Added TQt4 HEAD

122 files changed, 81810 insertions, 0 deletions

diff --git a/tqtinterface/qt4/src/tools/qfeatures.txt b/tqtinterface/qt4/src/tools/qfeatures.txt
new file mode 100644
index 0000000..857e71e
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/qfeatures.txt
@@ -0,0 +1,1314 @@
+Feature: WORKSPACE
+Section: Widgets
+Requires: SCROLLBAR VBOX TITLEBAR RESIZEHANDLER POPUPMENU LABEL TOOLBUTTON MAINWINDOW TOOLBAR MENUBAR
+Name: QWorkSpace
+SeeAlso: ???
+
+Feature: WHEELEVENT
+Section: Kernel
+Requires:
+Name: Wheel-mouse events
+SeeAlso: ???
+
+Feature: WMATRIX
+Section: Data structures
+Requires:
+Name: QWMatrix
+SeeAlso: ???
+
+Feature: STL
+Section: Data structures
+Requires:
+Name: Standard template library compatiblity
+SeeAlso: ???
+
+Feature: CANVAS
+Section: Widgets
+Requires: SCROLLVIEW BEZIER
+Name: QCanvas
+SeeAlso: ???
+
+Feature: TOOLBOX
+Section: Widgets
+Requires: ICONSET SCROLLVIEW TOOLTIP LAYOUT TOOLBUTTON
+Name: Tool box
+SeeAlso: ???
+
+
+Feature: TABLE
+Section: Widgets
+Requires: COMBOBOX HEADER CHECKBOX
+Name: QTable
+SeeAlso: ???
+
+Feature: XML
+Section: Data structures
+Requires: TEXTSTREAM TEXTCODEC REGEXP_CAPTURE
+Name: XML
+SeeAlso: ???
+
+Feature: SQL
+Section: Database
+Requires: STRINGLIST REGEXP_CAPTURE VARIANT SPRINTF DATESTRING
+Name: SQL classes
+SeeAlso: ???
+
+Feature: SQL_FORM
+Section: Database
+Requires: SQL PROPERTIES
+Name: QSqlForm
+SeeAlso: ???
+
+Feature: SQL_EDIT_WIDGETS
+Section: Database
+Requires: SQL SPINBOX COMBOBOX CHECKBOX DATETIMEEDIT
+Name: SQL value editor widgets
+SeeAlso: ???
+
+Feature: SQL_VIEW_WIDGETS
+Section: Database
+Requires: SQL_FORM SQL_EDIT_WIDGETS TABLE
+Name: SQL table widgets
+SeeAlso: ???
+
+Feature: STRINGLIST
+Section: Data structures
+Requires:
+Name: QStringList
+SeeAlso: ???
+
+Feature: REGEXP
+Section: Data structures
+Requires:
+Name: Regular expression capture
+SeeAlso: ???
+
+Feature: REGEXP_CAPTURE
+Section: Data structures
+Requires: REGEXP STRINGLIST
+Name: Regular expression capture
+SeeAlso: ???
+
+Feature: TEMPLATE_VARIANT
+Section: Data structures
+Requires: VARIANT STRINGLIST
+Name: Template classes in QVariant
+SeeAlso: ???
+
+Feature: VARIANT
+Section: Data structures
+Requires:
+Name: QVariant
+SeeAlso: ???
+
+Feature: REGEXP_OPTIM
+Section: Data structures
+Requires: REGEXP
+Name: Regular expression optimization
+SeeAlso: ???
+
+Feature: REGEXP_LOOKAHEAD
+Section: Data structures
+Requires: REGEXP
+Name: Regular expression lookahead
+SeeAlso: ???
+
+Feature: REGEXP_INTERVAL
+Section: Data structures
+Requires: REGEXP
+Name: Regular expression interval
+SeeAlso: ???
+
+Feature: REGEXP_ESCAPE
+Section: Data structures
+Requires: REGEXP
+Name: Regular expression escape
+SeeAlso: ???
+
+Feature: REGEXP_CCLASS
+Section: Data structures
+Requires: REGEXP
+Name: Regular expression character-class
+SeeAlso: ???
+
+Feature: REGEXP_BACKREF
+Section: Data structures
+Requires: REGEXP
+Name: Regular expression back-reference
+SeeAlso: ???
+
+Feature: REGEXP_ANCHOR_ALT
+Section: Data structures
+Requires: REGEXP
+Name: Regular expression anchors
+SeeAlso: ???
+
+Feature: REGEXP_WILDCARD
+Section: Data structures
+Requires: REGEXP
+Name: Regular expression wildcard
+SeeAlso: ???
+
+Feature: SPRINTF
+Section: Data structures
+Requires: REGEXP
+Name: QString::sprintf()
+SeeAlso: ???
+
+Feature: QUUID_STRING
+Section: Data structures
+Requires: STRINGLIST
+Name: Convert UUID to/from string
+SeeAlso: ???
+
+Feature: TEXTDATE
+Section: Data structures
+Requires: STRINGLIST DATESTRING
+Name: Month and day names in dates
+SeeAlso: ???
+
+Feature: DATESTRING
+Section: Data structures
+Requires:
+Name: QDate/QTime/QDateTime toString() and fromString()
+SeeAlso: ???
+
+Feature: ICONSET
+Section: Images
+Requires: IMAGEIO IMAGE_SMOOTHSCALE PALETTE IMAGE_HEURISTIC_MASK
+Name: QIconSet
+SeeAlso: ???
+
+Feature: DIR
+Section: File I/O
+Requires: STRINGLIST REGEXP
+Name: QDir
+SeeAlso: ???
+
+Feature: PALETTE
+Section: Kernel
+Requires:
+Name: Palettes
+SeeAlso: ???
+
+Feature: TEXTSTREAM
+Section: File I/O
+Requires:
+Name: QTextStream
+SeeAlso: ???
+
+Feature: DATASTREAM
+Section: File I/O
+Requires:
+Name: QDataStream
+SeeAlso: ???
+
+Feature: LIBRARY
+Section: File I/O
+Requires: REGEXP
+Name: Shared library wrapper
+SeeAlso: ???
+
+Feature: COMPONENT
+Section: File I/O
+Requires: QUUID_STRING SETTINGS SPRINTF LIBRARY DATESTRING
+Name: Dynamic module linking
+SeeAlso: ???
+
+Feature: SETTINGS
+Section: File I/O
+Requires: DIR TEXTSTREAM REGEXP_CAPTURE
+Name: Persistent application settings
+SeeAlso: ???
+
+Feature: SIGNALMAPPER
+Section: Widgets
+Requires:
+Name: QSignalMapper
+SeeAlso: ???
+
+Feature: IMAGEIO
+Section: Images
+Requires: REGEXP
+Name: Image formats
+SeeAlso: ???
+
+Feature: IMAGEIO_BMP
+Section: Images
+Requires: IMAGEIO DATASTREAM
+Name: BMP image I/O
+SeeAlso: ???
+
+Feature: IMAGEIO_PPM
+Section: Images
+Requires: IMAGEIO
+Name: PPM image I/O
+SeeAlso: ???
+
+Feature: IMAGEIO_XBM
+Section: Images
+Requires: IMAGEIO
+Name: XBM image I/O
+SeeAlso: ???
+
+Feature: IMAGEIO_XPM
+Section: Images
+Requires: IMAGEIO SPRINTF TEXTSTREAM
+Name: XPM image I/O
+SeeAlso: ???
+
+Feature: IMAGEIO_PNG
+Section: Images
+Requires: IMAGEIO
+Name: PNG image I/O
+SeeAlso: ???
+
+Feature: IMAGEIO_MNG
+Section: Images
+Requires: IMAGEIO
+Name: MNG image I/O
+SeeAlso: ???
+
+Feature: IMAGEIO_JPEG
+Section: Images
+Requires: IMAGEIO
+Name: JPEG image I/O
+SeeAlso: ???
+
+Feature: ASYNC_IO
+Section: Images
+Requires:
+Name: Asynchronous I/O
+SeeAlso: ???
+
+Feature: ASYNC_IMAGE_IO
+Section: Images
+Requires: IMAGEIO
+Name: Asynchronous image I/O
+SeeAlso: ???
+
+Feature: MOVIE
+Section: Images
+Requires: ASYNC_IO ASYNC_IMAGE_IO
+Name: Animated images
+SeeAlso: ???
+
+Feature: FREETYPE
+Section: Fonts
+Requires:
+Name: Freetype font engine
+SeeAlso: ???
+
+Feature: BDF
+Section: Fonts
+Requires: TEXTSTREAM STRINGLIST
+Name: BDF font files
+SeeAlso: ???
+
+Feature: FONTDATABASE
+Section: Fonts
+Requires: STRINGLIST
+Name: QFontDatabase
+SeeAlso: ???
+
+Feature: TRANSLATION
+Section: Internationalization
+Requires: DATASTREAM
+Name: Translations via TQT_BASE_OBJECT_NAME::tr()
+SeeAlso: ???
+
+Feature: TRANSLATION_UTF8
+Section: Internationalization
+Requires: TRANSLATION TEXTCODEC
+Name: Translations via TQT_BASE_OBJECT_NAME::trUtf8()
+SeeAlso: ???
+
+Feature: TEXTCODEC
+Section: Internationalization
+Requires:
+Name: Character set conversions
+SeeAlso: ???
+
+Feature: CODECS
+Section: Internationalization
+Requires: TEXTCODEC
+Name: Non-Unicode text conversions
+SeeAlso: ???
+
+Feature: BIG_CODECS
+Section: Internationalization
+Requires: CODEC_HEBREW
+Name: Big Codecs (eg. CJK)
+SeeAlso: ???
+
+Feature: CODEC_HEBREW
+Section: Internationalization
+Requires: CODECS COMPLEXTEXT
+Name: Hebrew Codec
+SeeAlso: ???
+
+Feature: UNICODETABLES
+Section: Internationalization
+Requires:
+Name: Unicode property tables
+SeeAlso: ???
+
+Feature: MIME
+Section: File I/O
+Requires: DIR IMAGEIO TEXTCODEC
+Name: MIME
+SeeAlso: ???
+
+Feature: RICHTEXT
+Section: Widgets
+Requires: STYLE LAYOUT STRINGLIST TEXTSTREAM
+Name: RichText (HTML) display
+SeeAlso: ???
+
+Feature: TEXTCUSTOMITEM
+Section: Widgets
+Requires: RICHTEXT MIME
+Name: RichText (HTML) tables and images
+SeeAlso: ???
+
+
+Feature: COMPLEXTEXT
+Section: Internationalization
+Requires: RICHTEXT
+Name: Complex scripts (eg. BiDi)
+SeeAlso: ???
+
+Feature: DOM
+Section: File I/O
+Requires: XML MIME
+Name: Document Object Model
+SeeAlso: ???
+
+Feature: SOUND
+Section: Kernel
+Requires:
+Name: Playing sounds
+SeeAlso: ???
+
+Feature: QWS_SOUNDSERVER
+Section: Qt/Embedded-specific
+Requires: SOUND DIR DNS
+Name: Server to play sound
+SeeAlso: ???
+
+Feature: PROPERTIES
+Section: Kernel
+Requires: VARIANT STRINGLIST ICONSET
+Name: Properties
+SeeAlso: ???
+
+Feature: NETWORK
+Section: Networking
+Requires:
+Name: Networking
+SeeAlso: ???
+
+Feature: DNS
+Section: Networking
+Requires: NETWORK STRINGLIST TEXTSTREAM SPRINTF
+Name: DNS
+SeeAlso: ???
+
+Feature: URL
+Section: Networking
+Requires: DIR
+Name: URL parser
+SeeAlso: ???
+
+Feature: NETWORKPROTOCOL
+Section: Networking
+Requires: TEXTCODEC URL
+Name: Network file access
+SeeAlso: ???
+
+Feature: NETWORKPROTOCOL_FTP
+Section: Networking
+Requires: NETWORKPROTOCOL DNS TEXTDATE
+Name: FTP file access
+SeeAlso: ???
+
+Feature: NETWORKPROTOCOL_HTTP
+Section: Networking
+Requires: NETWORKPROTOCOL DNS
+Name: HTTP file access
+SeeAlso: ???
+
+Feature: PROCESS
+Section: File I/O
+Requires: STRINGLIST REGEXP
+Name: External process invocation.
+SeeAlso: ???
+
+Feature: QWS_MULTIPROCESS
+Section: Qt/Embedded-specific
+Requires: NETWORK
+Name: Multi-process architecture
+SeeAlso: ???
+
+Feature: COP
+Section: Networking
+Requires: DATASTREAM
+Name: QCop IPC
+SeeAlso: ???
+
+Feature: QWS_KEYBOARD
+Section: Qt/Embedded-specific
+Requires:
+Name: Console keyboard
+SeeAlso: ???
+
+Feature: QWS_KBD_SL5000
+Section: Qt/Embedded-specific
+Requires: QWS_KEYBOARD
+Name: Keyboard for SHARP Zaurus SL5xxx tqdevices
+SeeAlso: ???
+
+Feature: QWS_CURSOR
+Section: Qt/Embedded-specific
+Requires: CURSOR
+Name: Visible cursor
+SeeAlso: ???
+
+Feature: QWS_ALPHA_CURSOR
+Section: Qt/Embedded-specific
+Requires:
+Name: Alpha-blended cursor
+SeeAlso: ???
+
+Feature: QWS_MACH64
+Section: Qt/Embedded-specific
+Requires:
+Name: Mach64 acceleration
+SeeAlso: ???
+
+Feature: QWS_VOODOO3
+Section: Qt/Embedded-specific
+Requires:
+Name: Voodoo3 acceleration
+SeeAlso: ???
+
+Feature: QWS_MATROX
+Section: Qt/Embedded-specific
+Requires:
+Name: Matrox MGA acceleration
+SeeAlso: ???
+
+Feature: QWS_REPEATER
+Section: Qt/Embedded-specific
+Requires:
+Name: Repeater display
+SeeAlso: ???
+
+Feature: QWS_VFB
+Section: Qt/Embedded-specific
+Requires:
+Name: Virtual frame buffer
+SeeAlso: ???
+
+Feature: QWS_TRANSFORMED
+Section: Qt/Embedded-specific
+Requires: QWS_LINUXFB
+Name: Transformed frame buffer
+SeeAlso: ???
+
+Feature: QWS_LINUXFB
+Section: Qt/Embedded-specific
+Requires:
+Name: Linux framebuffer
+SeeAlso: ???
+
+Feature: QWS_VNC
+Section: Qt/Embedded-specific
+Requires: NETWORK
+Name: Remote frame buffer (VNC)
+SeeAlso: ???
+
+Feature: QWS_SHADOWFB
+Section: Qt/Embedded-specific
+Requires: 
+Name: Shadow frame buffer
+SeeAlso: ???
+
+Feature: QWS_DEPTH_1
+Section: Qt/Embedded-specific
+Requires:
+Name: 1-bit monochrome
+SeeAlso: ???
+
+Feature: QWS_DEPTH_4
+Section: Qt/Embedded-specific
+Requires:
+Name: 4-bit grayscale
+SeeAlso: ???
+
+Feature: QWS_VGA_16
+Section: Qt/Embedded-specific
+Requires:
+Name: 4-bit VGA
+SeeAlso: ???
+
+Feature: QWS_DEPTH_8GRAYSCALE
+Section: Qt/Embedded-specific
+Requires:
+Name: 8-bit grayscale
+SeeAlso: ???
+
+Feature: QWS_DEPTH_8
+Section: Qt/Embedded-specific
+Requires:
+Name: 8-bit color
+SeeAlso: ???
+
+Feature: QWS_DEPTH_16
+Section: Qt/Embedded-specific
+Requires:
+Name: 15 or 16-bit color
+SeeAlso: ???
+
+Feature: QWS_DEPTH_24
+Section: Qt/Embedded-specific
+Requires:
+Name: 24-bit color
+SeeAlso: ???
+
+Feature: QWS_DEPTH_32
+Section: Qt/Embedded-specific
+Requires:
+Name: 32-bit color
+SeeAlso: ???
+
+Feature: QWS_DEPTH_32_BGR
+Section: Qt/Embedded-specific
+Requires: QWS_DEPTH_32
+Name: 32-bit color, BGR order
+SeeAlso: ???
+
+Feature: QWS_MANAGER
+Section: Qt/Embedded-specific
+Requires:
+Name: Window Manager
+SeeAlso: ???
+
+Feature: QWS_KDE2_WM_STYLE
+Section: Qt/Embedded-specific
+Requires: QWS_MANAGER
+Name: The "KDE2" style
+SeeAlso: ???
+
+Feature: QWS_HYDRO_WM_STYLE
+Section: Qt/Embedded-specific
+Requires: QWS_MANAGER
+Name: The "Hydro" style
+SeeAlso: ???
+
+Feature: QWS_BEOS_WM_STYLE
+Section: Qt/Embedded-specific
+Requires: QWS_MANAGER
+Name: The "BeOS" style
+SeeAlso: ???
+
+Feature: QWS_KDE_WM_STYLE
+Section: Qt/Embedded-specific
+Requires: QWS_MANAGER
+Name: The "KDE" style
+SeeAlso: ???
+
+Feature: QWS_WINDOWS_WM_STYLE
+Section: Qt/Embedded-specific
+Requires: QWS_MANAGER
+Name: The "Windows" style
+SeeAlso: ???
+
+Feature: QWS_MOUSE_AUTO
+Section: Qt/Embedded-specific
+Requires:
+Name: Autodetecting mouse driver
+SeeAlso: ???
+
+Feature: QWS_MOUSE_MANUAL
+Section: Qt/Embedded-specific
+Requires:
+Name: Non-autodetecting mouse driver
+SeeAlso: ???
+
+Feature: QWS_SAVEFONTS
+Section: Qt/Embedded-specific
+Requires:
+Name: Saving of fonts
+SeeAlso: ???
+
+Feature: QWS_GFX_SPEED
+Section: Qt/Embedded-specific
+Requires:
+Name: Favour code size over graphics speed
+SeeAlso: ???
+
+Feature: QWS_PROPERTIES
+Section: Qt/Embedded-specific
+Requires:
+Name: Qt/Embedded window system properties.
+SeeAlso: ???
+
+Feature: CLIPBOARD
+Section: Kernel
+Requires: QWS_PROPERTIES MIME
+Name: Cut and paste
+SeeAlso: ???
+
+Feature: DRAGANDDROP
+Section: Kernel
+Requires: MIME QWS_PROPERTIES IMAGEIO_XPM
+Name: Drag and drop
+SeeAlso: ???
+
+Feature: MIMECLIPBOARD
+Section: Kernel
+Requires: CLIPBOARD
+Name: Cut and paste non-text
+SeeAlso: ???
+
+Feature: DRAWUTIL
+Section: Kernel
+Requires: SPRINTF PALETTE
+Name: Drawing utility functions
+SeeAlso: ???
+
+Feature: IMAGE_TRUECOLOR
+Section: Images
+Requires:
+Name: TrueColor QImage
+SeeAlso: ???
+
+Feature: IMAGE_SMOOTHSCALE
+Section: Images
+Requires:
+Name: Smooth QImage scaling
+SeeAlso: ???
+
+Feature: IMAGE_DITHER_TO_1
+Section: Images
+Requires:
+Name: Dither QImage to 1-bit image
+SeeAlso: ???
+
+Feature: IMAGE_HEURISTIC_MASK
+Section: Images
+Requires:
+Name: QImage::createHeuristicMask()
+SeeAlso: ???
+
+Feature: IMAGE_MIRROR
+Section: Images
+Requires:
+Name: QImage mirroring
+SeeAlso: ???
+
+Feature: IMAGE_TEXT
+Section: Images
+Requires: STRINGLIST
+Name: Image file text strings
+SeeAlso: ???
+
+Feature: IMAGE_16_BIT
+Section: Qt/Embedded-specific
+Requires: IMAGE_TRUECOLOR
+Name: 16-bit QImage
+SeeAlso: ???
+
+Feature: CURSOR
+Section: Kernel
+Requires:
+Name: Cursors
+SeeAlso: ???
+
+Feature: COLORNAMES
+Section: Painting
+Requires:
+Name: Named colors
+SeeAlso: ???
+
+Feature: TRANSFORMATIONS
+Section: Painting
+Requires: WMATRIX
+Name: Scaling and rotation
+SeeAlso: ???
+
+Feature: PIXMAP_TRANSFORMATION
+Section: Painting
+Requires: WMATRIX
+Name: Pixmap transformations
+SeeAlso: ???
+
+Feature: IMAGE_TRANSFORMATION
+Section: Painting
+Requires: PIXMAP_TRANSFORMATION
+Name: Image transformations
+SeeAlso: ???
+
+Feature: SVG
+Section: Painting
+Requires: DOM TRANSFORMATIONS SPRINTF
+Name: Scalable Vector Graphics (SVG)
+SeeAlso: ???
+
+Feature: BEZIER
+Section: Painting
+Requires:
+Name: Bezier curves
+SeeAlso: ???
+
+Feature: PRINTER
+Section: Painting
+Requires: TEXTSTREAM SPRINTF FONTDATABASE DATESTRING REGEXP_CAPTURE
+Name: Printing
+SeeAlso: ???
+
+Feature: PICTURE
+Section: Painting
+Requires: DATASTREAM IMAGEIO
+Name: QPicture
+SeeAlso: ???
+
+Feature: LAYOUT
+Section: Kernel
+Requires:
+Name: Automatic widget tqlayout
+SeeAlso: ???
+
+Feature: STYLE
+Section: Widgets
+Requires: DRAWUTIL
+Name: QStyle
+SeeAlso: ???
+
+Feature: WIDGET_TOPEXTRA
+Section: Kernel
+Requires: IMAGE_HEURISTIC_MASK
+Name: Window icon and caption
+SeeAlso: ???
+
+Feature: DIALOG
+Section: Widgets
+Requires:
+Name: Dialogs
+SeeAlso: ???
+
+Feature: SEMIMODAL
+Section: Widgets
+Requires: DIALOG
+Name: Semi-modal dialogs
+SeeAlso: ???
+
+Feature: FRAME
+Section: Widgets
+Requires: STYLE
+Name: Framed widgets
+SeeAlso: ???
+
+Feature: EFFECTS
+Section: Kernel
+Requires:
+Name: Special widget effects (fading, scrolling)
+SeeAlso: ???
+
+Feature: LABEL
+Section: Widgets
+Requires: FRAME
+Name: QLabel
+SeeAlso: ???
+
+Feature: TOOLBAR
+Section: Widgets
+Requires: MAINWINDOW
+Name: Toolbars
+SeeAlso: ???
+
+Feature: BUTTON
+Section: Widgets
+Requires:
+Name: Buttons
+SeeAlso: ???
+
+Feature: CHECKBOX
+Section: Widgets
+Requires: BUTTON STYLE
+Name: Check-boxes
+SeeAlso: ???
+
+Feature: RADIOBUTTON
+Section: Widgets
+Requires: BUTTON STYLE
+Name: Radio-buttons
+SeeAlso: ???
+
+Feature: TOOLBUTTON
+Section: Widgets
+Requires: BUTTON ICONSET STYLE
+Name: Tool-buttons
+SeeAlso: ???
+
+Feature: GRID
+Section: Widgets
+Requires: LAYOUT FRAME
+Name: Grid tqlayout widgets
+SeeAlso: ???
+
+Feature: GROUPBOX
+Section: Widgets
+Requires: FRAME LAYOUT
+Name: Group boxes
+SeeAlso: ???
+
+Feature: BUTTONGROUP
+Section: Widgets
+Requires: GROUPBOX BUTTON RADIOBUTTON
+Name: Button groups
+SeeAlso: ???
+
+Feature: HGROUPBOX
+Section: Widgets
+Requires: GROUPBOX
+Name: Horizontal group boxes
+SeeAlso: ???
+
+Feature: VGROUPBOX
+Section: Widgets
+Requires: HGROUPBOX
+Name: Vertical group boxes
+SeeAlso: ???
+
+Feature: HBUTTONGROUP
+Section: Widgets
+Requires: BUTTONGROUP
+Name: Horizontal button groups
+SeeAlso: ???
+
+Feature: VBUTTONGROUP
+Section: Widgets
+Requires: HBUTTONGROUP
+Name: Vertical button groups
+SeeAlso: ???
+
+Feature: HBOX
+Section: Widgets
+Requires: LAYOUT FRAME
+Name: Horizontal box tqlayout widgets
+SeeAlso: ???
+
+Feature: VBOX
+Section: Widgets
+Requires: HBOX
+Name: Vertical box tqlayout widgets
+SeeAlso: ???
+
+Feature: MAINWINDOW
+Section: Widgets
+Requires: STRINGLIST POPUPMENU TITLEBAR RESIZEHANDLER TOOLBUTTON STATUSBAR
+Name: Main-windows
+SeeAlso: ???
+
+Feature: RESIZEHANDLER
+Section: Widgets
+Requires: FRAME
+Name: Internal resize handler
+SeeAlso: ???
+
+Feature: MENUDATA
+Section: Widgets
+Requires: ICONSET VARIANT
+Name: Menu-oriented widgets
+SeeAlso: ???
+
+Feature: POPUPMENU
+Section: Widgets
+Requires: MENUDATA FRAME
+Name: Popup-menus
+SeeAlso: ???
+
+Feature: MENUBAR
+Section: Widgets
+Requires: POPUPMENU
+Name: Menu bars
+SeeAlso: ???
+
+Feature: PUSHBUTTON
+Section: Widgets
+Requires: BUTTON STYLE
+Name: Push-buttons
+SeeAlso: ???
+
+Feature: PROGRESSBAR
+Section: Widgets
+Requires: FRAME
+Name: Progress bars
+SeeAlso: ???
+
+Feature: RANGECONTROL
+Section: Widgets
+Requires:
+Name: Range-control widgets
+SeeAlso: ???
+
+Feature: SCROLLBAR
+Section: Widgets
+Requires: RANGECONTROL STYLE
+Name: Scroll bars
+SeeAlso: ???
+
+Feature: SLIDER
+Section: Widgets
+Requires: RANGECONTROL STYLE
+Name: Sliders
+SeeAlso: ???
+
+Feature: DIAL
+Section: Widgets
+Requires: RANGECONTROL STYLE
+Name: Dials
+SeeAlso: ???
+
+Feature: SPINWIDGET
+Section: Widgets
+Requires: FRAME
+Name: Spinbox control widget
+SeeAlso: ???
+
+Feature: SCROLLVIEW
+Section: Widgets
+Requires: SCROLLBAR FRAME
+Name: Scrollable view widgets
+SeeAlso: ???
+
+Feature: ICONVIEW
+Section: Widgets
+Requires: SCROLLVIEW IMAGEIO_XPM IMAGE_HEURISTIC_MASK
+Name: QIconView
+SeeAlso: ???
+
+Feature: GRIDVIEW
+Section: Widgets
+Requires: SCROLLVIEW
+Name: QGridView
+SeeAlso: ???
+
+Feature: TEXTVIEW
+Section: Widgets
+Requires: TEXTEDIT
+Name: QTextView
+SeeAlso: ???
+
+Feature: TEXTEDIT
+Section: Widgets
+Requires: RICHTEXT SCROLLVIEW
+Name: Rich text edit
+SeeAlso: ???
+
+Feature: SYNTAXHIGHLIGHTER
+Section: Widgets
+Requires: TEXTEDIT
+Name: Rich text syntax highlighting
+SeeAlso: ???
+
+Feature: SPLASHSCREEN
+Section: Widgets
+Requires: IMAGEIO
+Name: Splash screen widget
+SeeAlso: ???
+
+
+Feature: TABLEVIEW
+Section: Widgets
+Requires: SCROLLBAR
+Name: Table-like widgets
+SeeAlso: ???
+
+Feature: LINEEDIT
+Section: Widgets
+Requires: FRAME
+Name: Single-line edits
+SeeAlso: ???
+
+Feature: MULTILINEEDIT
+Section: Widgets
+Requires: TEXTEDIT
+Name: Multi-line edits
+SeeAlso: ???
+
+Feature: SPINBOX
+Section: Widgets
+Requires: RANGECONTROL SPINWIDGET LINEEDIT VALIDATOR
+Name: Spin boxes
+SeeAlso: ???
+
+Feature: SPLITTER
+Section: Widgets
+Requires: FRAME LAYOUT
+Name: Splitters
+SeeAlso: ???
+
+Feature: STATUSBAR
+Section: Widgets
+Requires: LAYOUT STYLE
+Name: tqStatus bars
+SeeAlso: ???
+
+Feature: TABBAR
+Section: Widgets
+Requires: TOOLBUTTON
+Name: Tab-bars
+SeeAlso: ???
+
+Feature: TABWIDGET
+Section: Widgets
+Requires: TABBAR WIDGETSTACK
+Name: Tab widgets
+SeeAlso: ???
+
+Feature: TOOLTIP
+Section: Widgets
+Requires: LABEL
+Name: Tool tips
+SeeAlso: ???
+
+Feature: VALIDATOR
+Section: Widgets
+Requires:
+Name: Input validators
+SeeAlso: ???
+
+Feature: WHATSTHIS
+Section: Widgets
+Requires: TOOLTIP TOOLBUTTON
+Name: "What's this" help
+SeeAlso: ???
+
+Feature: WIDGETSTACK
+Section: Widgets
+Requires: FRAME
+Name: Widget stacks
+SeeAlso: ???
+
+Feature: TEXTBROWSER
+Section: Widgets
+Requires: TEXTVIEW MIME
+Name: QTextBrowser
+SeeAlso: ???
+
+Feature: LISTBOX
+Section: Widgets
+Requires: SCROLLVIEW STRINGLIST
+Name: QListBox
+SeeAlso: ???
+
+Feature: ACCEL
+Section: Kernel
+Requires: SPRINTF
+Name: Keyboard accelerators and shortcuts
+SeeAlso: ???
+
+Feature: SIZEGRIP
+Section: Widgets
+Requires: STYLE
+Name: QSizeGrip
+SeeAlso: ???
+
+Feature: HEADER
+Section: Widgets
+Requires: STYLE ICONSET
+Name: QHeader
+SeeAlso: ???
+
+Feature: TITLEBAR
+Section: Kernel
+Requires: STYLE
+Name: Internal titlebar widget
+SeeAlso: ???
+
+Feature: LCDNUMBER
+Section: Widgets
+Requires: FRAME
+Name: QLCDNumber
+SeeAlso: ???
+
+Feature: ACTION
+Section: Kernel
+Requires: TOOLBUTTON COMBOBOX
+Name: QAction
+SeeAlso: ???
+
+Feature: COMBOBOX
+Section: Widgets
+Requires: LISTBOX LINEEDIT POPUPMENU
+Name: QComboBox
+SeeAlso: ???
+
+Feature: LISTVIEW
+Section: Widgets
+Requires: SCROLLVIEW HEADER LINEEDIT
+Name: QListView
+SeeAlso: ???
+
+Feature: STYLE_WINDOWS
+Section: Widgets
+Requires: STYLE
+Name: Windows style
+SeeAlso: ???
+
+Feature: STYLE_MOTIF
+Section: Widgets
+Requires: STYLE
+Name: Motif style
+SeeAlso: ???
+
+Feature: STYLE_INTERLACE
+Section: Widgets
+Requires: STYLE_MOTIF
+Name: Interlace-friendly style
+SeeAlso: ???
+
+Feature: STYLE_COMPACT
+Section: Widgets
+Requires: STYLE_WINDOWS
+Name: Compact Windows style
+SeeAlso: ???
+
+Feature: STYLE_PLATINUM
+Section: Widgets
+Requires: STYLE_WINDOWS
+Name: Platinum style
+SeeAlso: ???
+
+Feature: STYLE_AQUA
+Section: Widgets
+Requires: STYLE_WINDOWS IMAGE_TRANSFORMATION
+Name: Aqua style
+SeeAlso: ???
+
+Feature: STYLE_CDE
+Section: Widgets
+Requires: STYLE_MOTIF TRANSFORMATIONS
+Name: CDE style
+SeeAlso: ???
+
+Feature: STYLE_SGI
+Section: Widgets
+Requires: STYLE_MOTIF TRANSFORMATIONS BUTTON SCROLLBAR SLIDER LINEEDIT  MENUBAR
+Name: SGI style
+SeeAlso: ???
+
+Feature: STYLE_MOTIFPLUS
+Section: Widgets
+Requires: STYLE_MOTIF TRANSFORMATIONS BUTTON SCROLLBAR SLIDER
+Name: Motif-plus style
+SeeAlso: ???
+
+Feature: COLORDIALOG
+Section: Widgets
+Requires: DIALOG LABEL PUSHBUTTON LINEEDIT VALIDATOR GRIDVIEW LAYOUT
+Name: QColorDialog
+SeeAlso: ???
+
+Feature: MESSAGEBOX
+Section: Widgets
+Requires: DIALOG PUSHBUTTON LABEL
+Name: QMessageBox
+SeeAlso: ???
+
+Feature: TABDIALOG
+Section: Widgets
+Requires: DIALOG PUSHBUTTON LAYOUT TABWIDGET
+Name: QTabDialog
+SeeAlso: ???
+
+Feature: WIZARD
+Section: Widgets
+Requires: DIALOG WIDGETSTACK PUSHBUTTON LAYOUT LABEL
+Name: QWizard
+SeeAlso: ???
+
+Feature: FILEDIALOG
+Section: Widgets
+Requires: MESSAGEBOX LISTVIEW NETWORKPROTOCOL COMBOBOX SEMIMODAL REGEXP_CAPTURE TOOLBUTTON BUTTONGROUP VBOX SPLITTER PROGRESSBAR WIDGETSTACK DATESTRING
+Name: QFileDialog
+SeeAlso: ???
+
+Feature: FONTDIALOG
+Section: Widgets
+Requires: DIALOG FONTDATABASE COMBOBOX LABEL CHECKBOX PUSHBUTTON VGROUPBOX VALIDATOR
+Name: QFontDialog
+SeeAlso: ???
+
+Feature: PRINTDIALOG
+Section: Widgets
+Requires: DIALOG LISTVIEW PRINTER COMBOBOX LABEL BUTTONGROUP SPINBOX RADIOBUTTON PUSHBUTTON DIR
+Name: QPrintDialog
+SeeAlso: ???
+
+Feature: PROGRESSDIALOG
+Section: Widgets
+Requires: SEMIMODAL LABEL PUSHBUTTON PROGRESSBAR
+Name: QProgressDialog
+SeeAlso: ???
+
+Feature: INPUTDIALOG
+Section: Widgets
+Requires: DIALOG COMBOBOX LABEL PUSHBUTTON SPINBOX WIDGETSTACK LAYOUT
+Name: QInputDialog
+SeeAlso: ???
+
+Feature: ERRORMESSAGE
+Section: Widgets
+Requires: DIALOG PUSHBUTTON LABEL CHECKBOX TEXTVIEW
+Name: QErrorMessage
+SeeAlso: ???
+
+Feature: SESSIONMANAGER
+Section: Kernel
+Requires: STRINGLIST
+Name: Session management
+SeeAlso: ???
+
+Feature: DATETIMEEDIT
+Section: Widgets
+Requires: RICHTEXT SPINWIDGET DATESTRING
+Name: QDateTimeEdit
+SeeAlso: ???
+
+Feature: TEXTCODECPLUGIN
+Section: Internationalization
+Requires: COMPONENT TEXTCODEC
+Name: QTextCodecPlugin
+SeeAlso: ???
+
+
+Feature: IMAGEFORMATPLUGIN
+Section: Images
+Requires: COMPONENT IMAGEIO
+Name: QImageFormatPlugin
+SeeAlso: ???
+
+
+Feature: WIDGETPLUGIN
+Section: Widgets
+Requires: COMPONENT ICONSET
+Name: QWidgetPlugin
+SeeAlso: ???
+
+
+Feature: DIRECTPAINTER
+Section: Painting
+Requires:
+Name: QDirectPainter
+SeeAlso: ???
+
+
+Feature: DIALOGBUTTONS
+Section: Widgets
+Requires: LAYOUT STYLE PUSHBUTTON
+Name: Experimental internal class
+SeeAlso: ???
diff --git a/tqtinterface/qt4/src/tools/qt_tools.pri b/tqtinterface/qt4/src/tools/qt_tools.pri
new file mode 100644
index 0000000..44c0c62
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/qt_tools.pri
@@ -0,0 +1,150 @@
+# Qt tools module
+
+tools {
+	TOOLS_P		= tools
+	HEADERS +=  $$TOOLS_H/tqmemarray.h \
+		  $$TOOLS_H/tqasciicache.h \
+		  $$TOOLS_H/tqasciidict.h \
+		  $$TOOLS_H/tqbitarray.h \
+		  $$TOOLS_H/tqbuffer.h \
+		  $$TOOLS_H/tqcache.h \
+		  $$TOOLS_H/tqcleanuphandler.h \
+		  $$TOOLS_P/tqcomponentfactory_p.h \
+		  $$TOOLS_P/tqcomlibrary_p.h \
+		  $$TOOLS_H/tqcstring.h \
+		  $$TOOLS_H/tqdatastream.h \
+		  $$TOOLS_H/tqdatetime.h \
+		  $$TOOLS_H/tqdeepcopy.h \
+		  $$TOOLS_H/tqdict.h \
+		  $$TOOLS_H/tqdir.h \
+		  $$TOOLS_P/tqdir_p.h \
+		  $$TOOLS_H/tqfile.h \
+		  $$TOOLS_P/tqfiledefs_p.h \
+		  $$TOOLS_H/tqfileinfo.h \
+		  $$TOOLS_H/tqgarray.h \
+		  $$TOOLS_H/tqgcache.h \
+		  $$TOOLS_H/tqgdict.h \
+		  $$TOOLS_H/tqgeneric.h \
+		  $$TOOLS_H/tqglist.h \
+		  $$TOOLS_H/tqglobal.h \
+		  $$TOOLS_P/tqgpluginmanager_p.h \
+		  $$TOOLS_H/tqgvector.h \
+		  $$TOOLS_H/tqintcache.h \
+		  $$TOOLS_H/tqintdict.h \
+		  $$TOOLS_H/tqiodevice.h \
+		  $$TOOLS_H/tqlibrary.h \
+		  $$TOOLS_P/tqlibrary_p.h \
+		  $$TOOLS_H/tqlocale.h \
+		  $$TOOLS_P/tqlocale_p.h \
+		  $$TOOLS_H/tqptrlist.h \
+		  $$TOOLS_H/tqmap.h \
+		  $$TOOLS_H/tqmutex.h \
+		  $$TOOLS_P/tqmutex_p.h \
+		  $$TOOLS_P/tqmutexpool_p.h \
+		  $$TOOLS_P/tqpluginmanager_p.h \
+		  $$TOOLS_H/tqptrcollection.h \
+		  $$TOOLS_H/tqptrdict.h \
+		  $$TOOLS_H/tqptrqueue.h \
+		  $$TOOLS_H/tqregexp.h \
+		  $$TOOLS_H/tqsemaphore.h \
+		  $$TOOLS_H/tqsettings.h \
+		  $$TOOLS_P/tqsettings_p.h \
+		  $$TOOLS_H/tqshared.h \
+		  $$TOOLS_H/tqsortedlist.h \
+		  $$TOOLS_H/tqptrstack.h \
+		  $$TOOLS_H/tqstring.h \
+		  $$TOOLS_H/tqstringlist.h \
+		  $$TOOLS_H/tqstrlist.h \
+		  $$TOOLS_H/tqstrvec.h \
+		  $$TOOLS_H/tqtextstream.h \
+		  $$TOOLS_P/tqthreadinstance_p.h \
+		  $$TOOLS_H/tqthreadstorage.h\
+		  $$TOOLS_P/tqunicodetables_p.h \
+		  $$TOOLS_H/tqptrvector.h \
+	          $$TOOLS_H/tqvaluelist.h \
+		  $$TOOLS_H/tqvaluestack.h \
+		  $$TOOLS_H/tqvaluevector.h \
+		  $$TOOLS_H/tqwaitcondition.h \
+		  $$TOOLS_P/tqcom_p.h \
+		  $$TOOLS_P/tqucom_p.h \
+		  $$TOOLS_H/tquuid.h
+
+	win32:SOURCES += $$TOOLS_CPP/tqdir_win.cpp \
+	 	  $$TOOLS_CPP/tqfile_win.cpp \
+		  $$TOOLS_CPP/tqfileinfo_win.cpp \
+		  $$TOOLS_CPP/tqlibrary_win.cpp \
+		  $$TOOLS_CPP/tqsettings_win.cpp \
+		  $$TOOLS_CPP/tqmutex_win.cpp \
+		  $$TOOLS_CPP/tqwaitcondition_win.cpp \
+		  $$TOOLS_CPP/tqthreadstorage_win.cpp \
+		  $$TOOLS_CPP/tqcriticalsection_p.cpp
+
+	win32-borland:SOURCES += $$TOOLS_CPP/tqwinexport.cpp
+
+	wince-* {
+		SOURCES -= $$TOOLS_CPP/tqdir_win.cpp \
+			   $$TOOLS_CPP/tqfile_win.cpp \
+			   $$TOOLS_CPP/tqfileinfo_win.cpp
+		SOURCES += $$TOOLS_CPP/tqdir_wce.cpp \
+			   $$TOOLS_CPP/tqfile_wce.cpp \
+			   $$TOOLS_CPP/tqfileinfo_wce.cpp
+	}
+
+        offmac:SOURCES += $$TOOLS_CPP/tqdir_mac.cpp \
+		  $$TOOLS_CPP/tqfile_mac.cpp \
+		  $$TOOLS_CPP/tqfileinfo_mac.cpp
+	else:unix:SOURCES += $$TOOLS_CPP/tqdir_unix.cpp \
+		  $$TOOLS_CPP/tqfile_unix.cpp \
+		  $$TOOLS_CPP/tqfileinfo_unix.cpp \
+		  $$TOOLS_CPP/tqmutex_unix.cpp \
+		  $$TOOLS_CPP/tqthreadstorage_unix.cpp \
+		  $$TOOLS_CPP/tqwaitcondition_unix.cpp
+
+        mac:!x11:!embedded:SOURCES += $$TOOLS_CPP/tqsettings_mac.cpp
+	mac {
+		SOURCES+=3rdparty/dlcompat/dlfcn.c
+		INCLUDEPATH+=3rdparty/dlcompat
+	    }
+	unix:SOURCES += $$TOOLS_CPP/tqlibrary_unix.cpp
+
+	SOURCES += $$TOOLS_CPP/tqbitarray.cpp \
+		  $$TOOLS_CPP/tqbuffer.cpp \
+		  $$TOOLS_CPP/tqcomponentfactory.cpp \
+		  $$TOOLS_CPP/tqcomlibrary.cpp \
+		  $$TOOLS_CPP/tqcstring.cpp \
+		  $$TOOLS_CPP/tqdatastream.cpp \
+		  $$TOOLS_CPP/tqdatetime.cpp \
+		  $$TOOLS_CPP/tqdeepcopy.cpp \
+		  $$TOOLS_CPP/tqdir.cpp \
+		  $$TOOLS_CPP/tqfile.cpp \
+		  $$TOOLS_CPP/tqfileinfo.cpp \
+		  $$TOOLS_CPP/tqgarray.cpp \
+		  $$TOOLS_CPP/tqgcache.cpp \
+		  $$TOOLS_CPP/tqgdict.cpp \
+		  $$TOOLS_CPP/tqglist.cpp \
+		  $$TOOLS_CPP/tqglobal.cpp \
+		  $$TOOLS_CPP/tqgpluginmanager.cpp \
+		  $$TOOLS_CPP/tqgvector.cpp \
+		  $$TOOLS_CPP/tqiodevice.cpp \
+		  $$TOOLS_CPP/tqlibrary.cpp \
+		  $$TOOLS_CPP/tqlocale.cpp \
+		  $$TOOLS_CPP/tqmap.cpp \
+		  $$TOOLS_CPP/tqmutexpool.cpp \
+		  $$TOOLS_CPP/tqptrcollection.cpp \
+		  $$TOOLS_CPP/tqregexp.cpp \
+		  $$TOOLS_CPP/tqstring.cpp \
+		  $$TOOLS_CPP/tqsemaphore.cpp \
+		  $$TOOLS_CPP/tqsettings.cpp \
+		  $$TOOLS_CPP/tqstringlist.cpp \
+		  $$TOOLS_CPP/tqtextstream.cpp \
+		  $$TOOLS_CPP/tqunicodetables.cpp \
+		  $$TOOLS_CPP/tqucom.cpp \
+		  $$TOOLS_CPP/tquuid.cpp
+
+        irix-cc* {
+                CXXFLAGS_PRELINK = $$TQMAKE_CXXFLAGS
+                CXXFLAGS_PRELINK -= -O2
+                QMAKE_PRE_LINK          = $(CXX) -c $$CXXFLAGS_PRELINK -O1 $(INCPATH) -o $(OBJECTS_DIR)/tqlocale.o tools/tqlocale.cpp
+        }
+}
+
diff --git a/tqtinterface/qt4/src/tools/tqasciicache.h b/tqtinterface/qt4/src/tools/tqasciicache.h
new file mode 100644
index 0000000..9a8d820
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqasciicache.h
@@ -0,0 +1,125 @@
+/****************************************************************************
+**
+** Definition of TQAsciiCache template/macro class
+**
+** Created : 950209
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQASCIICACHE_H
+#define TQASCIICACHE_H
+
+#ifndef TQT_H
+#include "tqgcache.h"
+#endif // TQT_H
+
+
+template<class type> 
+class TQAsciiCache
+#ifdef TQ_TQDOC
+	: public TQPtrCollection
+#else
+	: public TQGCache
+#endif
+{
+public:
+    TQAsciiCache( const TQAsciiCache<type> &c ) : TQGCache(c) {}
+    TQAsciiCache( int maxCost=100, int size=17, bool caseSensitive=TRUE,
+		 bool copyKeys=TRUE )
+	: TQGCache( maxCost, size, AsciiKey, caseSensitive, copyKeys ) {}
+   ~TQAsciiCache()			{ clear(); }
+    TQAsciiCache<type> &operator=( const TQAsciiCache<type> &c )
+			{ return (TQAsciiCache<type>&)TQGCache::operator=(c); }
+    int	  maxCost()   const		{ return TQGCache::maxCost(); }
+    int	  totalCost() const		{ return TQGCache::totalCost(); }
+    void  setMaxCost( int m )		{ TQGCache::setMaxCost(m); }
+    uint  count()     const		{ return TQGCache::count(); }
+    uint  size()      const		{ return TQGCache::size(); }
+    bool  isEmpty()   const		{ return TQGCache::count() == 0; }
+    void  clear()			{ TQGCache::clear(); }
+    bool  insert( const char *k, const type *d, int c=1, int p=0 )
+			{ return TQGCache::insert_other(k,(Item)d,c,p);}
+    bool  remove( const char *k )
+			{ return TQGCache::remove_other(k); }
+    type *take( const char *k )
+			{ return (type *)TQGCache::take_other(k); }
+    type *tqfind( const char *k, bool ref=TRUE ) const
+			{ return (type *)TQGCache::tqfind_other(k,ref);}
+    type *operator[]( const char *k ) const
+			{ return (type *)TQGCache::tqfind_other(k);}
+    void  statistics() const	      { TQGCache::statistics(); }
+private:
+    void  deleteItem( Item d );
+};
+
+#if !defined(TQ_BROKEN_TEMPLATE_SPECIALIZATION)
+template<> inline void TQAsciiCache<void>::deleteItem( TQPtrCollection::Item )
+{
+}
+#endif
+
+template<class type> inline void TQAsciiCache<type>::deleteItem( TQPtrCollection::Item d )
+{
+    if ( del_item ) delete (type *)d;
+}
+
+
+template<class type> 
+class TQAsciiCacheIterator : public TQGCacheIterator
+{
+public:
+    TQAsciiCacheIterator( const TQAsciiCache<type> &c ):TQGCacheIterator((TQGCache &)c) {}
+    TQAsciiCacheIterator( const TQAsciiCacheIterator<type> &ci)
+				: TQGCacheIterator( (TQGCacheIterator &)ci ) {}
+    TQAsciiCacheIterator<type> &operator=(const TQAsciiCacheIterator<type>&ci)
+	{ return ( TQAsciiCacheIterator<type>&)TQGCacheIterator::operator=( ci ); }
+    uint  count()   const     { return TQGCacheIterator::count(); }
+    bool  isEmpty() const     { return TQGCacheIterator::count() == 0; }
+    bool  atFirst() const     { return TQGCacheIterator::atFirst(); }
+    bool  atLast()  const     { return TQGCacheIterator::atLast(); }
+    type *toFirst()	      { return (type *)TQGCacheIterator::toFirst(); }
+    type *toLast()	      { return (type *)TQGCacheIterator::toLast(); }
+    operator type *() const   { return (type *)TQGCacheIterator::get(); }
+    type *current()   const   { return (type *)TQGCacheIterator::get(); }
+    const char *currentKey() const { return TQGCacheIterator::getKeyAscii(); }
+    type *operator()()	      { return (type *)TQGCacheIterator::operator()();}
+    type *operator++()	      { return (type *)TQGCacheIterator::operator++(); }
+    type *operator+=(uint j)  { return (type *)TQGCacheIterator::operator+=(j);}
+    type *operator--()	      { return (type *)TQGCacheIterator::operator--(); }
+    type *operator-=(uint j)  { return (type *)TQGCacheIterator::operator-=(j);}
+};
+
+
+#endif // TQASCIICACHE_H
diff --git a/tqtinterface/qt4/src/tools/tqasciidict.h b/tqtinterface/qt4/src/tools/tqasciidict.h
new file mode 100644
index 0000000..fdab8b2
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqasciidict.h
@@ -0,0 +1,123 @@
+/****************************************************************************
+**
+** Definition of TQAsciiDict template class
+**
+** Created : 920821
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQASCIIDICT_H
+#define TQASCIIDICT_H
+
+#ifndef TQT_H
+#include "tqgdict.h"
+#endif // TQT_H
+
+template<class type>
+class TQAsciiDict
+#ifdef TQ_TQDOC
+	: public TQPtrCollection
+#else
+	: public TQGDict
+#endif
+{
+public:
+    TQAsciiDict(int size=17, bool caseSensitive=TRUE, bool copyKeys=TRUE )
+	: TQGDict(size,AsciiKey,caseSensitive,copyKeys) {}
+    TQAsciiDict( const TQAsciiDict<type> &d ) : TQGDict(d) {}
+   ~TQAsciiDict()			{ clear(); }
+    TQAsciiDict<type> &operator=(const TQAsciiDict<type> &d)
+			{ return (TQAsciiDict<type>&)TQGDict::operator=(d); }
+    uint  count()   const		{ return TQGDict::count(); }
+    uint  size()    const		{ return TQGDict::size(); }
+    bool  isEmpty() const		{ return TQGDict::count() == 0; }
+
+    void  insert( const char *k, const type *d )
+					{ TQGDict::look_ascii(k,(Item)d,1); }
+    void  tqreplace( const char *k, const type *d )
+					{ TQGDict::look_ascii(k,(Item)d,2); }
+    bool  remove( const char *k )	{ return TQGDict::remove_ascii(k); }
+    type *take( const char *k )		{ return (type *)TQGDict::take_ascii(k); }
+    type *tqfind( const char *k ) const
+		{ return (type *)((TQGDict*)this)->TQGDict::look_ascii(k,0,0); }
+    type *operator[]( const char *k ) const
+		{ return (type *)((TQGDict*)this)->TQGDict::look_ascii(k,0,0); }
+
+    void  clear()			{ TQGDict::clear(); }
+    void  resize( uint n )		{ TQGDict::resize(n); }
+    void  statistics() const		{ TQGDict::statistics(); }
+
+#ifdef TQ_TQDOC
+protected:
+    virtual TQDataStream& read( TQDataStream &, TQPtrCollection::Item & );
+    virtual TQDataStream& write( TQDataStream &, TQPtrCollection::Item ) const;
+#endif
+
+private:
+    void  deleteItem( Item d );
+};
+
+#if !defined(TQ_BROKEN_TEMPLATE_SPECIALIZATION)
+template<> inline void TQAsciiDict<void>::deleteItem( TQPtrCollection::Item )
+{
+}
+#endif
+
+template<class type> inline void TQAsciiDict<type>::deleteItem( TQPtrCollection::Item d )
+{
+    if ( del_item ) delete (type *)d;
+}
+
+template<class type>
+class TQAsciiDictIterator : public TQGDictIterator
+{
+public:
+    TQAsciiDictIterator(const TQAsciiDict<type> &d)
+	: TQGDictIterator((TQGDict &)d) {}
+   ~TQAsciiDictIterator()      {}
+    uint  count()   const     { return dict->count(); }
+    bool  isEmpty() const     { return dict->count() == 0; }
+    type *toFirst()	      { return (type *)TQGDictIterator::toFirst(); }
+    operator type *() const   { return (type *)TQGDictIterator::get(); }
+    type   *current() const   { return (type *)TQGDictIterator::get(); }
+    const char *currentKey() const { return TQGDictIterator::getKeyAscii(); }
+    type *operator()()	      { return (type *)TQGDictIterator::operator()(); }
+    type *operator++()	      { return (type *)TQGDictIterator::operator++(); }
+    type *operator+=(uint j)  { return (type *)TQGDictIterator::operator+=(j);}
+};
+
+#define TQ_DEFINED_TQASCIIDICT
+#include "tqwinexport.h"
+#endif // TQASCIIDICT_H
diff --git a/tqtinterface/qt4/src/tools/tqbitarray.cpp b/tqtinterface/qt4/src/tools/tqbitarray.cpp
new file mode 100644
index 0000000..a741314
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqbitarray.cpp
@@ -0,0 +1,670 @@
+/****************************************************************************
+**
+** Implementation of TQBitArray class
+**
+** Created : 940118
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "tqbitarray.h"
+#include "tqdatastream.h"
+
+#define SHBLOCK	 ((bitarr_data*)(sharedBlock()))
+
+#ifdef USE_QT4
+
+#else // USE_QT4
+
+/*!
+    \class TQBitVal tqbitarray.h
+    \reentrant
+    \brief The TQBitVal class is an internal class, used with TQBitArray.
+
+    \ingroup collection
+
+    The TQBitVal is required by the indexing [] operator on bit arrays.
+    It is not for use in any other context.
+*/
+
+/*!
+    \fn TQBitVal::TQBitVal (TQBitArray* a, uint i)
+
+    Constructs a reference to element \a i in the TQBitArray \a a.
+    This is what TQBitArray::operator[] constructs its return value
+    with.
+*/
+
+/*!
+    \fn TQBitVal::operator int()
+
+    Returns the value referenced by the TQBitVal.
+*/
+
+/*!
+    \fn TQBitVal& TQBitVal::operator= (const TQBitVal& v)
+
+    Sets the value referenced by the TQBitVal to that referenced by
+    TQBitVal \a v.
+*/
+
+/*!
+    \overload TQBitVal& TQBitVal::operator= (bool v)
+
+    Sets the value referenced by the TQBitVal to \a v.
+*/
+
+
+/*!
+    \class TQBitArray tqbitarray.h
+    \reentrant
+    \brief The TQBitArray class provides an array of bits.
+
+    \ingroup collection
+    \ingroup tools
+    \ingroup shared
+
+    Because TQBitArray is a TQMemArray, it uses explicit \link
+    shclass.html sharing\endlink with a reference count.
+
+    A TQBitArray is a special byte array that can access individual
+    bits and perform bit-operations (AND, OR, XOR and NOT) on entire
+    arrays or bits.
+
+    Bits can be manipulated by the setBit() and clearBit() functions,
+    but it is also possible to use the indexing [] operator to test
+    and set individual bits. The [] operator is a little slower than
+    setBit() and clearBit() because some tricks are required to
+    implement single-bit assignments.
+
+    Example:
+    \code
+    TQBitArray a(3);
+    a.setBit( 0 );
+    a.clearBit( 1 );
+    a.setBit( 2 );     // a = [1 0 1]
+
+    TQBitArray b(3);
+    b[0] = 1;
+    b[1] = 1;
+    b[2] = 0;          // b = [1 1 0]
+
+    TQBitArray c;
+    c = ~a & b;        // c = [0 1 0]
+    \endcode
+
+    When a TQBitArray is constructed the bits are uninitialized. Use
+    fill() to set all the bits to 0 or 1. The array can be resized
+    with resize() and copied with copy(). Bits can be set with
+    setBit() and cleared with clearBit(). Bits can be toggled with
+    toggleBit(). A bit's value can be obtained with testBit() and with
+    at().
+
+    TQBitArray supports the \& (AND), | (OR), ^ (XOR) and ~ (NOT)
+    operators.
+*/
+
+/*! \class TQBitArray::bitarr_data
+  \brief The TQBitArray::bitarr_data class is internal.
+  \internal
+*/
+
+
+/*!
+    Constructs an empty bit array.
+*/
+
+TQBitArray::TQBitArray() : TQByteArray( 0, 0 )
+{
+    bitarr_data *x = new bitarr_data;
+    TQ_CHECK_PTR( x );
+    x->nbits = 0;
+    setSharedBlock( x );
+}
+
+/*!
+    Constructs a bit array of \a size bits. The bits are uninitialized.
+
+    \sa fill()
+*/
+
+TQBitArray::TQBitArray( uint size ) : TQByteArray( 0, 0 )
+{
+    bitarr_data *x = new bitarr_data;
+    TQ_CHECK_PTR( x );
+    x->nbits = 0;
+    setSharedBlock( x );
+    resize( size );
+}
+
+/*!
+    \fn TQBitArray::TQBitArray( const TQBitArray &a )
+
+    Constructs a shallow copy of \a a.
+*/
+
+/*!
+    \fn TQBitArray &TQBitArray::operator=( const TQBitArray &a )
+
+    Assigns a shallow copy of \a a to this bit array and returns a
+    reference to this array.
+*/
+
+
+/*!
+    Pad last byte with 0-bits.
+*/
+void TQBitArray::pad0()
+{
+    uint sz = size();
+    if ( sz && sz%8 )
+	*(data()+sz/8) &= (1 << (sz%8)) - 1;
+}
+
+
+/*!
+    \fn uint TQBitArray::size() const
+
+    Returns the bit array's size (number of bits).
+
+    \sa resize()
+*/
+
+/*!
+    Resizes the bit array to \a size bits and returns TRUE if the bit
+    array could be resized; otherwise returns FALSE. The array becomes
+    a null array if \a size == 0.
+
+    If the array is expanded, the new bits are set to 0.
+
+    \sa size()
+*/
+
+bool TQBitArray::resize( uint size )
+{
+    uint s = this->size();
+    if ( !TQByteArray::resize( (size+7)/8 ) )
+	return FALSE;				// cannot resize
+    SHBLOCK->nbits = size;
+    if ( size != 0 ) {				// not null array
+	int ds = (int)(size+7)/8 - (int)(s+7)/8;// number of bytes difference
+	if ( ds > 0 )				// expanding array
+	    memset( data() + (s+7)/8, 0, ds );	//   reset new data
+    }
+    return TRUE;
+}
+
+
+/*!
+    Fills the bit array with \a v (1's if \a v is TRUE, or 0's if \a v
+    is FALSE).
+
+    fill() resizes the bit array to \a size bits if \a size is
+    nonnegative.
+
+    Returns FALSE if a nonnegative \e size was specified and the bit
+    array could not be resized; otherwise returns TRUE.
+
+    \sa resize()
+*/
+
+bool TQBitArray::fill( bool v, int size )
+{
+    if ( size >= 0 ) {				// resize first
+	if ( !resize( size ) )
+	    return FALSE;			// cannot resize
+    } else {
+	size = this->size();
+    }
+    if ( size > 0 )
+	memset( data(), v ? 0xff : 0, (size + 7) / 8 );
+    if ( v )
+	pad0();
+    return TRUE;
+}
+
+
+/*!
+    Detaches from shared bit array data and makes sure that this bit
+    array is the only one referring to the data.
+
+    If multiple bit arrays share common data, this bit array
+    dereferences the data and gets a copy of the data. Nothing happens
+    if there is only a single reference.
+
+    \sa copy()
+*/
+
+void TQBitArray::detach()
+{
+    int nbits = SHBLOCK->nbits;
+    this->duplicate( *this );
+    SHBLOCK->nbits = nbits;
+}
+
+/*!
+    Returns a deep copy of the bit array.
+
+    \sa detach()
+*/
+
+TQBitArray TQBitArray::copy() const
+{
+    TQBitArray tmp;
+    tmp.duplicate( *this );
+    ((bitarr_data*)(tmp.sharedBlock()))->nbits = SHBLOCK->nbits;
+    return tmp;
+}
+
+
+/*!
+    Returns TRUE if the bit at position \a index is set, i.e. is 1;
+    otherwise returns FALSE.
+
+    \sa setBit(), clearBit()
+*/
+
+bool TQBitArray::testBit( uint index ) const
+{
+#if defined(TQT_CHECK_RANGE)
+    if ( index >= size() ) {
+	qWarning( "TQBitArray::testBit: Index %d out of range", index );
+	return FALSE;
+    }
+#endif
+    return (*(data()+(index>>3)) & (1 << (index & 7))) != 0;
+}
+
+/*!
+    \overload
+
+    Sets the bit at position \a index to 1.
+
+    \sa clearBit() toggleBit()
+*/
+
+void TQBitArray::setBit( uint index )
+{
+#if defined(TQT_CHECK_RANGE)
+    if ( index >= size() ) {
+	qWarning( "TQBitArray::setBit: Index %d out of range", index );
+	return;
+    }
+#endif
+    *(data()+(index>>3)) |= (1 << (index & 7));
+}
+
+/*!
+    \fn void TQBitArray::setBit( uint index, bool value )
+
+    Sets the bit at position \a index to \a value.
+
+    Equivalent to:
+    \code
+    if ( value )
+	setBit( index );
+    else
+	clearBit( index );
+    \endcode
+
+    \sa clearBit() toggleBit()
+*/
+
+/*!
+    Clears the bit at position \a index, i.e. sets it to 0.
+
+    \sa setBit(), toggleBit()
+*/
+
+void TQBitArray::clearBit( uint index )
+{
+#if defined(TQT_CHECK_RANGE)
+    if ( index >= size() ) {
+	qWarning( "TQBitArray::clearBit: Index %d out of range", index );
+	return;
+    }
+#endif
+    *(data()+(index>>3)) &= ~(1 << (index & 7));
+}
+
+/*!
+    Toggles the bit at position \a index.
+
+    If the previous value was 0, the new value will be 1. If the
+    previous value was 1, the new value will be 0.
+
+    \sa setBit(), clearBit()
+*/
+
+bool TQBitArray::toggleBit( uint index )
+{
+#if defined(TQT_CHECK_RANGE)
+    if ( index >= size() ) {
+	qWarning( "TQBitArray::toggleBit: Index %d out of range", index );
+	return FALSE;
+    }
+#endif
+    register uchar *p = (uchar *)data() + (index>>3);
+    uchar b = (1 << (index & 7));		// bit position
+    uchar c = *p & b;				// read bit
+    *p ^= b;					// toggle bit
+    return c;
+}
+
+
+/*!
+    \fn bool TQBitArray::at( uint index ) const
+
+    Returns the value (0 or 1) of the bit at position \a index.
+
+    \sa operator[]()
+*/
+
+/*!
+    \fn TQBitVal TQBitArray::operator[]( int index )
+
+    Implements the [] operator for bit arrays.
+
+    The returned TQBitVal is a context object. It makes it possible to
+    get and set a single bit value by its \a index position.
+
+    Example:
+    \code
+    TQBitArray a( 3 );
+    a[0] = 0;
+    a[1] = 1;
+    a[2] = a[0] ^ a[1];
+    \endcode
+
+    The functions testBit(), setBit() and clearBit() are faster.
+
+    \sa at()
+*/
+
+/*!
+    \overload bool TQBitArray::operator[]( int index ) const
+
+    Implements the [] operator for constant bit arrays.
+*/
+
+
+/*!
+    Performs the AND operation between all bits in this bit array and
+    \a a. Returns a reference to this bit array.
+
+    The result has the length of the longest of the two bit arrays,
+    with any missing bits (i.e. if one array is shorter than the
+    other), taken to be 0.
+    \code
+    TQBitArray a( 3 ), b( 2 );
+    a[0] = 1;  a[1] = 0;  a[2] = 1;     // a = [1 0 1]
+    b[0] = 1;  b[1] = 0;                // b = [1 0]
+    a &= b;                             // a = [1 0 0]
+    \endcode
+
+    \sa operator|=(), operator^=(), operator~()
+*/
+
+TQBitArray &TQBitArray::operator&=( const TQBitArray &a )
+{
+    resize( TQMAX(size(), a.size()) );
+    register uchar *a1 = (uchar *)data();
+    register uchar *a2 = (uchar *)a.data();
+    int n = TQMIN( TQByteArray::size(), a.TQByteArray::size() );
+    int p = TQMAX( TQByteArray::size(), a.TQByteArray::size() ) - n;
+    while ( n-- > 0 )
+	*a1++ &= *a2++;
+    while ( p-- > 0 )
+	*a1++ = 0;
+    return *this;
+}
+
+/*!
+    Performs the OR operation between all bits in this bit array and
+    \a a. Returns a reference to this bit array.
+
+    The result has the length of the longest of the two bit arrays,
+    with any missing bits (i.e. if one array is shorter than the
+    other), taken to be 0.
+    \code
+    TQBitArray a( 3 ), b( 2 );
+    a[0] = 1;  a[1] = 0;  a[2] = 1;     // a = [1 0 1]
+    b[0] = 1;  b[1] = 0;                // b = [1 0]
+    a |= b;                             // a = [1 0 1]
+    \endcode
+
+    \sa operator&=(), operator^=(), operator~()
+*/
+
+TQBitArray &TQBitArray::operator|=( const TQBitArray &a )
+{
+    resize( TQMAX(size(), a.size()) );
+    register uchar *a1 = (uchar *)data();
+    register uchar *a2 = (uchar *)a.data();
+    int n = TQMIN( TQByteArray::size(), a.TQByteArray::size() );
+    while ( n-- > 0 )
+	*a1++ |= *a2++;
+    return *this;
+}
+
+/*!
+    Performs the XOR operation between all bits in this bit array and
+    \a a. Returns a reference to this bit array.
+
+    The result has the length of the longest of the two bit arrays,
+    with any missing bits (i.e. if one array is shorter than the
+    other), taken to be 0.
+    \code
+    TQBitArray a( 3 ), b( 2 );
+    a[0] = 1;  a[1] = 0;  a[2] = 1;     // a = [1 0 1]
+    b[0] = 1;  b[1] = 0;                // b = [1 0]
+    a ^= b;                             // a = [0 0 1]
+    \endcode
+
+    \sa operator&=(), operator|=(), operator~()
+*/
+
+TQBitArray &TQBitArray::operator^=( const TQBitArray &a )
+{
+    resize( TQMAX(size(), a.size()) );
+    register uchar *a1 = (uchar *)data();
+    register uchar *a2 = (uchar *)a.data();
+    int n = TQMIN( TQByteArray::size(), a.TQByteArray::size() );
+    while ( n-- > 0 )
+	*a1++ ^= *a2++;
+    return *this;
+}
+
+/*!
+    Returns a bit array that tqcontains the inverted bits of this bit array.
+
+    Example:
+    \code
+    TQBitArray a( 3 ), b;
+    a[0] = 1;  a[1] = 0; a[2] = 1;	// a = [1 0 1]
+    b = ~a;				// b = [0 1 0]
+    \endcode
+*/
+
+TQBitArray TQBitArray::operator~() const
+{
+    TQBitArray a( size() );
+    register uchar *a1 = (uchar *)data();
+    register uchar *a2 = (uchar *)a.data();
+    int n = TQByteArray::size();
+    while ( n-- )
+	*a2++ = ~*a1++;
+    a.pad0();
+    return a;
+}
+
+
+/*!
+    \relates TQBitArray
+
+    Returns the AND result between the bit arrays \a a1 and \a a2.
+
+    The result has the length of the longest of the two bit arrays,
+    with any missing bits (i.e. if one array is shorter than the
+    other), taken to be 0.
+
+    \sa TQBitArray::operator&=()
+*/
+
+TQBitArray operator&( const TQBitArray &a1, const TQBitArray &a2 )
+{
+    TQBitArray tmp = a1.copy();
+    tmp &= a2;
+    return tmp;
+}
+
+/*!
+    \relates TQBitArray
+
+    Returns the OR result between the bit arrays \a a1 and \a a2.
+
+    The result has the length of the longest of the two bit arrays,
+    with any missing bits (i.e. if one array is shorter than the
+    other), taken to be 0.
+
+    \sa TQBitArray::operator|=()
+*/
+
+TQBitArray operator|( const TQBitArray &a1, const TQBitArray &a2 )
+{
+    TQBitArray tmp = a1.copy();
+    tmp |= a2;
+    return tmp;
+}
+
+/*!
+    \relates TQBitArray
+
+    Returns the XOR result between the bit arrays \a a1 and \a a2.
+
+    The result has the length of the longest of the two bit arrays,
+    with any missing bits (i.e. if one array is shorter than the
+    other), taken to be 0.
+
+    \sa TQBitArray::operator^()
+*/
+
+TQBitArray operator^( const TQBitArray &a1, const TQBitArray &a2 )
+{
+    TQBitArray tmp = a1.copy();
+    tmp ^= a2;
+    return tmp;
+}
+
+
+/* \enum TQGArray::array_data
+
+  \warning This will be renamed in the next major release of TQt.  Until
+  then it is undocumented and we recommend against its use.
+
+  \internal
+
+  ### 3.0 rename ###
+  ### 3.0 move it to TQGArray? ###
+*/
+
+
+/*!
+    \fn TQBitArray::array_data * TQBitArray::newData()
+
+    \internal
+
+    Returns data specific to TQBitArray that extends what TQGArray provides.
+    TQPtrCollection mechanism for allowing extra/different data.
+*/
+
+
+/*!
+    \fn void  TQBitArray::deleteData ( array_data * d )
+
+    \internal
+
+    Deletes data specific to TQBitArray that extended what TQGArray provided.
+
+    TQPtrCollection mechanism for allowing extra/different data.
+*/
+
+
+/*****************************************************************************
+  TQBitArray stream functions
+ *****************************************************************************/
+
+/*!
+    \relates TQBitArray
+
+    Writes bit array \a a to stream \a s.
+
+    \sa \link datastreamformat.html Format of the TQDataStream operators \endlink
+*/
+#ifndef TQT_NO_DATASTREAM
+TQDataStream &operator<<( TQDataStream &s, const TQBitArray &a )
+{
+    TQ_UINT32 len = a.size();
+    s << len;					// write size of array
+    if ( len > 0 )				// write data
+	s.writeRawBytes( a.data(), a.TQByteArray::size() );
+    return s;
+}
+
+/*!
+    \relates TQBitArray
+
+    Reads a bit array into \a a from stream \a s.
+
+    \sa \link datastreamformat.html Format of the TQDataStream operators \endlink
+*/
+
+TQDataStream &operator>>( TQDataStream &s, TQBitArray &a )
+{
+    TQ_UINT32 len;
+    s >> len;					// read size of array
+    if ( !a.resize( (uint)len ) ) {		// resize array
+#if defined(TQT_CHECK_NULL)
+	qWarning( "TQDataStream: Not enough memory to read TQBitArray" );
+#endif
+	len = 0;
+    }
+    if ( len > 0 )				// read data
+	s.readRawBytes( a.data(), a.TQByteArray::size() );
+    return s;
+}
+
+#endif // USE_QT4
+
+#endif // TQT_NO_DATASTREAM
diff --git a/tqtinterface/qt4/src/tools/tqbitarray.h b/tqtinterface/qt4/src/tools/tqbitarray.h
new file mode 100644
index 0000000..4529162
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqbitarray.h
@@ -0,0 +1,204 @@
+/****************************************************************************
+**
+** Definition of TQBitArray class
+**
+** Created : 940118
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQBITARRAY_H
+#define TQBITARRAY_H
+
+#include "tqtglobaldefines.h"
+
+#ifndef TQT_H
+#include "tqstring.h"
+#endif // TQT_H
+
+#ifdef USE_QT4
+
+#include <Qt/qbitarray.h>
+
+#endif // USE_QT4
+
+#ifdef USE_QT4
+
+// class TQBitArray;
+
+// class TQ_EXPORT TQBitVal : public QBitRef
+// {
+// public:
+// 	TQBitVal( QBitArray *a, uint i ) : QBitRef ( *a, i ) {}
+// };
+
+typedef QBitRef TQBitVal;
+
+class TQ_EXPORT TQBitArray : public QBitArray
+{
+public:
+	TQBitArray() : QBitArray() {}
+	TQBitArray( uint size ) : QBitArray( size ) {}
+	TQBitArray( const QBitArray &a ) : QBitArray( a ) {}
+
+	inline TQBitArray copy() const { return TQBitArray(*this); }
+	inline bool tqat( uint index ) const { return at(index); }
+};
+
+#else // USE_QT4
+
+/*****************************************************************************
+  TQBitVal class; a context class for TQBitArray::operator[]
+ *****************************************************************************/
+
+class TQBitArray;
+
+class TQ_EXPORT TQBitVal
+{
+private:
+    TQBitArray *array;
+    uint    index;
+public:
+    TQBitVal( TQBitArray *a, uint i ) : array(a), index(i) {}
+    operator int();
+    TQBitVal &operator=( const TQBitVal &v );
+    TQBitVal &operator=( bool v );
+};
+
+
+/*****************************************************************************
+  TQBitArray class
+ *****************************************************************************/
+
+class TQ_EXPORT TQBitArray : public TQByteArray
+{
+public:
+    TQBitArray();
+    TQBitArray( uint size );
+    TQBitArray( const TQBitArray &a ) : TQByteArray( a ) {}
+
+    TQBitArray &operator=( const TQBitArray & );
+
+    uint    size() const;
+    bool    resize( uint size );
+
+    bool    fill( bool v, int size = -1 );
+
+    void    detach();
+    TQBitArray copy() const;
+
+    bool    testBit( uint index ) const;
+    void    setBit( uint index );
+    void    setBit( uint index, bool value );
+    void    clearBit( uint index );
+    bool    toggleBit( uint index );
+
+    bool    at( uint index ) const;
+    bool    tqat( uint index ) const { return at(index); }
+    TQBitVal operator[]( int index );
+    bool operator[]( int index ) const;
+
+    TQBitArray &operator&=( const TQBitArray & );
+    TQBitArray &operator|=( const TQBitArray & );
+    TQBitArray &operator^=( const TQBitArray & );
+    TQBitArray  operator~() const;
+
+protected:
+    struct bitarr_data : public TQGArray::array_data {
+	uint   nbits;
+    };
+    array_data *newData()		    { return new bitarr_data; }
+    void	deleteData( array_data *d ) { delete (bitarr_data*)d; }
+private:
+    void    pad0();
+};
+
+
+inline TQBitArray &TQBitArray::operator=( const TQBitArray &a )
+{ return (TQBitArray&)assign( a ); }
+
+inline uint TQBitArray::size() const
+{ return ((bitarr_data*)sharedBlock())->nbits; }
+
+inline void TQBitArray::setBit( uint index, bool value )
+{ if ( value ) setBit(index); else clearBit(index); }
+
+inline bool TQBitArray::at( uint index ) const
+{ return testBit(index); }
+
+inline TQBitVal TQBitArray::operator[]( int index )
+{ return TQBitVal( (TQBitArray*)this, index ); }
+
+inline bool TQBitArray::operator[]( int index ) const
+{ return testBit( index ); }
+
+
+/*****************************************************************************
+  Misc. TQBitArray operator functions
+ *****************************************************************************/
+
+TQ_EXPORT TQBitArray operator&( const TQBitArray &, const TQBitArray & );
+TQ_EXPORT TQBitArray operator|( const TQBitArray &, const TQBitArray & );
+TQ_EXPORT TQBitArray operator^( const TQBitArray &, const TQBitArray & );
+
+
+inline TQBitVal::operator int()
+{
+    return array->testBit( index );
+}
+
+inline TQBitVal &TQBitVal::operator=( const TQBitVal &v )
+{
+    array->setBit( index, v.array->testBit(v.index) );
+    return *this;
+}
+
+inline TQBitVal &TQBitVal::operator=( bool v )
+{
+    array->setBit( index, v );
+    return *this;
+}
+
+
+/*****************************************************************************
+  TQBitArray stream functions
+ *****************************************************************************/
+#ifndef TQT_NO_DATASTREAM
+TQ_EXPORT TQDataStream &operator<<( TQDataStream &, const TQBitArray & );
+TQ_EXPORT TQDataStream &operator>>( TQDataStream &, TQBitArray & );
+#endif
+
+#endif // USE_QT4
+
+#endif // TQBITARRAY_H
diff --git a/tqtinterface/qt4/src/tools/tqbuffer.cpp b/tqtinterface/qt4/src/tools/tqbuffer.cpp
new file mode 100644
index 0000000..81ad242
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqbuffer.cpp
@@ -0,0 +1,503 @@
+/****************************************************************************
+**
+** Implementation of TQBuffer class
+**
+** Created : 930812
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "tqbuffer.h"
+#include <stdlib.h>
+
+#ifdef USE_QT4
+
+#else // USE_QT4
+
+/*!
+    \class TQBuffer tqbuffer.h
+    \reentrant
+    \brief The TQBuffer class is an I/O tqdevice that operates on a TQByteArray.
+
+    \ingroup io
+    \ingroup collection
+
+    TQBuffer is used to read and write to a memory buffer. It is
+    normally used with a TQTextStream or a TQDataStream. TQBuffer has an
+    associated TQByteArray which holds the buffer data. The size() of
+    the buffer is automatically adjusted as data is written.
+
+    The constructor \c TQBuffer(TQByteArray) creates a TQBuffer using an
+    existing byte array. The byte array can also be set with
+    setBuffer(). Writing to the TQBuffer will modify the original byte
+    array because TQByteArray is \link shclass.html explicitly
+    shared.\endlink
+
+    Use open() to open the buffer before use and to set the mode
+    (read-only, write-only, etc.). close() closes the buffer. The
+    buffer must be closed before reopening or calling setBuffer().
+
+    A common way to use TQBuffer is through \l TQDataStream or \l
+    TQTextStream, which have constructors that take a TQBuffer
+    parameter. For convenience, there are also TQDataStream and
+    TQTextStream constructors that take a TQByteArray parameter. These
+    constructors create and open an internal TQBuffer.
+
+    Note that TQTextStream can also operate on a TQString (a Unicode
+    string); a TQBuffer cannot.
+
+    You can also use TQBuffer directly through the standard TQIODevice
+    functions readBlock(), writeBlock() readLine(), at(), getch(),
+    putch() and ungetch().
+
+    \sa TQFile, TQDataStream, TQTextStream, TQByteArray, \link shclass.html Shared Classes\endlink
+*/
+
+
+/*!
+    Constructs an empty buffer.
+*/
+
+TQBuffer::TQBuffer()
+{
+    setFlags( IO_Direct );
+    a_inc = 16;                                 // initial increment
+    a_len = 0;
+    ioIndex = 0;
+}
+
+
+/*!
+    Constructs a buffer that operates on \a buf.
+
+    If you open the buffer in write mode (\c IO_WriteOnly or
+    \c IO_ReadWrite) and write something into the buffer, \a buf
+    will be modified.
+
+    Example:
+    \code
+    TQCString str = "abc";
+    TQBuffer b( str );
+    b.open( IO_WriteOnly );
+    b.at( 3 ); // position at the 4th character (the terminating \0)
+    b.writeBlock( "def", 4 ); // write "def" including the terminating \0
+    b.close();
+    // Now, str == "abcdef" with a terminating \0
+    \endcode
+
+    \sa setBuffer()
+*/
+
+TQBuffer::TQBuffer( TQByteArray buf ) : a(buf)
+{
+    setFlags( IO_Direct );
+    a_len = a.size();
+    a_inc = (a_len > 512) ? 512 : a_len;        // initial increment
+    if ( a_inc < 16 )
+        a_inc = 16;
+    ioIndex = 0;
+}
+
+/*!
+    Destroys the buffer.
+*/
+
+TQBuffer::~TQBuffer()
+{
+}
+
+
+/*!
+    Replaces the buffer's contents with \a buf and returns TRUE.
+
+    Does nothing (and returns FALSE) if isOpen() is TRUE.
+
+    Note that if you open the buffer in write mode (\c IO_WriteOnly or
+    IO_ReadWrite) and write something into the buffer, \a buf is also
+    modified because TQByteArray is an explicitly shared class.
+
+    \sa buffer(), open(), close()
+*/
+
+bool TQBuffer::setBuffer( TQByteArray buf )
+{
+    if ( isOpen() ) {
+#if defined(TQT_CHECK_STATE)
+        qWarning( "TQBuffer::setBuffer: Buffer is open" );
+#endif
+        return FALSE;
+    }
+    a = buf;
+    a_len = a.size();
+    a_inc = (a_len > 512) ? 512 : a_len;        // initial increment
+    if ( a_inc < 16 )
+        a_inc = 16;
+    ioIndex = 0;
+    return TRUE;
+}
+
+/*!
+    \fn TQByteArray TQBuffer::buffer() const
+
+    Returns this buffer's byte array.
+
+    \sa setBuffer()
+*/
+
+/*!
+    \reimp
+
+    Opens the buffer in mode \a m. Returns TRUE if successful;
+    otherwise returns FALSE. The buffer must be opened before use.
+
+    The mode parameter \a m must be a combination of the following flags.
+    \list
+    \i \c IO_ReadOnly opens the buffer in read-only mode.
+    \i \c IO_WriteOnly opens the buffer in write-only mode.
+    \i \c IO_ReadWrite opens the buffer in read/write mode.
+    \i \c IO_Append sets the buffer index to the end of the buffer.
+    \i \c IO_Truncate truncates the buffer.
+    \endlist
+
+    \sa close(), isOpen()
+*/
+
+bool TQBuffer::open( int m  )
+{
+    if ( isOpen() ) {                           // buffer already open
+#if defined(TQT_CHECK_STATE)
+        qWarning( "TQBuffer::open: Buffer already open" );
+#endif
+        return FALSE;
+    }
+    setMode( m );
+    if ( m & IO_Truncate ) {                    // truncate buffer
+        a.resize( 0 );
+        a_len = 0;
+    }
+    if ( m & IO_Append ) {                      // append to end of buffer
+        ioIndex = a.size();
+    } else {
+        ioIndex = 0;
+    }
+    a_inc = 16;
+    setState( IO_Open );
+    resetqStatus();
+    return TRUE;
+}
+
+/*!
+    \reimp
+
+    Closes an open buffer.
+
+    \sa open()
+*/
+
+void TQBuffer::close()
+{
+    if ( isOpen() ) {
+        setFlags( IO_Direct );
+        ioIndex = 0;
+        a_inc = 16;
+    }
+}
+
+/*!
+    \reimp
+
+    The flush function does nothing for a TQBuffer.
+*/
+
+void TQBuffer::flush()
+{
+    return;
+}
+
+
+/*!
+    \fn TQIODevice::Offset TQBuffer::at() const
+
+    \reimp
+*/
+
+/*!
+    \fn TQIODevice::Offset TQBuffer::size() const
+
+    \reimp
+*/
+
+/*!
+  \reimp
+*/
+
+bool TQBuffer::at( Offset pos )
+{
+#if defined(TQT_CHECK_STATE)
+    if ( !isOpen() ) {
+        qWarning( "TQBuffer::at: Buffer is not open" );
+        return FALSE;
+    }
+#endif
+    if ( pos > a_len ) {
+#if defined(TQT_CHECK_RANGE)
+#if defined(TQT_ABI_QT4)
+        qWarning( "TQBuffer::at: Index %lld out of range", pos );
+#else
+        qWarning( "TQBuffer::at: Index %lu out of range", pos );
+#endif
+#endif
+        return FALSE;
+    }
+    ioIndex = pos;
+    return TRUE;
+}
+
+
+/*!
+  \reimp
+*/
+
+TQ_LONG TQBuffer::readBlock( char *p, TQ_ULONG len )
+{
+#if defined(TQT_CHECK_STATE)
+    if ( !p ) {
+	qWarning( "TQBuffer::readBlock: Null pointer error" );
+	return -1;
+    }
+    if ( !isOpen() ) {                          // buffer not open
+        qWarning( "TQBuffer::readBlock: Buffer not open" );
+        return -1;
+    }
+    if ( !isReadable() ) {                      // reading not permitted
+        qWarning( "TQBuffer::readBlock: Read operation not permitted" );
+        return -1;
+    }
+#endif
+    if ( ioIndex + len > a.size() ) {   // overflow
+        if ( ioIndex >= a.size() ) {
+            return 0;
+        } else {
+            len = a.size() - ioIndex;
+        }
+    }
+    memcpy(p, a.data() + ioIndex, len);
+    ioIndex += len;
+    return len;
+}
+
+/*!
+    \overload TQ_LONG TQBuffer::writeBlock( const TQByteArray& data )
+
+    This convenience function is the same as calling
+    \c{writeBlock( data.data(), data.size() )} with \a data.
+*/
+
+/*!
+    Writes \a len bytes from \a p into the buffer at the current
+    index position, overwriting any characters there and extending the
+    buffer if necessary. Returns the number of bytes actually written.
+
+    Returns -1 if an error occurred.
+
+    \sa readBlock()
+*/
+
+TQ_LONG TQBuffer::writeBlock( const char *p, TQ_ULONG len )
+{
+    if ( len == 0 )
+        return 0;
+
+#if defined(TQT_CHECK_NULL)
+    if ( p == 0 ) {
+        qWarning( "TQBuffer::writeBlock: Null pointer error" );
+        return -1;
+    }
+#endif
+#if defined(TQT_CHECK_STATE)
+    if ( !isOpen() ) {                          // buffer not open
+        qWarning( "TQBuffer::writeBlock: Buffer not open" );
+        return -1;
+    }
+    if ( !isWritable() ) {                      // writing not permitted
+        qWarning( "TQBuffer::writeBlock: Write operation not permitted" );
+        return -1;
+    }
+#endif
+    if ( ioIndex + len > a_len ) {              // overflow
+        TQ_ULONG new_len = a_len + a_inc*((ioIndex+len-a_len)/a_inc+1);
+        if ( !a.resize( new_len ) ) {           // could not resize
+#if defined(TQT_CHECK_NULL)
+            qWarning( "TQBuffer::writeBlock: Memory allocation error" );
+#endif
+            setqStatus( IO_ResourceError );
+            return -1;
+        }
+        a_inc *= 2;                             // double increment
+        a_len = new_len;
+        a.shd->len = ioIndex + len;
+    }
+    memcpy( a.data()+ioIndex, p, len );
+    ioIndex += len;
+    if ( a.shd->len < ioIndex )
+        a.shd->len = ioIndex;                   // fake (not alloc'd) length
+    return len;
+}
+
+
+/*!
+  \reimp
+*/
+
+TQ_LONG TQBuffer::readLine( char *p, TQ_ULONG maxlen )
+{
+#if defined(TQT_CHECK_NULL)
+    if ( p == 0 ) {
+        qWarning( "TQBuffer::readLine: Null pointer error" );
+        return -1;
+    }
+#endif
+#if defined(TQT_CHECK_STATE)
+    if ( !isOpen() ) {                          // buffer not open
+        qWarning( "TQBuffer::readLine: Buffer not open" );
+        return -1;
+    }
+    if ( !isReadable() ) {                      // reading not permitted
+        qWarning( "TQBuffer::readLine: Read operation not permitted" );
+        return -1;
+    }
+#endif
+    if ( maxlen == 0 )
+        return 0;
+    TQ_ULONG start = ioIndex;
+    char *d = a.data() + ioIndex;
+    maxlen--;                                   // make room for 0-terminator
+    if ( a.size() - ioIndex < maxlen )
+        maxlen = a.size() - ioIndex;
+    while ( maxlen-- ) {
+        if ( (*p++ = *d++) == '\n' )
+            break;
+    }
+    *p = '\0';
+    ioIndex = d - a.data();
+    return ioIndex - start;
+}
+
+
+/*!
+  \reimp
+*/
+
+int TQBuffer::getch()
+{
+#if defined(TQT_CHECK_STATE)
+    if ( !isOpen() ) {                          // buffer not open
+        qWarning( "TQBuffer::getch: Buffer not open" );
+        return -1;
+    }
+    if ( !isReadable() ) {                      // reading not permitted
+        qWarning( "TQBuffer::getch: Read operation not permitted" );
+        return -1;
+    }
+#endif
+    if ( ioIndex+1 > a.size() ) {               // overflow
+        setqStatus( IO_ReadError );
+        return -1;
+    }
+    return uchar(*(a.data()+ioIndex++));
+}
+
+/*!
+    \reimp
+
+    Writes the character \a ch into the buffer at the current index
+    position, overwriting any existing character and extending the
+    buffer if necessary.
+
+    Returns \a ch, or -1 if an error occurred.
+
+    \sa getch(), ungetch()
+*/
+
+int TQBuffer::putch( int ch )
+{
+#if defined(TQT_CHECK_STATE)
+    if ( !isOpen() ) {                          // buffer not open
+        qWarning( "TQBuffer::putch: Buffer not open" );
+        return -1;
+    }
+    if ( !isWritable() ) {                      // writing not permitted
+        qWarning( "TQBuffer::putch: Write operation not permitted" );
+        return -1;
+    }
+#endif
+    if ( ioIndex + 1 > a_len ) {                // overflow
+        char buf[1];
+        buf[0] = (char)ch;
+        if ( writeBlock(buf,1) != 1 )
+            return -1;                          // write error
+    } else {
+        *(a.data() + ioIndex++) = (char)ch;
+        if ( a.shd->len < ioIndex )
+            a.shd->len = ioIndex;
+    }
+    return ch;
+}
+
+/*!
+  \reimp
+*/
+
+int TQBuffer::ungetch( int ch )
+{
+#if defined(TQT_CHECK_STATE)
+    if ( !isOpen() ) {                          // buffer not open
+        qWarning( "TQBuffer::ungetch: Buffer not open" );
+        return -1;
+    }
+    if ( !isReadable() ) {                      // reading not permitted
+        qWarning( "TQBuffer::ungetch: Read operation not permitted" );
+        return -1;
+    }
+#endif
+    if ( ch != -1 ) {
+        if ( ioIndex )
+            ioIndex--;
+        else
+            ch = -1;
+    }
+    return ch;
+}
+
+#endif // USE_QT4
\ No newline at end of file
diff --git a/tqtinterface/qt4/src/tools/tqbuffer.h b/tqtinterface/qt4/src/tools/tqbuffer.h
new file mode 100644
index 0000000..1cc3fd0
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqbuffer.h
@@ -0,0 +1,220 @@
+/****************************************************************************
+**
+** Definition of TQBuffer class
+**
+** Created : 930812
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQBUFFER_H
+#define TQBUFFER_H
+
+#include "tqtglobaldefines.h"
+
+#ifndef TQT_H
+#include "tqiodevice.h"
+#include "tqstring.h"
+#endif // TQT_H
+
+#ifdef USE_QT4
+
+#include <Qt/qbuffer.h>
+
+#endif // USE_QT4
+
+#ifdef USE_QT4
+
+class TQ_EXPORT TQBuffer : public QBuffer
+{
+public:
+#if defined(TQT_ABI_QT4)
+    typedef TQ_LLONG Offset;
+#else
+    typedef TQ_ULONG Offset;
+#endif
+
+	#warning Please remember that TQByteArray is no longer explicitly shared.  If you get weird crashes while using TQt stream objects please see tqbuffer.h line 69
+	// NOTE:
+	// QByteArray was explicitly shared in Qt3
+	// This is no longer the case in Qt4
+	// If you get weird crashes inside TQBuffer, it probably means you did something like this:
+	// 
+	// main() {
+	// 	aFunction();
+	// 	otherFunction();
+	// }
+	// 
+	// aFunction() {
+	// 	TQBuffer m_Buffer(QByteArray());
+	// }
+	// 
+	// otherFunction() {
+	// 	m_Buffer.putch('H');
+	// }
+	// 
+	// The QByteArray object was created within aFunction, but as it went out of scope it was destroyed before otherFunction was called
+	// Therefore, the TQBuffer's internal reference to the TQByteArray was invalid at the time putch() was called
+	// You could do this instead:
+	// 
+	// aFunction() {
+	// 	TQBuffer m_Buffer();
+	// 	m_Buffer.tqsetBufferFromCopy(QByteArray());
+	// }
+
+	TQBuffer() : QBuffer() {}
+	TQBuffer( TQByteArray &ba ) : QBuffer( &ba, 0 ) {}
+	TQBuffer( const TQByteArray &ba ) : QBuffer( const_cast<TQByteArray*>(&ba), 0 ) {}
+// 	TQBuffer( TQByteArray ba ) : QBuffer(), internal_ba_copy(ba) { QBuffer::setBuffer(&internal_ba_copy); }		// Make a copy of ba
+
+	inline int state() const { return isOpen() ? 0x1000 : 0; }
+	inline int mode() const { return (int) openMode(); }
+	inline int flags() const { return (int) openMode(); }
+	inline bool tqopen( int mode ) { return open((OpenModeFlag)mode); }
+
+	inline Offset at() const { return pos(); }
+	inline bool at(Offset offset) { return seek(offset); }
+	inline Offset tqat() const { return pos(); }
+	inline bool tqat(Offset offset) { return seek(offset); }
+
+// 	virtual inline qint64 readBlock(char *data, quint64 maxlen) { return read(data, maxlen); }
+// 	virtual inline qint64 writeBlock(const char *data, quint64 len) { return write(data, len); }
+// 	virtual inline qint64 writeBlock(const QByteArray &data) { return write(data); }
+	inline qint64 readBlock(char *data, quint64 maxlen) { return read(data, maxlen); }
+	inline qint64 writeBlock(const char *data, quint64 len) { return write(data, len); }
+	inline qint64 writeBlock(const QByteArray &data) { return write(data); }
+
+// 	virtual inline qint64 readData ( char * data, qint64 maxSize ) { return readBlock(data, maxSize); }
+// 	virtual inline qint64 writeData ( const char * data, qint64 maxSize ) { return writeBlock(data, maxSize); }
+
+	inline int getch() { char c; return getChar(&c) ? int(uchar(c)) : -1; }
+	inline int putch(int c) { return putChar(char(c)) ? int(uchar(c)) : -1; }
+	inline int ungetch(int c) { ungetChar(uchar(c)); return c; }
+
+	inline bool isDirectAccess() const { return !isSequential(); }
+	inline bool isSequentialAccess() const { return isSequential(); }
+	inline bool isCombinedAccess() const { return false; }
+	inline bool isBuffered() const { return true; }
+	inline bool isRaw() const { return false; }
+	inline bool isSynchronous() const { return true; }
+	inline bool isAsynchronous() const { return false; }
+	inline bool isTranslated() const { return (openMode() & Text) != 0; }
+	inline bool isInactive() const { return !isOpen(); }
+
+	inline TQByteArray &buffer() { return static_cast<TQByteArray&>(QBuffer::buffer()); }
+	inline bool setBuffer( TQByteArray &tqba ) { if (isOpen() == TRUE) return FALSE; QBuffer::setBuffer(&tqba); return TRUE; }
+	inline bool tqsetBufferFromCopy( TQByteArray tqba ) { if (isOpen() == TRUE) return FALSE; internal_ba_copy = tqba; QBuffer::setBuffer(&internal_ba_copy); return TRUE; }
+// 	inline bool setBuffer( TQByteArray tqba ) { if (isOpen() == TRUE) return FALSE; internal_ba_copy = tqba; QBuffer::setBuffer(&internal_ba_copy); return TRUE; }
+
+public:
+	typedef int Status;
+	Status status() const {
+#if !defined(QT_NO_QOBJECT)
+		const QFile *f = qobject_cast<const QFile *>(this);
+		if (f) return (int) f->error();
+#endif
+		return isOpen() ? 0 /* IO_Ok */ : 8 /* IO_UnspecifiedError */;
+	}
+	void resetStatus() {
+#if !defined(QT_NO_QOBJECT)
+		QFile *f = qobject_cast<QFile *>(this);
+		if (f) f->unsetError();
+#endif
+	}
+
+protected:
+	void setqStatus( int ) { std::cout << "[WARNING] TQBuffer::setqStatus() UNIMPLEMENTED\n\r"; }
+	void resetqStatus() { resetStatus(); }
+
+private:
+	TQByteArray internal_ba_copy;
+};
+
+#else // USE_QT4
+
+class TQ_EXPORT TQBuffer : public TQIODevice
+{
+public:
+    TQBuffer();
+    TQBuffer( TQByteArray );
+   ~TQBuffer();
+
+    TQByteArray buffer() const;
+    bool  setBuffer( TQByteArray );
+
+    bool  open( int );
+    void  close();
+    void  flush();
+
+    Offset size() const;
+    Offset at() const;
+    bool  at( Offset );
+
+    TQ_LONG	  readBlock( char *p, TQ_ULONG );
+    TQ_LONG	  writeBlock( const char *p, TQ_ULONG );
+    TQ_LONG	  writeBlock( const TQByteArray& data )
+	      { return TQIODevice::writeBlock(data); }
+    TQ_LONG	  readLine( char *p, TQ_ULONG );
+
+    int	  getch();
+    int	  putch( int );
+    int	  ungetch( int );
+
+protected:
+    TQByteArray a;
+
+private:
+    uint  a_len;
+    uint  a_inc;
+
+private:	// Disabled copy constructor and operator=
+#if defined(TQ_DISABLE_COPY)
+    TQBuffer( const TQBuffer & );
+    TQBuffer &operator=( const TQBuffer & );
+#endif
+};
+
+
+inline TQByteArray TQBuffer::buffer() const
+{ return a; }
+
+inline TQIODevice::Offset TQBuffer::size() const
+{ return (Offset)a.size(); }
+
+inline TQIODevice::Offset TQBuffer::at() const
+{ return ioIndex; }
+
+#endif // USE_QT4
+
+#endif // TQBUFFER_H
diff --git a/tqtinterface/qt4/src/tools/tqbuffer.h~ b/tqtinterface/qt4/src/tools/tqbuffer.h~
new file mode 100644
index 0000000..c939e50
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqbuffer.h~
@@ -0,0 +1,219 @@
+/****************************************************************************
+**
+** Definition of TQBuffer class
+**
+** Created : 930812
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQBUFFER_H
+#define TQBUFFER_H
+
+#include "tqtglobaldefines.h"
+
+#ifndef TQT_H
+#include "tqiodevice.h"
+#include "tqstring.h"
+#endif // TQT_H
+
+#ifdef USE_QT4
+
+#include <Qt/qbuffer.h>
+
+#endif // USE_QT4
+
+#ifdef USE_QT4
+
+class TQ_EXPORT TQBuffer : public QBuffer
+{
+public:
+#if defined(TQT_ABI_QT4)
+    typedef TQ_LLONG Offset;
+#else
+    typedef TQ_ULONG Offset;
+#endif
+
+	#warning Please remember that TQByteArray is no longer explicitly shared.  If you get weird crashes while using TQt stream objects please see tqbuffer.h line 69
+	// NOTE:
+	// QByteArray was explicitly shared in Qt3
+	// This is no longer the case in Qt4
+	// If you get weird crashes inside TQBuffer, it probably means you did something like this:
+	// 
+	// main() {
+	// 	aFunction();
+	// 	otherFunction();
+	// }
+	// 
+	// aFunction() {
+	// 	TQBuffer m_Buffer(QByteArray());
+	// }
+	// 
+	// otherFunction() {
+	// 	m_Buffer.putch('H');
+	// }
+	// 
+	// The QByteArray object was created within aFunction, but as it went out of scope it was destroyed before otherFunction was called
+	// Therefore, the TQBuffer's internal reference to the TQByteArray was invalid at the time putch() was called
+	// You could do this instead:
+	// 
+	// aFunction() {
+	// 	TQBuffer m_Buffer();
+	// 	m_Buffer.tqsetBufferFromCopy(QByteArray());
+	// }
+
+	TQBuffer() : QBuffer() {}
+	TQBuffer( TQByteArray &ba ) : QBuffer( &ba, 0 ) {}
+	TQBuffer( const TQByteArray &ba ) : QBuffer( const_cast<TQByteArray*>(&ba), 0 ) {}
+// 	TQBuffer( TQByteArray ba ) : QBuffer(), internal_ba_copy(ba) { QBuffer::setBuffer(&internal_ba_copy); }		// Make a copy of ba
+
+	inline int state() const { return isOpen() ? 0x1000 : 0; }
+	inline int mode() const { return (int) openMode(); }
+	inline int flags() const { return (int) openMode(); }
+	inline bool tqopen( int mode ) { return open((OpenModeFlag)mode); }
+
+	inline Offset at() const { return pos(); }
+	inline bool at(Offset offset) { return seek(offset); }
+	inline Offset tqat() const { return pos(); }
+	inline bool tqat(Offset offset) { return seek(offset); }
+
+// 	virtual inline qint64 readBlock(char *data, quint64 maxlen) { return read(data, maxlen); }
+// 	virtual inline qint64 writeBlock(const char *data, quint64 len) { return write(data, len); }
+// 	virtual inline qint64 writeBlock(const QByteArray &data) { return write(data); }
+	inline qint64 readBlock(char *data, quint64 maxlen) { return read(data, maxlen); }
+	inline qint64 writeBlock(const char *data, quint64 len) { return write(data, len); }
+	inline qint64 writeBlock(const QByteArray &data) { return write(data); }
+
+// 	virtual inline qint64 readData ( char * data, qint64 maxSize ) { return readBlock(data, maxSize); }
+// 	virtual inline qint64 writeData ( const char * data, qint64 maxSize ) { return writeBlock(data, maxSize); }
+
+	inline int getch() { char c; return getChar(&c) ? int(uchar(c)) : -1; }
+	inline int putch(int c) { return putChar(char(c)) ? int(uchar(c)) : -1; }
+	inline int ungetch(int c) { ungetChar(uchar(c)); return c; }
+
+	inline bool isDirectAccess() const { return !isSequential(); }
+	inline bool isSequentialAccess() const { return isSequential(); }
+	inline bool isCombinedAccess() const { return false; }
+	inline bool isBuffered() const { return true; }
+	inline bool isRaw() const { return false; }
+	inline bool isSynchronous() const { return true; }
+	inline bool isAsynchronous() const { return false; }
+	inline bool isTranslated() const { return (openMode() & Text) != 0; }
+	inline bool isInactive() const { return !isOpen(); }
+
+	inline TQByteArray &buffer() { return static_cast<TQByteArray&>(QBuffer::buffer()); }
+	inline bool setBuffer( TQByteArray &tqba ) { if (isOpen() == TRUE) return FALSE; QBuffer::setBuffer(&tqba); return TRUE; }
+	inline bool tqsetBufferFromCopy( TQByteArray tqba ) { if (isOpen() == TRUE) return FALSE; internal_ba_copy = tqba; QBuffer::setBuffer(&internal_ba_copy); return TRUE; }
+// 	inline bool setBuffer( TQByteArray tqba ) { if (isOpen() == TRUE) return FALSE; internal_ba_copy = tqba; QBuffer::setBuffer(&internal_ba_copy); return TRUE; }
+
+public:
+	typedef int Status;
+	Status status() const {
+#if !defined(QT_NO_QOBJECT)
+		const QFile *f = qobject_cast<const QFile *>(this);
+		if (f) return (int) f->error();
+#endif
+		return isOpen() ? 0 /* IO_Ok */ : 8 /* IO_UnspecifiedError */;
+	}
+	void resetStatus() {
+#if !defined(QT_NO_QOBJECT)
+		QFile *f = qobject_cast<QFile *>(this);
+		if (f) f->unsetError();
+#endif
+	}
+
+	void setqStatus( int ) { std::cout << "[WARNING] TQBuffer::setqStatus() UNIMPLEMENTED\n\r"; }
+	void resetqStatus() { resetStatus(); }
+
+private:
+	TQByteArray internal_ba_copy;
+};
+
+#else // USE_QT4
+
+class TQ_EXPORT TQBuffer : public TQIODevice
+{
+public:
+    TQBuffer();
+    TQBuffer( TQByteArray );
+   ~TQBuffer();
+
+    TQByteArray buffer() const;
+    bool  setBuffer( TQByteArray );
+
+    bool  open( int );
+    void  close();
+    void  flush();
+
+    Offset size() const;
+    Offset at() const;
+    bool  at( Offset );
+
+    TQ_LONG	  readBlock( char *p, TQ_ULONG );
+    TQ_LONG	  writeBlock( const char *p, TQ_ULONG );
+    TQ_LONG	  writeBlock( const TQByteArray& data )
+	      { return TQIODevice::writeBlock(data); }
+    TQ_LONG	  readLine( char *p, TQ_ULONG );
+
+    int	  getch();
+    int	  putch( int );
+    int	  ungetch( int );
+
+protected:
+    TQByteArray a;
+
+private:
+    uint  a_len;
+    uint  a_inc;
+
+private:	// Disabled copy constructor and operator=
+#if defined(TQ_DISABLE_COPY)
+    TQBuffer( const TQBuffer & );
+    TQBuffer &operator=( const TQBuffer & );
+#endif
+};
+
+
+inline TQByteArray TQBuffer::buffer() const
+{ return a; }
+
+inline TQIODevice::Offset TQBuffer::size() const
+{ return (Offset)a.size(); }
+
+inline TQIODevice::Offset TQBuffer::at() const
+{ return ioIndex; }
+
+#endif // USE_QT4
+
+#endif // TQBUFFER_H
diff --git a/tqtinterface/qt4/src/tools/tqcache.h b/tqtinterface/qt4/src/tools/tqcache.h
new file mode 100644
index 0000000..72881d4
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqcache.h
@@ -0,0 +1,121 @@
+/****************************************************************************
+**
+** Definition of TQCache template class
+**
+** Created : 950209
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQCACHE_H
+#define TQCACHE_H
+
+#ifndef TQT_H
+#include "tqgcache.h"
+#endif // TQT_H
+
+template<class type>
+class TQCache
+#ifdef TQ_TQDOC
+	: public TQPtrCollection
+#else
+	: public TQGCache
+#endif
+{
+public:
+    TQCache( const TQCache<type> &c ) : TQGCache(c) {}
+    TQCache( int maxCost=100, int size=17, bool caseSensitive=TRUE )
+	: TQGCache( maxCost, size, StringKey, caseSensitive, FALSE ) {}
+   ~TQCache()				{ clear(); }
+    TQCache<type> &operator=( const TQCache<type> &c )
+			{ return (TQCache<type>&)TQGCache::operator=(c); }
+    int	  maxCost()   const		{ return TQGCache::maxCost(); }
+    int	  totalCost() const		{ return TQGCache::totalCost(); }
+    void  setMaxCost( int m )		{ TQGCache::setMaxCost(m); }
+    uint  count()     const		{ return TQGCache::count(); }
+    uint  size()      const		{ return TQGCache::size(); }
+    bool  isEmpty()   const		{ return TQGCache::count() == 0; }
+    void  clear()			{ TQGCache::clear(); }
+    bool  insert( const TQString &k, const type *d, int c=1, int p=0 )
+			{ return TQGCache::insert_string(k,(Item)d,c,p);}
+    bool  remove( const TQString &k )
+			{ return TQGCache::remove_string(k); }
+    type *take( const TQString &k )
+			{ return (type *)TQGCache::take_string(k); }
+    type *tqfind( const TQString &k, bool ref=TRUE ) const
+			{ return (type *)TQGCache::tqfind_string(k,ref);}
+    type *operator[]( const TQString &k ) const
+			{ return (type *)TQGCache::tqfind_string(k);}
+    void  statistics() const	      { TQGCache::statistics(); }
+private:
+    void  deleteItem( Item d );
+};
+
+#if !defined(TQ_BROKEN_TEMPLATE_SPECIALIZATION)
+template<> inline void TQCache<void>::deleteItem( TQPtrCollection::Item )
+{
+}
+#endif
+
+template<class type> inline void TQCache<type>::deleteItem( TQPtrCollection::Item d )
+{
+    if ( del_item ) delete (type *)d;
+}
+
+template<class type>
+class TQCacheIterator : public TQGCacheIterator
+{
+public:
+    TQCacheIterator( const TQCache<type> &c ):TQGCacheIterator((TQGCache &)c) {}
+    TQCacheIterator( const TQCacheIterator<type> &ci)
+				: TQGCacheIterator( (TQGCacheIterator &)ci ) {}
+    TQCacheIterator<type> &operator=(const TQCacheIterator<type>&ci)
+	{ return ( TQCacheIterator<type>&)TQGCacheIterator::operator=( ci ); }
+    uint  count()   const     { return TQGCacheIterator::count(); }
+    bool  isEmpty() const     { return TQGCacheIterator::count() == 0; }
+    bool  atFirst() const     { return TQGCacheIterator::atFirst(); }
+    bool  atLast()  const     { return TQGCacheIterator::atLast(); }
+    type *toFirst()	      { return (type *)TQGCacheIterator::toFirst(); }
+    type *toLast()	      { return (type *)TQGCacheIterator::toLast(); }
+    operator type *() const   { return (type *)TQGCacheIterator::get(); }
+    type *current()   const   { return (type *)TQGCacheIterator::get(); }
+    TQString currentKey() const{ return TQGCacheIterator::getKeyString(); }
+    type *operator()()	      { return (type *)TQGCacheIterator::operator()();}
+    type *operator++()	      { return (type *)TQGCacheIterator::operator++(); }
+    type *operator+=(uint j)  { return (type *)TQGCacheIterator::operator+=(j);}
+    type *operator--()	      { return (type *)TQGCacheIterator::operator--(); }
+    type *operator-=(uint j)  { return (type *)TQGCacheIterator::operator-=(j);}
+};
+
+#endif // TQCACHE_H
diff --git a/tqtinterface/qt4/src/tools/tqcleanuphandler.h b/tqtinterface/qt4/src/tools/tqcleanuphandler.h
new file mode 100644
index 0000000..a7e5ea1
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqcleanuphandler.h
@@ -0,0 +1,130 @@
+/****************************************************************************
+**
+** ...
+**
+** Copyright (C) 2001-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQCLEANUPHANDLER_H
+#define TQCLEANUPHANDLER_H
+
+#ifndef TQT_H
+#include "tqptrlist.h"
+#endif // TQT_H
+
+template<class Type>
+class TQCleanupHandler
+{
+public:
+    TQCleanupHandler() : cleanupObjects( 0 ) {}
+    ~TQCleanupHandler() { clear(); }
+
+    Type* add( Type **object ) {
+	if ( !cleanupObjects )
+	    cleanupObjects = new TQPtrList<Type*>;
+	cleanupObjects->insert( 0, object );
+	return *object;
+    }
+
+    void remove( Type **object ) {
+	if ( !cleanupObjects )
+	    return;
+	if ( cleanupObjects->tqfindRef( object ) >= 0 )
+	    (void) cleanupObjects->take();
+    }
+
+    bool isEmpty() const {
+	return cleanupObjects ? cleanupObjects->isEmpty() : TRUE;
+    }
+
+    void clear() {
+	if ( !cleanupObjects )
+	    return;
+	TQPtrListIterator<Type*> it( *cleanupObjects );
+	Type **object;
+	while ( ( object = it.current() ) ) {
+	    delete *object;
+	    *object = 0;
+	    cleanupObjects->remove( object );
+	}
+	delete cleanupObjects;
+	cleanupObjects = 0;
+    }
+
+private:
+    TQPtrList<Type*> *cleanupObjects;
+};
+
+template<class Type>
+class TQSingleCleanupHandler
+{
+public:
+    TQSingleCleanupHandler() : object( 0 ) {}
+    ~TQSingleCleanupHandler() {
+	if ( object ) {
+	    delete *object;
+	    *object = 0;
+	}
+    }
+    Type* set( Type **o ) {
+	object = o;
+	return *object;
+    }
+    void reset() { object = 0; }
+private:
+    Type **object;
+};
+
+template<class Type>
+class TQSharedCleanupHandler
+{
+public:
+    TQSharedCleanupHandler() : object( 0 ) {}
+    ~TQSharedCleanupHandler() {
+	if ( object ) {
+	    if ( (*object)->deref() )
+		delete *object;
+	    *object = 0;
+	}
+    }
+    Type* set( Type **o ) {
+	object = o;
+	return *object;
+    }
+    void reset() { object = 0; }
+private:
+    Type **object;
+};
+
+#endif //TQCLEANUPHANDLER_H
diff --git a/tqtinterface/qt4/src/tools/tqcom_p.h b/tqtinterface/qt4/src/tools/tqcom_p.h
new file mode 100644
index 0000000..2d41781
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqcom_p.h
@@ -0,0 +1,344 @@
+/****************************************************************************
+**
+** ...
+**
+** Copyright (C) 2001-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQCOM_P_H
+#define TQCOM_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the TQt API.  It exists for the convenience
+// of a number of TQt sources files.  This header file may change from
+// version to version without notice, or even be removed.
+//
+// We mean it.
+//
+//
+
+#ifndef TQT_H
+#include "tqstringlist.h"
+#include "tquuid.h"
+#endif // TQT_H
+
+#if __GNUC__ - 0 > 3
+#pragma GCC system_header
+#endif
+
+#ifndef TQT_NO_COMPONENT
+
+class TQObject;
+struct TQUInterfaceDescription;
+struct TQUObject;
+
+#define TQRESULT		unsigned long
+#define TQS_OK		(TQRESULT)0x00000000
+#define TQS_FALSE	(TQRESULT)0x00000001
+
+#define TQE_NOTIMPL      (TQRESULT)0x80000001
+#define TQE_OUTOFMEMORY  (TQRESULT)0x80000002
+#define TQE_INVALIDARG	(TQRESULT)0x80000003
+#define TQE_NOINTERFACE	(TQRESULT)0x80000004
+#define TQE_NOCOMPONENT	(TQRESULT)0x80000005
+
+
+// {1D8518CD-E8F5-4366-99E8-879FD7E482DE}
+#ifndef IID_TQUnknown
+#define IID_TQUnknown TQUuid(0x1d8518cd, 0xe8f5, 0x4366, 0x99, 0xe8, 0x87, 0x9f, 0xd7, 0xe4, 0x82, 0xde)
+#endif
+
+struct TQ_EXPORT TQUnknownInterface
+{
+    virtual TQRESULT queryInterface( const TQUuid&, TQUnknownInterface** ) = 0;
+    virtual ulong   addRef() = 0;
+    virtual ulong   release() = 0;
+};
+
+// {FBAC965E-A441-413F-935E-CDF582573FAB}
+#ifndef IID_TQDispatch
+#define IID_TQDispatch TQUuid( 0xfbac965e, 0xa441, 0x413f, 0x93, 0x5e, 0xcd, 0xf5, 0x82, 0x57, 0x3f, 0xab)
+#endif
+
+// the dispatch interface that inherits the unknown interface.. It is
+// used to explore interfaces during runtime and to do dynamic calls.
+struct TQ_EXPORT TQDispatchInterface : public TQUnknownInterface
+{
+    // returns the interface description of this dispatch interface.
+    virtual const TQUInterfaceDescription* interfaceDescription() const = 0;
+
+    // returns the event description of this dispatch interface.
+    virtual const TQUInterfaceDescription* eventsDescription() const = 0;
+
+    // invokes method id with parameters V*. Returns some sort of
+    // exception code.
+    virtual TQRESULT invoke( int id, TQUObject* o ) = 0;
+
+    // installs listener as event listener
+    virtual void installListener( TQDispatchInterface* listener ) = 0;
+
+    // remove listener as event listener
+    virtual void removeListener( TQDispatchInterface* listener ) = 0;
+};
+
+template <class T>
+class TQInterfacePtr
+{
+public:
+    TQInterfacePtr():iface(0){}
+
+    TQInterfacePtr( T* i) {
+	if ( (iface = i) )
+	    iface->addRef();
+    }
+
+    TQInterfacePtr(const TQInterfacePtr<T> &p) {
+	if ( (iface = p.iface) )
+	    iface->addRef();
+    }
+
+    ~TQInterfacePtr() {
+	if ( iface )
+	    iface->release();
+    }
+
+    TQInterfacePtr<T> &operator=(const TQInterfacePtr<T> &p) {
+	if ( iface != p.iface ) {
+	    if ( iface )
+		iface->release();
+	    if ( (iface = p.iface) )
+		iface->addRef();
+	}
+	return *this;
+    }
+
+    TQInterfacePtr<T> &operator=(T* i) {
+	if (iface != i ) {
+	    if ( iface )
+		iface->release();
+	    if ( (iface = i) )
+		iface->addRef();
+	}
+	return *this;
+    }
+
+    bool operator==( const TQInterfacePtr<T> &p ) const { return iface == p.iface; }
+
+    bool operator!= ( const TQInterfacePtr<T>& p ) const {  return !( *this == p ); }
+
+    bool isNull() const { return !iface; }
+
+    T* operator->() const { return iface; }
+
+    T& operator*() const { return *iface; }
+
+    operator T*() const { return iface; }
+
+    TQUnknownInterface** operator &() const {
+	if( iface )
+	    iface->release();
+	return (TQUnknownInterface**)&iface;
+    }
+
+    T** operator &() {
+	if ( iface )
+	    iface->release();
+	return &iface;
+    }
+
+private:
+    T* iface;
+};
+
+// {10A1501B-4C5F-4914-95DD-C400486CF900}
+#ifndef IID_TQObject
+#define IID_TQObject TQUuid( 0x10a1501b, 0x4c5f, 0x4914, 0x95, 0xdd, 0xc4, 0x00, 0x48, 0x6c, 0xf9, 0x00)
+#endif
+
+struct TQ_EXPORT TQObjectInterface
+{
+    virtual TQObject*   qObject() = 0;
+};
+
+// {5F3968A5-F451-45b1-96FB-061AD98F926E}
+#ifndef IID_TQComponentInformation
+#define IID_TQComponentInformation TQUuid(0x5f3968a5, 0xf451, 0x45b1, 0x96, 0xfb, 0x6, 0x1a, 0xd9, 0x8f, 0x92, 0x6e)
+#endif
+
+struct TQ_EXPORT TQComponentInformationInterface : public TQUnknownInterface
+{
+    virtual TQString name() const = 0;
+    virtual TQString description() const = 0;
+    virtual TQString author() const = 0;
+    virtual TQString version() const = 0;
+};
+
+// {6CAA771B-17BB-4988-9E78-BA5CDDAAC31E}
+#ifndef IID_TQComponentFactory
+#define IID_TQComponentFactory TQUuid( 0x6caa771b, 0x17bb, 0x4988, 0x9e, 0x78, 0xba, 0x5c, 0xdd, 0xaa, 0xc3, 0x1e)
+#endif
+
+struct TQ_EXPORT TQComponentFactoryInterface : public TQUnknownInterface
+{
+    virtual TQRESULT createInstance( const TQUuid &cid, const TQUuid &iid, TQUnknownInterface** instance, TQUnknownInterface *outer ) = 0;
+};
+
+// {D16111D4-E1E7-4C47-8599-24483DAE2E07}
+#ifndef IID_TQLibrary
+#define IID_TQLibrary TQUuid( 0xd16111d4, 0xe1e7, 0x4c47, 0x85, 0x99, 0x24, 0x48, 0x3d, 0xae, 0x2e, 0x07)
+#endif
+
+struct TQ_EXPORT TQLibraryInterface : public TQUnknownInterface
+{
+    virtual bool    init() = 0;
+    virtual void    cleanup() = 0;
+    virtual bool    canUnload() const = 0;
+};
+
+// {3F8FDC44-3015-4f3e-B6D6-E4AAAABDEAAD}
+#ifndef IID_TQFeatureList
+#define IID_TQFeatureList TQUuid(0x3f8fdc44, 0x3015, 0x4f3e, 0xb6, 0xd6, 0xe4, 0xaa, 0xaa, 0xbd, 0xea, 0xad)
+#endif
+
+struct TQ_EXPORT TQFeatureListInterface : public TQUnknownInterface
+{
+    virtual TQStringList	featureList() const = 0;
+};
+
+// {B5FEB5DE-E0CD-4E37-B0EB-8A812499A0C1}
+#ifndef IID_TQComponentRegistration
+#define IID_TQComponentRegistration TQUuid( 0xb5feb5de, 0xe0cd, 0x4e37, 0xb0, 0xeb, 0x8a, 0x81, 0x24, 0x99, 0xa0, 0xc1)
+#endif
+
+struct TQ_EXPORT TQComponentRegistrationInterface : public TQUnknownInterface
+{
+    virtual bool    registerComponents( const TQString &filepath ) const = 0;
+    virtual bool    unregisterComponents() const = 0;
+};
+
+// internal class that wraps an initialized ulong
+struct TQ_EXPORT TQtULong
+{
+    TQtULong() : ref( 0 ) { }
+    operator unsigned long () const { return ref; }
+    unsigned long& operator++() { return ++ref; }
+    unsigned long operator++( int ) { return ref++; }
+    unsigned long& operator--() { return --ref; }
+    unsigned long operator--( int ) { return ref--; }
+
+    unsigned long ref;
+};
+// default implementation of ref counting. A variable "ulong ref" has to be a member
+
+
+#define TQ_REFCOUNT \
+private:	   \
+    TQtULong qtrefcount;   \
+public:		   \
+    ulong addRef() {return qtrefcount++;} \
+    ulong release() {if(!--qtrefcount){delete this;return 0;}return qtrefcount;}
+
+#ifndef TQ_EXPORT_COMPONENT
+#if defined(TQT_THREAD_SUPPORT)
+#define TQT_THREADED_BUILD 1
+#define TQ_UCM_FLAGS_STRING "11"
+#else
+#define TQT_THREADED_BUILD 0
+#define TQ_UCM_FLAGS_STRING "01"
+#endif
+
+#ifndef TQ_EXTERN_C
+#ifdef __cplusplus
+#define TQ_EXTERN_C    extern "C"
+#else
+#define TQ_EXTERN_C    extern
+#endif
+#endif
+
+// this is duplicated at TQ_PLUGIN_VERIFICATION_DATA in tqgplugin.h
+// NOTE: if you change pattern, you MUST change the pattern in
+// qcomlibrary.cpp as well.  changing the pattern will break all
+// backwards compatibility as well (no old plugins will be loaded).
+#ifndef TQ_UCM_VERIFICATION_DATA
+#  define TQ_UCM_VERIFICATION_DATA \
+	static const char *qt_ucm_verification_data =			\
+            "pattern=""TQT_UCM_VERIFICATION_DATA""\n"			\
+            "version="TQT_VERSION_STR"\n"				\
+            "flags="TQ_UCM_FLAGS_STRING"\n"				\
+	    "buildkey="TQT_BUILD_KEY"\0";
+#endif // TQ_UCM_VERIFICATION_DATA
+
+// This macro expands to the default implementation of ucm_instantiate.
+#ifndef TQ_CREATE_INSTANCE
+#    define TQ_CREATE_INSTANCE( IMPLEMENTATION )		\
+	IMPLEMENTATION *i = new IMPLEMENTATION;		\
+	TQUnknownInterface* iface = 0; 			\
+	i->queryInterface( IID_TQUnknown, &iface );	\
+	return iface;
+#endif // TQ_CREATE_INSTANCE
+
+#    ifdef TQ_WS_WIN
+#	ifdef TQ_CC_BOR
+#	    define TQ_EXPORT_COMPONENT() \
+	        TQ_UCM_VERIFICATION_DATA \
+		TQ_EXTERN_C __declspec(dllexport) \
+                const char * __stdcall qt_ucm_query_verification_data() \
+                { return qt_ucm_verification_data; } \
+		TQ_EXTERN_C __declspec(dllexport) TQUnknownInterface* \
+                __stdcall ucm_instantiate()
+#	else
+#	    define TQ_EXPORT_COMPONENT() \
+	        TQ_UCM_VERIFICATION_DATA \
+		TQ_EXTERN_C __declspec(dllexport) \
+                const char *qt_ucm_query_verification_data() \
+                { return qt_ucm_verification_data; } \
+		TQ_EXTERN_C __declspec(dllexport) TQUnknownInterface* ucm_instantiate()
+#	endif
+#    else
+#	define TQ_EXPORT_COMPONENT() \
+	    TQ_UCM_VERIFICATION_DATA \
+	    TQ_EXTERN_C \
+            const char *qt_ucm_query_verification_data() \
+            { return qt_ucm_verification_data; } \
+	    TQ_EXTERN_C TQUnknownInterface* ucm_instantiate()
+#    endif
+#    define TQ_EXPORT_INTERFACE() TQ_EXPORT_COMPONENT()
+#endif
+
+#endif //TQT_NO_COMPONENT
+
+#endif //TQCOM_P_H
diff --git a/tqtinterface/qt4/src/tools/tqcomlibrary.cpp b/tqtinterface/qt4/src/tools/tqcomlibrary.cpp
new file mode 100644
index 0000000..253f9bf
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqcomlibrary.cpp
@@ -0,0 +1,538 @@
+/****************************************************************************
+**
+** Implementation of TQComLibrary class
+**
+** Copyright (C) 2001-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "tqcomlibrary_p.h"
+
+#ifndef TQT_NO_COMPONENT
+#include <tqapplication.h>
+#include <tqsettings.h>
+#include <tqfileinfo.h>
+#include <tqdatetime.h>
+#include <tqcleanuphandler.h>
+#ifndef NO_ERRNO_H
+#include <errno.h>
+#endif // NO_ERROR_H
+
+#ifdef TQT_THREAD_SUPPORT
+#  include "tqmutexpool_p.h"
+#endif // TQT_THREAD_SUPPORT
+
+#ifndef TQT_DEBUG_COMPONENT
+# if defined(TQT_DEBUG)
+#  define TQT_DEBUG_COMPONENT 1
+# endif
+#endif
+
+
+TQComLibrary::TQComLibrary( const TQString &filename )
+    : TQLibrary( filename ), entry( 0 ), libiface( 0 ), qt_version( 0 )
+{
+}
+
+TQComLibrary::~TQComLibrary()
+{
+    if ( autoUnload() )
+	unload();
+    if ( libiface )
+	libiface->release();
+    if ( entry )
+	entry->release();
+}
+
+bool TQComLibrary::unload()
+{
+    int refs = entry ? entry->release() : 0;
+    entry = 0;
+    if (refs || !libiface)
+	return FALSE;
+
+    libiface->cleanup();
+    if ( !libiface->canUnload() )
+	return FALSE;
+    libiface->release();
+    libiface = 0;
+
+    return TQLibrary::unload();
+}
+
+static bool qt_verify( const TQString& library, uint version, uint flags,
+		    const TQCString &key, bool warn )
+{
+    uint our_flags = 1;
+#if defined(TQT_THREAD_SUPPORT)
+    our_flags |= 2;
+#endif
+
+    if ( (flags & 1) == 0 ) {
+	if ( warn )
+	    qWarning( "Conflict in %s:\n"
+		      "  Plugin cannot be queried successfully! [2]",
+		      (const char*) TQFile::encodeName(library) );
+    } else if ( ( version > TQT_VERSION ) ||
+		( ( TQT_VERSION & 0xff0000 ) > ( version & 0xff0000 ) ) ) {
+	if ( warn )
+	    qWarning( "Conflict in %s:\n"
+		      "  Plugin uses incompatible TQt library (%d.%d.%d)!",
+		      (const char*) TQFile::encodeName(library),
+		      (version&0xff0000) >> 16, (version&0xff00) >> 8, version&0xff );
+    } else if ( (flags & 2) != (our_flags & 2) ) {
+	if ( warn )
+	    qWarning( "Conflict in %s:\n"
+		      "  Plugin uses %s TQt library!",
+		      (const char*) TQFile::encodeName(library),
+		      (flags & 2) ? "multi threaded" : "single threaded" );
+    } else if ( key != TQT_BUILD_KEY ) {
+	if ( warn )
+	    qWarning( "Conflict in %s:\n"
+		      "  Plugin uses incompatible TQt library!\n"
+		      "  expected build key \"%s\", got \"%s\".",
+		      (const char*) TQFile::encodeName(library),
+		      TQT_BUILD_KEY,
+		      key.isEmpty() ? "<null>" : (const char *) key );
+    } else {
+	return TRUE;
+    }
+    return FALSE;
+}
+
+struct qt_token_info
+{
+    qt_token_info( const char *f, const ulong fc )
+	: fields( f ), field_count( fc ), results( fc ), lengths( fc )
+    {
+	results.fill( 0 );
+	lengths.fill( 0 );
+    }
+
+    const char *fields;
+    const ulong field_count;
+
+    TQMemArray<const char *> results;
+    TQMemArray<ulong> lengths;
+};
+
+/*
+  return values:
+       1 parse ok
+       0 eos
+      -1 parse error
+*/
+static int qt_tokenize( const char *s, ulong s_len, ulong *advance,
+			const qt_token_info &token_info )
+{
+    ulong pos = 0, field = 0, fieldlen = 0;
+    char current;
+    int ret = -1;
+    *advance = 0;
+    for (;;) {
+	current = s[ pos ];
+
+	// next char
+	++pos;
+	++fieldlen;
+	++*advance;
+
+	if ( ! current || pos == s_len + 1 ) {
+	    // save result
+	    token_info.results[ (int)field ] = s;
+	    token_info.lengths[ (int)field ] = fieldlen - 1;
+
+	    // end of string
+	    ret = 0;
+	    break;
+	}
+
+	if ( current == token_info.fields[ field ] ) {
+	    // save result
+	    token_info.results[ (int)field ] = s;
+	    token_info.lengths[ (int)field ] = fieldlen - 1;
+
+	    // end of field
+	    fieldlen = 0;
+	    ++field;
+	    if ( field == token_info.field_count - 1 ) {
+		// parse ok
+		ret = 1;
+	    }
+	    if ( field == token_info.field_count ) {
+		// done parsing
+		break;
+	    }
+
+	    // reset string and its length
+	    s = s + pos;
+	    s_len -= pos;
+	    pos = 0;
+	}
+    }
+
+    return ret;
+}
+
+/*
+  returns TRUE if the string s was correctly parsed, FALSE otherwise.
+*/
+static bool tqt_parse_pattern( const char *s, uint *version, uint *flags,
+				   TQCString *key )
+{
+    bool ret = TRUE;
+
+    qt_token_info pinfo("=\n", 2);
+    int parse;
+    ulong at = 0, advance, parselen = tqstrlen( s );
+    do {
+	parse = qt_tokenize( s + at, parselen, &advance, pinfo );
+	if ( parse == -1 ) {
+	    ret = FALSE;
+	    break;
+	}
+
+	at += advance;
+	parselen -= advance;
+
+	if ( tqstrncmp( "version", pinfo.results[ 0 ], pinfo.lengths[ 0 ] ) == 0 ) {
+	    // parse version string
+	    qt_token_info pinfo2("..-", 3);
+	    if ( qt_tokenize( pinfo.results[ 1 ], pinfo.lengths[ 1 ],
+			      &advance, pinfo2 ) != -1 ) {
+		TQCString m( pinfo2.results[ 0 ], pinfo2.lengths[ 0 ] + 1 );
+		TQCString n( pinfo2.results[ 1 ], pinfo2.lengths[ 1 ] + 1 );
+		TQCString p( pinfo2.results[ 2 ], pinfo2.lengths[ 2 ] + 1 );
+		*version  = (m.toUInt() << 16) | (n.toUInt() << 8) | p.toUInt();
+	    } else {
+		ret = FALSE;
+		break;
+	    }
+	} else if ( tqstrncmp( "flags", pinfo.results[ 0 ], pinfo.lengths[ 0 ] ) == 0 ) {
+	    // parse flags string
+	    char ch;
+	    *flags = 0;
+	    ulong p = 0, c = 0, bit = 0;
+	    while ( p < pinfo.lengths[ 1 ] ) {
+		ch = pinfo.results[ 1 ][ p ];
+		bit = pinfo.lengths[ 1 ] - p - 1;
+		c = 1 << bit;
+		if ( ch == '1' ) {
+		    *flags |= c;
+		} else if ( ch != '0' ) {
+		    ret = FALSE;
+		    break;
+		}
+		++p;
+	    }
+	} else if ( tqstrncmp( "buildkey", pinfo.results[ 0 ],
+			      pinfo.lengths[ 0 ] ) == 0 ){
+	    // save buildkey
+	    *key = TQCString( pinfo.results[ 1 ], pinfo.lengths[ 1 ] + 1 );
+	}
+    } while ( parse == 1 && parselen > 0 );
+
+    return ret;
+}
+
+#if defined(TQ_OS_UNIX)
+
+#if defined(TQ_OS_FREEBSD) || defined(TQ_OS_LINUX)
+#  define USE_MMAP
+#  include <sys/types.h>
+#  include <sys/mman.h>
+#endif // TQ_OS_FREEBSD || TQ_OS_LINUX
+
+static long qt_tqfind_pattern( const char *s, ulong s_len,
+			     const char *pattern, ulong p_len )
+{
+    /*
+      this uses the same algorithm as TQString::tqfindRev...
+
+      we search from the end of the file because on the supported
+      systems, the read-only data/text segments are placed at the end
+      of the file.  HOWEVER, when building with debugging enabled, all
+      the debug symbols are placed AFTER the data/text segments.
+
+      what does this mean?  when building in release mode, the search
+      is fast because the data we are looking for is at the end of the
+      file... when building in debug mode, the search is slower
+      because we have to skip over all the debugging symbols first
+    */
+
+    if ( ! s || ! pattern || p_len > s_len ) return -1;
+    ulong i, hs = 0, hp = 0, delta = s_len - p_len;
+
+    for (i = 0; i < p_len; ++i ) {
+	hs += s[delta + i];
+	hp += pattern[i];
+    }
+    i = delta;
+    for (;;) {
+	if ( hs == hp && tqstrncmp( s + i, pattern, p_len ) == 0 )
+	    return i;
+	if ( i == 0 )
+	    break;
+	--i;
+	hs -= s[i + p_len];
+	hs += s[i];
+    }
+
+    return -1;
+}
+
+/*
+  This opens the specified library, mmaps it into memory, and searches
+  for the TQT_UCM_VERIFICATION_DATA.  The advantage of this approach is that
+  we can get the verification data without have to actually load the library.
+  This lets us detect mismatches more safely.
+
+  Returns FALSE if version/flags/key information is not present, or if the
+                information could not be read.
+  Returns  TRUE if version/flags/key information is present and succesfully read.
+*/
+static bool tqt_unix_query( const TQString &library, uint *version, uint *flags,
+			   TQCString *key )
+{
+    TQFile file( library );
+    if (! file.open( IO_ReadOnly ) ) {
+	qWarning( "%s: %s", (const char*) TQFile::encodeName(library),
+	    strerror( errno ) );
+	return FALSE;
+    }
+
+    TQByteArray data;
+    char *filedata = 0;
+    ulong fdlen = 0;
+
+#ifdef USE_MMAP
+    char *mapaddr = 0;
+    size_t maplen = file.size();
+    mapaddr = (char *) mmap( mapaddr, maplen, PROT_READ, MAP_PRIVATE, file.handle(), 0 );
+    if ( mapaddr != MAP_FAILED ) {
+	// mmap succeeded
+	filedata = mapaddr;
+	fdlen = maplen;
+    } else {
+	// mmap failed
+	qWarning( "mmap: %s", strerror( errno ) );
+#endif // USE_MMAP
+	// try reading the data into memory instead
+	data = file.readAll();
+	filedata = data.data();
+	fdlen = data.size();
+#ifdef USE_MMAP
+    }
+#endif // USE_MMAP
+
+    // verify that the pattern is present in the plugin
+    const char *pattern = "pattern=TQT_UCM_VERIFICATION_DATA";
+    const ulong plen = tqstrlen( pattern );
+    long pos = qt_tqfind_pattern( filedata, fdlen, pattern, plen );
+
+    bool ret = FALSE;
+    if ( pos >= 0 ) {
+	ret = tqt_parse_pattern( filedata + pos, version, flags, key );
+    }
+
+#ifdef USE_MMAP
+    if ( mapaddr != MAP_FAILED && munmap(mapaddr, maplen) != 0 ) {
+	qWarning( "munmap: %s", strerror( errno ) );
+    }
+#endif // USE_MMAP
+
+    file.close();
+    return ret;
+}
+
+#endif // TQ_OS_UNIX
+
+
+static TQSettings *cache = 0;
+static TQSingleCleanupHandler<TQSettings> cleanup_cache;
+
+void TQComLibrary::createInstanceInternal()
+{
+    if ( library().isEmpty() )
+	return;
+
+    TQFileInfo fileinfo( library() );
+    TQString lastModified  = fileinfo.lastModified().toString(Qt::ISODate);
+    TQString regkey = TQString("/TQt Plugins %1.%2/%3")
+		     .arg( ( TQT_VERSION & 0xff0000 ) >> 16 )
+		     .arg( ( TQT_VERSION & 0xff00 ) >> 8 )
+		     .arg( library() );
+    TQStringList reg;
+    uint flags = 0;
+    TQCString key;
+    bool query_done = FALSE;
+    bool warn_mismatch = TRUE;
+
+#ifdef TQT_THREAD_SUPPORT
+    TQMutexLocker locker( tqt_global_mutexpool ?
+			 tqt_global_mutexpool->get( &cache ) : 0 );
+#endif // TQT_THREAD_SUPPORT
+
+    if ( ! cache ) {
+	cache = new TQSettings;
+	cache->insertSearchPath( TQSettings::Windows, "/Trolltech" );
+	cleanup_cache.set( &cache );
+    }
+
+    reg = cache->readListEntry( regkey );
+    if ( reg.count() == 4 ) {
+	// check timestamp
+	if ( lastModified == reg[3] ) {
+	    qt_version = reg[0].toUInt(0, 16);
+	    flags = reg[1].toUInt(0, 16);
+	    key = reg[2].latin1();
+
+	    query_done = TRUE;
+	    warn_mismatch = FALSE;
+	}
+    }
+
+#if defined(TQ_OS_UNIX)
+    if ( ! query_done ) {
+	// get the query information directly from the plugin without loading
+	if ( tqt_unix_query( library(), &qt_version, &flags, &key ) ) {
+ 	    // info read succesfully from library
+ 	    query_done = TRUE;
+	}
+    }
+#else // !TQ_OS_UNIX
+    if ( ! query_done ) {
+	// get the query information by loading the plugin
+	if ( !isLoaded() ) {
+	    TQ_ASSERT( entry == 0 );
+	    if ( !load() )
+		return;
+	}
+
+#  ifdef TQ_CC_BOR
+	typedef const char * __stdcall (*UCMQueryVerificationDataProc)();
+#  else
+	typedef const char * (*UCMQueryVerificationDataProc)();
+#  endif
+	UCMQueryVerificationDataProc ucmQueryVerificationdataProc;
+	ucmQueryVerificationdataProc =
+	    (UCMQueryVerificationDataProc) resolve( "qt_ucm_query_verification_data" );
+
+	if ( !ucmQueryVerificationdataProc ||
+	     !tqt_parse_pattern( ucmQueryVerificationdataProc(),
+				&qt_version, &flags, &key ) ) {
+	    qt_version = flags = 0;
+	    key = "unknown";
+	} else {
+	    query_done = TRUE;
+	}
+    }
+#endif // TQ_OS_UNIX
+
+    TQStringList queried;
+    queried << TQString::number( qt_version,16 )
+	    << TQString::number( flags, 16 )
+	    <<  key
+	    << lastModified;
+
+    if ( queried != reg ) {
+	cache->writeEntry( regkey, queried );
+	// delete the cache, which forces the settings to be written
+	delete cache;
+	cache = 0;
+    }
+
+    if ( ! query_done ) {
+	if ( warn_mismatch ) {
+	    qWarning( "Conflict in %s:\n Plugin cannot be queried successfully! [1]",
+		      (const char*) TQFile::encodeName( library() ) );
+	}
+	unload();
+	return;
+    }
+
+    if ( ! qt_verify( library(), qt_version, flags, key, warn_mismatch ) ) {
+	unload();
+	return;
+    } else if ( !isLoaded() ) {
+	TQ_ASSERT( entry == 0 );
+	if ( !load() )
+	    return;
+    }
+
+#ifdef TQ_CC_BOR
+    typedef TQUnknownInterface* __stdcall (*UCMInstanceProc)();
+#else
+    typedef TQUnknownInterface* (*UCMInstanceProc)();
+#endif
+    UCMInstanceProc ucmInstanceProc;
+    ucmInstanceProc = (UCMInstanceProc) resolve( "ucm_instantiate" );
+#if defined(TQT_DEBUG_COMPONENT)
+    if ( !ucmInstanceProc )
+	qWarning( "%s: Not a UCOM library.", (const char*) TQFile::encodeName(library()) );
+#endif
+    entry = ucmInstanceProc ? ucmInstanceProc() : 0;
+
+    if ( entry ) {
+	if ( entry->queryInterface( IID_TQLibrary, (TQUnknownInterface**)&libiface ) == TQS_OK ) {
+	    if ( libiface && !libiface->init() ) {
+		libiface->release();
+		libiface = 0;
+		unload();
+		return;
+	    }
+	}
+    } else {
+#if defined(TQT_DEBUG_COMPONENT)
+	qWarning( "%s: No exported component provided.", (const char*) TQFile::encodeName(library()) );
+#endif
+	unload();
+    }
+}
+
+TQRESULT TQComLibrary::queryInterface( const TQUuid& request, TQUnknownInterface** iface )
+{
+    if ( !entry )
+	createInstanceInternal();
+    return entry ? entry->queryInterface( request, iface ) : TQE_NOCOMPONENT;
+}
+
+uint TQComLibrary::qtVersion()
+{
+    if ( !entry )
+	createInstanceInternal();
+    return entry ? qt_version : 0;
+}
+
+
+#endif // TQT_NO_COMPONENT
diff --git a/tqtinterface/qt4/src/tools/tqcomlibrary_p.h b/tqtinterface/qt4/src/tools/tqcomlibrary_p.h
new file mode 100644
index 0000000..470ff4c
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqcomlibrary_p.h
@@ -0,0 +1,82 @@
+/****************************************************************************
+**
+** Definition of TQComLibrary class
+**
+** Copyright (C) 2001-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQCOMLIBRARY_P_H
+#define TQCOMLIBRARY_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the TQt API.  It exists for the convenience
+// of a number of TQt sources files.  This header file may change from
+// version to version without notice, or even be removed.
+//
+// We mean it.
+//
+//
+
+#ifndef TQT_H
+#include "tqcom_p.h"
+#include "tqlibrary.h"
+#endif // TQT_H
+
+#ifndef TQT_NO_COMPONENT
+
+class TQ_EXPORT TQComLibrary : public TQLibrary
+{
+public:
+    TQComLibrary( const TQString &filename );
+    ~TQComLibrary();
+
+    bool unload();
+    TQRESULT queryInterface( const TQUuid &iid, TQUnknownInterface **iface );
+    uint qtVersion();
+
+private:
+    void createInstanceInternal();
+
+    TQUnknownInterface *entry;
+    TQLibraryInterface *libiface;
+    uint qt_version;
+
+};
+
+#endif //TQT_NO_COMPONENT
+
+#endif
diff --git a/tqtinterface/qt4/src/tools/tqcomponentfactory.cpp b/tqtinterface/qt4/src/tools/tqcomponentfactory.cpp
new file mode 100644
index 0000000..800e2b6
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqcomponentfactory.cpp
@@ -0,0 +1,355 @@
+/****************************************************************************
+**
+** Implementation of the TQComponentFactory class
+**
+** Created : 990101
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "tqcomponentfactory_p.h"
+
+#ifndef TQT_NO_COMPONENT
+#include "tqsettings.h"
+#include <private/tqcomlibrary_p.h>
+#include "tqdir.h"
+#include "tqapplication.h"
+
+/*!
+  \class TQComponentFactory qcomponentfactory.h
+  \brief The TQComponentFactory class provides static functions to create and register components.
+
+    \internal
+
+  The static convenience functions can be used both by applications to instantiate components,
+  and by component servers to register components.
+
+  The createInstance() function provides a pointer to an interface implemented in a specific
+  component if the component requested has been installed properly and implements the interface.
+
+  Use registerServer() to load a component server and register its components, and unregisterServer()
+  to unregister the components. The component exported by the component server has to implement the
+  TQComponentRegistrationInterface.
+
+  The static functions registerComponent() and unregisterComponent() register and unregister a single
+  component in the system component registry, and should be used when implementing the
+  \link TQComponentRegistrationInterface::registerComponents() registerCompontents() \endlink and
+  \link TQComponentRegistrationInterface::unregisterComponents() unregisterCompontents() \endlink functions
+  in the TQComponentRegistrationInterface.
+
+  A component is registered using a UUID, but can additionally be registered with a name, version and
+  description. A component registered with a name and a version can be instantiated by client applications
+  using the name and specific version number, or the highest available version number for that component by
+  just using the name. A component that is registered calling
+
+  \code
+  TQComponentFactory::registerComponent( TQUuid(...), filename, "MyProgram.Component", 1 );
+  \endcode
+
+  can be instantiated calling either:
+
+  \code
+  TQComponentFactory::createInstance( TQUuid(...), IID_XYZ, (TQUnknownInterface**)&iface );
+  \endcode
+  or
+  \code
+  TQComponentFactory::createInstance( "MyProgram.Component", IID_XYZ, (TQUnknownInterface**)&iface );
+  \endcode
+  or
+  \code
+  TQComponentFactory::createInstance( "MyProgram.Component.1", IID_XYZ, (TQUnknownInterface**)&iface );
+  \endcode
+
+  The first and the last way will always instantiate exactly the component registered above, while
+  the second call might also return a later version of the same component. This allows smoother upgrading
+  of components, and is easier to use in application source code, but should only be used when new versions
+  of the component are guaranteed to work with the application.
+
+  The component name can be anything, but should be unique on the system the component is being
+  installed on. A common naming convention for components is \e application.component.
+
+  \sa TQComponentRegistrationInterface TQComponentFactoryInterface
+*/
+
+
+static TQPtrList<TQComLibrary> *libraries = 0;
+
+static void cleanup()
+{
+    delete libraries;
+    libraries = 0;
+}
+
+static TQPtrList<TQComLibrary> *liblist()
+{
+    if ( !libraries ) {
+	libraries = new TQPtrList<TQComLibrary>();
+	libraries->setAutoDelete( TRUE );
+	qAddPostRoutine( cleanup );
+    }
+    return libraries;
+}
+
+/*!
+  Searches for the component identifier \a cid in the system component registry,
+  loads the corresponding component server and queries for the interface \a iid.
+  \a iface is set to the resulting interface pointer. \a cid can either be the
+  UUID or the name of the component.
+
+  The parameter \a outer is a pointer to the outer interface used
+  for containment and aggregation and is propagated to the \link
+  TQComponentFactoryInterface::createInstance() createInstance() \endlink
+  implementation of the TQComponentFactoryInterface in the component server if
+  provided.
+
+  The function returns TQS_OK if the interface was successfully instantiated, TQE_NOINTERFACE if
+  the component does not provide an interface \a iid, or TQE_NOCOMPONENT if there was
+  an error loading the component.
+
+  Example:
+  \code
+  TQInterfacePtr<MyInterface> iface;
+  if ( TQComponentFactory::createInstance( IID_MyInterface, CID_MyComponent, (TQUnknownInterface**)&iface ) == TQS_OK )
+      iface->doSomething();
+      ...
+  }
+  \endcode
+*/
+TQRESULT TQComponentFactory::createInstance( const TQString &cid, const TQUuid &iid, TQUnknownInterface** iface, TQUnknownInterface *outer )
+{
+    TQSettings settings;
+    settings.insertSearchPath( TQSettings::Windows, "/Classes" );
+    bool ok = FALSE;
+    TQString cidStr = cid;
+    TQRESULT res = TQE_NOCOMPONENT;
+
+    TQUuid uuid( cidStr ); // try to parse, and resolve CLSID if necessary
+    if ( uuid.isNull() ) {
+	uuid = settings.readEntry( "/" + cid + "/CLSID/Default", TQString::null, &ok );
+	cidStr = uuid.toString().upper();
+    }
+
+    if ( cidStr.isEmpty() )
+	return res;
+
+    TQString file = settings.readEntry( "/CLSID/" + cidStr + "/InprocServer32/Default", TQString::null, &ok );
+    if ( !ok )
+	return res;
+
+    TQComLibrary *library = new TQComLibrary( file );
+    library->setAutoUnload( FALSE );
+
+    TQComponentFactoryInterface *cfIface =0;
+    library->queryInterface( IID_TQComponentFactory, (TQUnknownInterface**)&cfIface );
+
+    if ( cfIface ) {
+	res = cfIface->createInstance( uuid, iid, iface, outer );
+	cfIface->release();
+    } else {
+	res = library->queryInterface( iid, iface );
+    }
+    TQLibraryInterface *libiface = 0;
+    if ( library->queryInterface( IID_TQLibrary, (TQUnknownInterface**)&libiface ) != TQS_OK || !tqApp ) {
+	delete library; // only deletes the object, thanks to TQLibrary::Manual
+    } else {
+	libiface->release();
+	library->setAutoUnload( TRUE );
+	liblist()->prepend( library );
+    }
+    return res;
+}
+
+/*!
+  Loads the shared library \a filename and queries for a
+  TQComponentRegistrationInterface. If the library implements this interface,
+  the \link TQComponentRegistrationInterface::registerComponents()
+  registerComponents() \endlink function is called.
+
+  Returns TRUE if the interface is found and successfully called,
+  otherwise returns FALSE.
+*/
+TQRESULT TQComponentFactory::registerServer( const TQString &filename )
+{
+    TQComLibrary lib( filename );
+    lib.load();
+    TQComponentRegistrationInterface *iface = 0;
+    TQRESULT res = lib.queryInterface( IID_TQComponentRegistration, (TQUnknownInterface**)&iface );
+    if ( res != TQS_OK )
+	return res;
+    TQDir dir( filename );
+    bool ok = iface->registerComponents( dir.absPath() );
+    iface->release();
+    return ok ? TQS_OK : TQS_FALSE;
+}
+
+/*!
+  Loads the shared library \a filename and queries for a
+  TQComponentRegistrationInterface. If the library implements this interface,
+  the \link TQComponentRegistrationInterface::unregisterComponents()
+  unregisterComponents() \endlink function is called.
+
+  Returns TRUE if the interface is found and successfully unregistered,
+  otherwise returns FALSE.
+*/
+TQRESULT TQComponentFactory::unregisterServer( const TQString &filename )
+{
+    TQComLibrary lib( filename );
+    lib.load();
+    TQComponentRegistrationInterface *iface = 0;
+    TQRESULT res = lib.queryInterface( IID_TQComponentRegistration, (TQUnknownInterface**)&iface );
+    if ( res != TQS_OK )
+	return res;
+    bool ok = iface->unregisterComponents();
+    iface->release();
+    return ok ? TQS_OK : TQS_FALSE;
+}
+
+/*!
+  Registers the component with id \a cid in the system component registry and
+  returns TRUE if the component was registerd successfully, otherwise returns
+  FALSE. The component is provided by the component server at \a filepath and
+  registered with an optional \a name, \a version and \a description.
+
+  This function does nothing and returns FALSE if a component with an identical
+  \a cid does already exist on the system.
+
+  A component that has been registered with a \a name can be created using both the
+  \a cid and the \a name value using createInstance().
+
+  Call this function for each component in an implementation of
+  \link TQComponentRegistrationInterface::registerComponents() registerComponents() \endlink.
+
+  \sa unregisterComponent(), registerServer(), createInstance()
+*/
+bool TQComponentFactory::registerComponent( const TQUuid &cid, const TQString &filepath, const TQString &name, int version, const TQString &description )
+{
+    bool ok = FALSE;
+    TQSettings settings;
+    settings.insertSearchPath( TQSettings::Windows, "/Classes" );
+
+    TQString cidStr = cid.toString().upper();
+    settings.readEntry( "/CLSID/" + cidStr + "/InprocServer32/Default", TQString::null, &ok );
+    if ( ok ) // don't overwrite existing component
+	return FALSE;
+
+    ok = settings.writeEntry( "/CLSID/" + cidStr + "/InprocServer32/Default", filepath );
+    if ( ok && !!description )
+	settings.writeEntry( "/CLSID/" + cidStr + "/Default", description );
+
+    // register the human readable part
+    if ( ok && !!name ) {
+	TQString vName = version ? name + "." + TQString::number( version ) : name;
+	settings.writeEntry( "/CLSID/" + cidStr + "/ProgID/Default", vName );
+	ok = settings.writeEntry( "/" + vName + "/CLSID/Default", cidStr );
+	if ( ok && !!description )
+	    settings.writeEntry( "/" + vName + "/Default", description );
+
+	if ( ok && version ) {
+	    settings.writeEntry( "/CLSID/" + cidStr + "/VersionIndependentProgID/Default", name );
+	    TQString curVer = settings.readEntry( "/" + name + "/CurVer/Default" );
+	    if ( !curVer || curVer < vName ) { // no previous, or a lesser version installed
+		settings.writeEntry( "/" + name + "/CurVer/Default", vName );
+		ok = settings.writeEntry( "/" + name + "/CLSID/Default", cidStr );
+		if ( ok && !!description )
+		    settings.writeEntry( "/" + name + "/Default", description );
+	    }
+	}
+    }
+
+    return ok;
+}
+
+/*!
+  Unregisters the component with id \a cid from the system component registry and returns
+  TRUE if the component was unregistered successfully, otherwise returns FALSE.
+
+  Call this function for each component in an implementation of
+  \link TQComponentRegistrationInterface::unregisterComponents() unregisterComponents() \endlink.
+
+  \sa registerComponent(), unregisterServer()
+*/
+bool TQComponentFactory::unregisterComponent( const TQUuid &cid )
+{
+    TQSettings settings;
+    bool ok = FALSE;
+    settings.insertSearchPath( TQSettings::Windows, "/Classes" );
+
+    TQString cidStr = cid.toString().upper();
+    if ( cidStr.isEmpty() )
+	return FALSE;
+
+    // unregister the human readable part
+    TQString vName = settings.readEntry( "/CLSID/" + cidStr + "/ProgID/Default", TQString::null, &ok );
+    if ( ok ) {
+	TQString name = settings.readEntry( "/CLSID/" + cidStr + "/VersionIndependentProgID/Default", TQString::null );
+	if ( !!name && settings.readEntry( "/" + name + "/CurVer/Default" ) == vName ) {
+	    // unregistering the current version -> change CurVer to previous version
+	    TQString version = vName.right( vName.length() - name.length() - 1 );
+	    TQString newVerName;
+	    TQString newCidStr;
+	    if ( version.tqfind( '.' ) == -1 ) {
+		int ver = version.toInt();
+		// see if a lesser version is installed, and make that the CurVer
+		while ( ver-- ) {
+		    newVerName = name + "." + TQString::number( ver );
+		    newCidStr = settings.readEntry( "/" + newVerName + "/CLSID/Default" );
+		    if ( !!newCidStr )
+			break;
+		}
+	    } else {
+		// oh well...
+	    }
+	    if ( !!newCidStr ) {
+		settings.writeEntry( "/" + name + "/CurVer/Default", newVerName );
+		settings.writeEntry( "/" + name + "/CLSID/Default", newCidStr );
+	    } else {
+		settings.removeEntry( "/" + name + "/CurVer/Default" );
+		settings.removeEntry( "/" + name + "/CLSID/Default" );
+		settings.removeEntry( "/" + name + "/Default" );
+	    }
+	}
+
+	settings.removeEntry( "/" + vName + "/CLSID/Default" );
+	settings.removeEntry( "/" + vName + "/Default" );
+    }
+
+    settings.removeEntry( "/CLSID/" + cidStr + "/VersionIndependentProgID/Default" );
+    settings.removeEntry( "/CLSID/" + cidStr + "/ProgID/Default" );
+    settings.removeEntry( "/CLSID/" + cidStr + "/InprocServer32/Default" );
+    ok = settings.removeEntry( "/CLSID/" + cidStr + "/Default" );
+
+    return ok;
+}
+
+#endif // TQT_NO_COMPONENT
diff --git a/tqtinterface/qt4/src/tools/tqcomponentfactory_p.h b/tqtinterface/qt4/src/tools/tqcomponentfactory_p.h
new file mode 100644
index 0000000..acec9d4
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqcomponentfactory_p.h
@@ -0,0 +1,76 @@
+/****************************************************************************
+**
+** Definition of the TQComponentFactory class
+**
+** Created : 990101
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQCOMPONENTFACTORY_P_H
+#define TQCOMPONENTFACTORY_P_H
+
+#ifndef TQT_H
+#include "tqcom_p.h"
+#endif // TQT_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the TQt API.  It exists for the convenience
+// of a number of TQt sources files.  This header file may change from
+// version to version without notice, or even be removed.
+//
+// We mean it.
+//
+//
+
+#ifndef TQT_NO_COMPONENT
+
+class TQ_EXPORT TQComponentFactory
+{
+public:
+    static TQRESULT createInstance( const TQString &cid, const TQUuid &iid, TQUnknownInterface** instance, TQUnknownInterface *outer = 0 );
+    static TQRESULT registerServer( const TQString &filename );
+    static TQRESULT unregisterServer( const TQString &filename );
+
+    static bool registerComponent( const TQUuid &cid, const TQString &filename, const TQString &name = TQString::null, 
+				   int version = 0, const TQString &description = TQString::null );
+    static bool unregisterComponent( const TQUuid &cid );
+};
+
+#endif // TQT_NO_COMPONENT
+
+#endif // TQCOMPONENTFACTORY_P_H
diff --git a/tqtinterface/qt4/src/tools/tqconfig-dist.h b/tqtinterface/qt4/src/tools/tqconfig-dist.h
new file mode 100644
index 0000000..1e4c589
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqconfig-dist.h
@@ -0,0 +1,11 @@
+#ifndef TQT_H
+#endif /* TQT_H */
+
+/*
+ Empty leaves all features enabled. See doc/html/features.html for choices.
+
+ Note that disabling some features will produce a libtqt that is not
+ compatible with other libtqt builds. Such modifications are only
+ supported on TQt/Embedded where reducing the library size is important
+ and where the application-suite is often a fixed set.
+*/
diff --git a/tqtinterface/qt4/src/tools/tqconfig-large.h b/tqtinterface/qt4/src/tools/tqconfig-large.h
new file mode 100644
index 0000000..2b44bf7
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqconfig-large.h
@@ -0,0 +1,42 @@
+#ifndef TQT_H
+#endif /* TQT_H */
+#ifndef TQT_NO_CODECS
+#define TQT_NO_CODECS
+#endif
+#define TQT_NO_UNICODETABLES
+#define TQT_NO_IMAGEIO_BMP
+#define TQT_NO_IMAGEIO_PPM
+#define TQT_NO_ASYNC_IO
+#define TQT_NO_ASYNC_IMAGE_IO
+/* #define TQT_NO_FREETYPE */
+#define TQT_NO_BDF
+//#define TQT_NO_FONTDATABASE
+#define TQT_NO_TRANSLATION
+#define TQT_NO_DRAGANDDROP
+#define TQT_NO_CLIPBOARD
+#define TQT_NO_SOUND
+#define TQT_NO_PROPERTIES
+#define TQT_NO_DNS
+#define TQT_NO_NETWORKPROTOCOL
+#define TQT_NO_URL
+#define TQT_NO_COLORNAMES
+#define TQT_NO_TRANSFORMATIONS
+#define TQT_NO_PRINTER
+#define TQT_NO_PICTURE
+#define TQT_NO_ICONVIEW
+#define TQT_NO_DIAL
+#define TQT_NO_WORKSPACE
+#define TQT_NO_TABLE
+#define TQT_NO_ACTION
+#define TQT_NO_STYLE_MOTIF
+#define TQT_NO_STYLE_PLATINUM
+/* #define TQT_NO_FILEDIALOG */
+#define TQT_NO_FONTDIALOG
+#define TQT_NO_PRINTDIALOG
+/* #define TQT_NO_COLORDIALOG */
+#define TQT_NO_INPUTDIALOG
+/* #define TQT_NO_MESSAGEBOX */
+#define TQT_NO_PROGRESSDIALOG
+/* #define TQT_NO_TABDIALOG */
+#define TQT_NO_WIZARD
+#define TQT_NO_EFFECTS
diff --git a/tqtinterface/qt4/src/tools/tqconfig-medium.h b/tqtinterface/qt4/src/tools/tqconfig-medium.h
new file mode 100644
index 0000000..36254aa
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqconfig-medium.h
@@ -0,0 +1,108 @@
+#ifndef TQT_H
+#endif /* TQT_H */
+#ifndef TQT_NO_TEXTCODEC /* tqmoc? */
+#define TQT_NO_TEXTCODEC
+#endif
+#define TQT_NO_UNICODETABLES
+#define TQT_NO_IMAGEIO_BMP
+#define TQT_NO_IMAGEIO_PPM
+/* #define TQT_NO_IMAGEIO_PNG */
+#define TQT_NO_ASYNC_IO
+#define TQT_NO_ASYNC_IMAGE_IO
+/* #define TQT_NO_FREETYPE */
+#define TQT_NO_BDF
+//#define TQT_NO_FONTDATABASE
+#define TQT_NO_TRANSLATION
+#define TQT_NO_DRAGANDDROP
+#define TQT_NO_CLIPBOARD
+#define TQT_NO_SOUND
+#define TQT_NO_PROPERTIES
+#define TQT_NO_DNS
+#define TQT_NO_NETWORKPROTOCOL
+#define TQT_NO_COLORNAMES
+#define TQT_NO_TRANSFORMATIONS
+#define TQT_NO_PRINTER
+#define TQT_NO_PICTURE
+#define TQT_NO_ICONVIEW
+#define TQT_NO_DIAL
+#define TQT_NO_WORKSPACE
+#define TQT_NO_TABLE
+#define TQT_NO_ACTION
+#define TQT_NO_STYLE_MOTIF
+#define TQT_NO_STYLE_PLATINUM
+/* #define TQT_NO_FILEDIALOG */
+#define TQT_NO_FONTDIALOG
+#define TQT_NO_PRINTDIALOG
+/* #define TQT_NO_COLORDIALOG */
+#define TQT_NO_INPUTDIALOG
+/* #define TQT_NO_MESSAGEBOX */
+#define TQT_NO_PROGRESSDIALOG
+/* #define TQT_NO_TABDIALOG */
+#define TQT_NO_WIZARD
+#define TQT_NO_EFFECTS
+
+
+#define TQT_NO_MIME
+/* #define TQT_NO_NETWORK //??? means single-process only */
+
+
+#define TQT_NO_IMAGE_TRUECOLOR
+/* #define TQT_NO_IMAGE_SMOOTHSCALE  //needed for iconset --> pushbutton */
+#define TQT_NO_IMAGE_TEXT
+#define TQT_NO_DIR
+
+/* #define TQT_NO_TEXTSTREAM */
+#define TQT_NO_DATASTREAM
+#define TQT_NO_TQWS_SAVEFONTS
+
+#define TQT_NO_SESSIONMANAGER
+
+
+/* #define TQT_NO_DIALOG */
+
+#define TQT_NO_SEMIMODAL
+
+#define TQT_NO_EFFECTS
+#define TQT_NO_COP
+
+#define TQT_NO_TQWS_PROPERTIES
+
+/* #define TQT_NO_RANGECONTROL */
+/* #define TQT_NO_SPLITTER */
+#define TQT_NO_STATUSBAR
+#define TQT_NO_TABBAR
+#define TQT_NO_TOOLBAR
+#define TQT_NO_TOOLTIP
+/* #define TQT_NO_VALIDATOR */
+#define TQT_NO_WHATSTHIS
+#define TQT_NO_WIDGETSTACK
+#define TQT_NO_ACCEL
+#define TQT_NO_SIZEGRIP
+#define TQT_NO_HEADER
+#define TQT_NO_WORKSPACE
+#define TQT_NO_LCDNUMBER
+#define TQT_NO_STYLE_MOTIF
+#define TQT_NO_STYLE_PLATINUM
+#define TQT_NO_PROGRESSBAR
+
+#define TQT_NO_ICONVIEW
+#define TQT_NO_DIAL
+
+#define TQT_NO_TABLE
+
+/* #define TQT_NO_FILEDIALOG */
+#define TQT_NO_FONTDIALOG
+#define TQT_NO_PRINTDIALOG
+#define TQT_NO_COLORDIALOG
+#define TQT_NO_INPUTDIALOG
+/* #define TQT_NO_MESSAGEBOX */
+#define TQT_NO_PROGRESSDIALOG
+/* #define TQT_NO_TABDIALOG */
+#define TQT_NO_WIZARD
+#define TQT_NO_EFFECTS
+
+/* #define TQT_NO_TQWS_HYDRO_WM_STYLE */
+#define TQT_NO_TQWS_BEOS_WM_STYLE
+#define TQT_NO_TQWS_KDE2_WM_STYLE
+#define TQT_NO_TQWS_KDE_WM_STYLE
+/* #define TQT_NO_TQWS_WINDOWS_WM_STYLE */
diff --git a/tqtinterface/qt4/src/tools/tqconfig-minimal.h b/tqtinterface/qt4/src/tools/tqconfig-minimal.h
new file mode 100644
index 0000000..8c406bd
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqconfig-minimal.h
@@ -0,0 +1,97 @@
+#ifndef TQT_H
+#endif /* TQT_H */
+
+#ifndef TQT_NO_CHECK
+# define TQT_NO_CHECK
+#endif
+#define TQT_NO_PROCESS
+#define TQT_NO_PALETTE
+#define TQT_NO_ACTION
+#ifndef TQT_NO_TEXTCODEC /* tqmoc? */
+#define TQT_NO_TEXTCODEC
+#endif
+#define TQT_NO_UNICODETABLES
+#define TQT_NO_IMAGEIO_BMP
+#define TQT_NO_IMAGEIO_PPM
+#define TQT_NO_IMAGEIO_XBM
+#define TQT_NO_IMAGEIO_XPM
+/* #define TQT_NO_IMAGEIO_PNG //done by configure -no-png */
+#define TQT_NO_ASYNC_IO
+#define TQT_NO_ASYNC_IMAGE_IO
+/* //#define TQT_NO_FREETYPE //done by configure -no-freetype */
+#define TQT_NO_BDF
+//#define TQT_NO_FONTDATABASE
+#define TQT_NO_TRANSLATION
+#define TQT_NO_MIME
+#define TQT_NO_SOUND
+/* #define TQT_NO_PROPERTIES */
+#define TQT_NO_TQWS_CURSOR
+#define TQT_NO_CURSOR
+#define TQT_NO_TQWS_GFX_SPEED
+#define TQT_NO_NETWORK
+#define TQT_NO_COLORNAMES
+#define TQT_NO_TRANSFORMATIONS
+#define TQT_NO_PRINTER
+#define TQT_NO_PICTURE
+#define TQT_NO_LAYOUT
+#define TQT_NO_DRAWUTIL
+#define TQT_NO_IMAGE_TRUECOLOR
+#define TQT_NO_IMAGE_SMOOTHSCALE
+#define TQT_NO_IMAGE_TEXT
+#define TQT_NO_DIR
+#define TQT_NO_TQWS_MANAGER
+#define TQT_NO_TEXTSTREAM
+#define TQT_NO_DATASTREAM
+#define TQT_NO_TQWS_SAVEFONTS
+//#define TQT_NO_STRINGLIST
+#define TQT_NO_TEMPLATE_VARIANT
+#define TQT_NO_SESSIONMANAGER
+#define TQT_NO_TQWS_KEYBOARD
+#define TQT_NO_SYNTAXHIGHLIGHTER
+
+#define TQT_NO_ACCEL
+#define TQT_NO_BUTTON
+#define TQT_NO_DIALOG
+#define TQT_NO_FRAME
+#define TQT_NO_SEMIMODAL
+
+#define TQT_NO_STYLE
+#define TQT_NO_EFFECTS
+#define TQT_NO_COP
+
+#define TQT_NO_SQL
+
+#define TQT_NO_REGEXP_CAPTURE
+#define TQT_NO_REGEXP_WILDCARD
+
+#define TQT_NO_VALIDATOR
+#define TQT_NO_SPRINTF
+
+#define TQT_NO_REGEXP
+
+#define TQT_NO_IMAGEIO
+
+/* #define TQT_NO_VARIANT //needed for Q_SIGNALS/Q_SLOTS */
+
+#define TQT_NO_RANGECONTROL
+#define TQT_NO_TQUUID_STRING
+#define TQT_NO_SIGNALMAPPER
+
+#define TQT_NO_WHEELEVENT
+#define TQT_NO_BEZIER
+
+#define TQT_NO_TQWS_MOUSE_AUTO
+/* #define TQT_NO_TQWS_MOUSE_MANUAL */
+
+#define TQT_NO_IMAGE_DITHER_TO_1
+#define TQT_NO_IMAGE_HEURISTIC_MASK
+#define TQT_NO_IMAGE_MIRROR
+
+#ifndef TQT_NO_STL
+# define TQT_NO_STL
+#endif
+
+#define TQT_NO_DATESTRING
+#define TQT_NO_WMATRIX
+
+#define TQT_NO_DIRECTPAINTER
diff --git a/tqtinterface/qt4/src/tools/tqconfig-small.h b/tqtinterface/qt4/src/tools/tqconfig-small.h
new file mode 100644
index 0000000..f4b772a
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqconfig-small.h
@@ -0,0 +1,94 @@
+#define NO_CHECK
+#ifndef TQT_H
+#endif /* TQT_H */
+
+#define TQT_NO_ACTION
+#ifndef TQT_NO_TEXTCODEC /* tqmoc? */
+#define TQT_NO_TEXTCODEC
+#endif
+#define TQT_NO_UNICODETABLES
+#define TQT_NO_IMAGEIO_BMP
+#define TQT_NO_IMAGEIO_PPM
+#define TQT_NO_IMAGEIO_XBM
+#define TQT_NO_IMAGEIO_XPM
+/* #define TQT_NO_IMAGEIO_PNG //done by configure -no-png */
+#define TQT_NO_ASYNC_IO
+#define TQT_NO_ASYNC_IMAGE_IO
+/* #define TQT_NO_FREETYPE //done by configure -no-freetype */
+#define TQT_NO_BDF
+//#define TQT_NO_FONTDATABASE
+#define TQT_NO_TRANSLATION
+#define TQT_NO_MIME
+#define TQT_NO_SOUND
+#define TQT_NO_PROPERTIES
+#define TQT_NO_SYNTAXHIGHLIGHTER
+
+#define TQT_NO_TQWS_GFX_SPEED
+#define TQT_NO_NETWORK /* ?????????????? */
+#define TQT_NO_COLORNAMES
+#define TQT_NO_TRANSFORMATIONS
+#define TQT_NO_PRINTER
+#define TQT_NO_PICTURE
+
+#define TQT_NO_IMAGE_TRUECOLOR
+/* #define TQT_NO_IMAGE_SMOOTHSCALE  //needed for iconset --> pushbutton */
+#define TQT_NO_IMAGE_TEXT
+#define TQT_NO_DIR
+
+#define TQT_NO_TEXTSTREAM
+#define TQT_NO_DATASTREAM
+#define TQT_NO_TQWS_SAVEFONTS
+//#define TQT_NO_STRINGLIST
+#define TQT_NO_SESSIONMANAGER
+
+
+#define TQT_NO_DIALOG
+
+#define TQT_NO_SEMIMODAL
+
+/* #define TQT_NO_STYLE //will require substantial work... */
+
+#define TQT_NO_EFFECTS
+#define TQT_NO_COP
+
+#define TQT_NO_TQWS_PROPERTIES
+
+#define TQT_NO_RANGECONTROL
+#define TQT_NO_SPLITTER
+#define TQT_NO_STATUSBAR
+#define TQT_NO_TABBAR
+#define TQT_NO_TOOLBAR
+#define TQT_NO_TOOLTIP
+#define TQT_NO_VALIDATOR
+#define TQT_NO_WHATSTHIS
+#define TQT_NO_WIDGETSTACK
+#define TQT_NO_ACCEL
+#define TQT_NO_SIZEGRIP
+#define TQT_NO_HEADER
+#define TQT_NO_WORKSPACE
+#define TQT_NO_LCDNUMBER
+#define TQT_NO_STYLE_MOTIF
+#define TQT_NO_STYLE_PLATINUM
+#define TQT_NO_PROGRESSBAR
+
+
+#define TQT_NO_TQWS_HYDRO_WM_STYLE
+#define TQT_NO_TQWS_BEOS_WM_STYLE
+#define TQT_NO_TQWS_KDE2_WM_STYLE
+#define TQT_NO_TQWS_KDE_WM_STYLE
+#define TQT_NO_TQWS_WINDOWS_WM_STYLE
+
+
+/* other widgets that could be removed: */
+/*
+#define TQT_NO_MENUDATA
+*/
+
+
+/* possible options: */
+/*
+#define TQT_NO_CURSOR
+#define TQT_NO_LAYOUT
+#define TQT_NO_TQWS_MANAGER
+#define TQT_NO_TQWS_KEYBOARD
+*/
diff --git a/tqtinterface/qt4/src/tools/tqcriticalsection_p.cpp b/tqtinterface/qt4/src/tools/tqcriticalsection_p.cpp
new file mode 100644
index 0000000..ed6ead8
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqcriticalsection_p.cpp
@@ -0,0 +1,76 @@
+/****************************************************************************
+**
+** Implementation of TQCriticalSection class
+**
+** Copyright (C) 2005-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#if defined(TQT_THREAD_SUPPORT)
+
+#include "tqt_windows.h"
+
+#include <private/tqcriticalsection_p.h>
+
+class TQCriticalSectionPrivate 
+{
+public:
+    TQCriticalSectionPrivate() {}
+
+    CRITICAL_SECTION section;
+};
+
+
+TQCriticalSection::TQCriticalSection()
+{
+    d = new TQCriticalSectionPrivate;
+    InitializeCriticalSection( &d->section );
+}
+
+TQCriticalSection::~TQCriticalSection()
+{
+    DeleteCriticalSection( &d->section );
+    delete d;
+}
+
+void TQCriticalSection::enter()
+{
+    EnterCriticalSection( &d->section );
+}
+
+void TQCriticalSection::leave()
+{
+    LeaveCriticalSection( &d->section );
+}
+
+#endif
diff --git a/tqtinterface/qt4/src/tools/tqcriticalsection_p.h b/tqtinterface/qt4/src/tools/tqcriticalsection_p.h
new file mode 100644
index 0000000..21d1f6d
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqcriticalsection_p.h
@@ -0,0 +1,83 @@
+/****************************************************************************
+**
+** Definition of TQCriticalSection class
+**
+** Copyright (C) 2001-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQCRITICALSECTION_P_H
+#define TQCRITICALSECTION_P_H
+
+#ifndef TQT_H
+#endif // TQT_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the TQt API.  It exists for the convenience
+// of TQt Remote Control. This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+//
+
+#if defined(TQT_THREAD_SUPPORT)
+
+#if defined(TQ_WS_WIN)
+
+/*
+  TQCriticalSection
+*/
+
+class TQCriticalSectionPrivate;
+
+class TQCriticalSection
+{
+public:
+    TQCriticalSection();
+    ~TQCriticalSection();
+    void enter();
+    void leave();
+
+private:
+    TQCriticalSectionPrivate *d;
+};
+
+#endif
+
+#endif
+
+#endif
diff --git a/tqtinterface/qt4/src/tools/tqcstring.cpp b/tqtinterface/qt4/src/tools/tqcstring.cpp
new file mode 100644
index 0000000..f81348f
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqcstring.cpp
@@ -0,0 +1,4149 @@
+/****************************************************************************
+**
+** Implementation of extended char array operations, and TQByteArray and
+** TQCString classes
+**
+** Created : 920722
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "tqstring.h"
+#include "tqregexp.h"
+#include "tqdatastream.h"
+
+#ifdef TQT_THREAD_SUPPORT
+#  include <private/tqmutexpool_p.h>
+#endif // TQT_THREAD_SUPPORT
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <limits.h>
+#ifndef TQT_NO_COMPRESS
+#include "../3rdparty/zlib/zlib.h"
+#endif
+
+/*****************************************************************************
+  Safe and portable C string functions; extensions to standard string.h
+ *****************************************************************************/
+
+/*!
+    \relates TQCString
+
+    This function is normally part of the C library. TQt implements
+    memmove() for platforms that do not provide it.
+
+    memmove() copies \a len bytes from \a src into \a dst. The data
+    is copied correctly even if \a src and \a dst overlap.
+*/
+
+void *tqmemmove( void *dst, const void *src, uint len )
+{
+    register char *d;
+    register char *s;
+    if ( dst > src ) {
+	d = (char *)dst + len - 1;
+	s = (char *)src + len - 1;
+	while ( len-- )
+	    *d-- = *s--;
+    } else if ( dst < src ) {
+	d = (char *)dst;
+	s = (char *)src;
+	while ( len-- )
+	    *d++ = *s++;
+    }
+    return dst;
+}
+
+
+/*!
+    \relates TQCString
+
+    Returns a duplicate string.
+
+    Allocates space for a copy of \a src, copies it, and returns a
+    pointer to the copy. If \a src is 0, it immediately returns 0.
+
+    The returned string must be deleted using \c delete[].
+*/
+
+char *tqstrdup( const char *src )
+{
+    if ( !src )
+	return 0;
+    char *dst = new char[strlen(src)+1];
+    TQ_CHECK_PTR( dst );
+    return strcpy( dst, src );
+}
+
+/*!
+    \fn char *qstrcpy( char *dst, const char *src )
+
+    \relates TQCString
+
+    A safe strcpy() function.
+
+    Copies all characters up to and including the '\0' from \a src
+    into \a dst and returns a pointer to \a dst.
+*/
+
+/*!
+    \relates TQCString
+
+    A safe strncpy() function.
+
+    Copies at most \a len bytes from \a src (stopping at \a len or the
+    terminating '\0' whichever comes first) into \a dst and returns a
+    pointer to \a dst. Guarantees that \a dst is '\0'-terminated. If
+    \a src or \a dst is 0, returns 0 immediately.
+
+    \sa qstrcpy()
+*/
+
+char *tqstrncpy( char *dst, const char *src, uint len )
+{
+    if ( !src || !dst )
+	return 0;
+    strncpy( dst, src, len );
+    if ( len > 0 )
+	dst[len-1] = '\0';
+    return dst;
+}
+
+/*!
+    \fn uint tqstrlen( const char *str );
+
+    \relates TQCString
+
+    A safe strlen function.
+
+    Returns the number of characters that precede the terminating '\0'.
+    or 0 if \a str is 0.
+*/
+
+/*!
+    \fn int qstrcmp( const char *str1, const char *str2 );
+
+    \relates TQCString
+
+    A safe strcmp() function.
+
+    Compares \a str1 and \a str2. Returns a negative value if \a str1
+    is less than \a str2, 0 if \a str1 is equal to \a str2 or a
+    positive value if \a str1 is greater than \a str2.
+
+    Special case I: Returns 0 if \a str1 and \a str2 are both 0.
+
+    Special case II: Returns a random nonzero value if \a str1 is 0
+    or \a str2 is 0 (but not both).
+
+    \sa tqstrncmp() qstricmp() qstrnicmp()
+	\link #asciinotion Note on character comparisons \endlink
+*/
+
+/*!
+    \fn int tqstrncmp( const char *str1, const char *str2, uint len );
+
+    \relates TQCString
+
+    A safe strncmp() function.
+
+    Compares at most \a len bytes of \a str1 and \a str2.
+
+    Returns a negative value if \a str1 is less than \a str2, 0 if \a
+    str1 is equal to \a str2 or a positive value if \a str1 is greater
+    than \a str2.
+
+    Special case I: Returns 0 if \a str1 and \a str2 are both 0.
+
+    Special case II: Returns a random nonzero value if \a str1 is 0
+    or \a str2 is 0 (but not both).
+
+    \sa qstrcmp(), qstricmp(), qstrnicmp()
+	\link #asciinotion Note on character comparisons \endlink
+*/
+
+/*!
+    \relates TQCString
+
+    A safe stricmp() function.
+
+    Compares \a str1 and \a str2 ignoring the case.
+
+    Returns a negative value if \a str1 is less than \a str2, 0 if \a
+    str1 is equal to \a str2 or a positive value if \a str1 is greater
+    than \a str2.
+
+    Special case I: Returns 0 if \a str1 and \a str2 are both 0.
+
+    Special case II: Returns a random nonzero value if \a str1 is 0
+    or \a str2 is 0 (but not both).
+
+    \sa qstrcmp(), tqstrncmp(), qstrnicmp()
+	\link #asciinotion Note on character comparisons \endlink
+*/
+
+int tqstricmp( const char *str1, const char *str2 )
+{
+    register const uchar *s1 = (const uchar *)str1;
+    register const uchar *s2 = (const uchar *)str2;
+    int res;
+    uchar c;
+    if ( !s1 || !s2 )
+	return s1 ? 1 : ( s2 ? -1 : 0 );
+    for ( ; !(res = (c=tolower(*s1)) - tolower(*s2)); s1++, s2++ )
+	if ( !c )				// strings are equal
+	    break;
+    return res;
+}
+
+/*!
+    \relates TQCString
+
+    A safe strnicmp() function.
+
+    Compares at most \a len bytes of \a str1 and \a str2 ignoring the case.
+
+    Returns a negative value if \a str1 is less than \a str2, 0 if \a str1
+    is equal to \a str2 or a positive value if \a str1 is greater than \a
+    str2.
+
+    Special case I: Returns 0 if \a str1 and \a str2 are both 0.
+
+    Special case II: Returns a random nonzero value if \a str1 is 0
+    or \a str2 is 0 (but not both).
+
+    \sa qstrcmp(), tqstrncmp() qstricmp()
+	\link #asciinotion Note on character comparisons \endlink
+*/
+
+int tqstrnicmp( const char *str1, const char *str2, uint len )
+{
+    register const uchar *s1 = (const uchar *)str1;
+    register const uchar *s2 = (const uchar *)str2;
+    int res;
+    uchar c;
+    if ( !s1 || !s2 )
+	return s1 ? 1 : ( s2 ? -1 : 0 );
+    for ( ; len--; s1++, s2++ ) {
+	if ( (res = (c=tolower(*s1)) - tolower(*s2)) )
+	    return res;
+	if ( !c )				// strings are equal
+	    break;
+    }
+    return 0;
+}
+
+
+static TQ_UINT16 crc_tbl[16];
+static bool   crc_tbl_init = FALSE;
+
+static void createCRC16Table()			// build CRC16 lookup table
+{
+    register uint i;
+    register uint j;
+    uint v0, v1, v2, v3;
+    for ( i = 0; i < 16; i++ ) {
+	v0 = i & 1;
+	v1 = ( i >> 1 ) & 1;
+	v2 = ( i >> 2 ) & 1;
+	v3 = ( i >> 3 ) & 1;
+	j = 0;
+#undef SET_BIT
+#define SET_BIT(x, b, v) (x) |= (v) << (b)
+	SET_BIT( j,  0, v0 );
+	SET_BIT( j,  7, v0 );
+	SET_BIT( j, 12, v0 );
+	SET_BIT( j,  1, v1 );
+	SET_BIT( j,  8, v1 );
+	SET_BIT( j, 13, v1 );
+	SET_BIT( j,  2, v2 );
+	SET_BIT( j,  9, v2 );
+	SET_BIT( j, 14, v2 );
+	SET_BIT( j,  3, v3 );
+	SET_BIT( j, 10, v3 );
+	SET_BIT( j, 15, v3 );
+	crc_tbl[i] = j;
+    }
+}
+
+/*!
+    \relates TQMemArray
+
+    Returns the CRC-16 checksum of \a len bytes starting at \a data.
+
+    The checksum is independent of the byte order (endianness).
+*/
+
+TQ_UINT16 qChecksum( const char *data, uint len )
+{
+    if ( !crc_tbl_init ) {			// create lookup table
+
+#ifdef TQT_THREAD_SUPPORT
+	TQMutexLocker locker( tqt_global_mutexpool ?
+			     tqt_global_mutexpool->get( &crc_tbl_init ) : 0 );
+#endif // TQT_THREAD_SUPPORT
+
+	if ( !crc_tbl_init ) {
+	    createCRC16Table();
+	    crc_tbl_init = TRUE;
+	}
+    }
+    register TQ_UINT16 crc = 0xffff;
+    uchar c;
+    uchar *p = (uchar *)data;
+    while ( len-- ) {
+	c = *p++;
+	crc = ( (crc >> 4) & 0x0fff ) ^ crc_tbl[((crc ^ c) & 15)];
+	c >>= 4;
+	crc = ( (crc >> 4) & 0x0fff ) ^ crc_tbl[((crc ^ c) & 15)];
+    }
+    return ~crc & 0xffff;
+}
+
+/*!
+    \fn TQByteArray tqCompress( const TQByteArray& data )
+
+    \relates TQByteArray
+
+    Compresses the array \a data and returns the compressed byte
+    array using zlib.
+
+    \sa tqUncompress()
+*/
+
+/*!
+    \relates TQByteArray
+
+    \overload
+
+    Compresses the array \a data which is \a nbytes long and returns the
+    compressed byte array.
+*/
+
+#ifndef TQT_NO_COMPRESS
+TQByteArray tqCompress( const uchar* data, int nbytes )
+{
+    if ( nbytes == 0 ) {
+	TQByteArray tmp( 4 );
+	tmp.fill( 0 );
+	return tmp;
+    }
+    if ( !data ) {
+#if defined(TQT_CHECK_RANGE)
+	qWarning( "tqCompress: data is NULL." );
+#endif
+	return TQByteArray();
+    }
+
+    ulong len = nbytes + nbytes / 100 + 13;
+    TQByteArray bazip;
+    int res;
+    do {
+	bazip.resize( len + 4 );
+	res = ::compress(  (uchar*)bazip.data()+4, &len, (uchar*)data, nbytes );
+
+	switch ( res ) {
+	case Z_OK:
+	    bazip.resize( len + 4 );
+	    bazip[0] = ( nbytes & 0xff000000 ) >> 24;
+	    bazip[1] = ( nbytes & 0x00ff0000 ) >> 16;
+	    bazip[2] = ( nbytes & 0x0000ff00 ) >> 8;
+	    bazip[3] = ( nbytes & 0x000000ff );
+	    break;
+	case Z_MEM_ERROR:
+#if defined(TQT_CHECK_RANGE)
+	    qWarning( "tqCompress: Z_MEM_ERROR: Not enough memory." );
+#endif
+	    bazip.resize( 0 );
+	    break;
+	case Z_BUF_ERROR:
+	    len *= 2;
+	    break;
+	}
+    } while ( res == Z_BUF_ERROR );
+
+    return bazip;
+}
+#endif
+
+/*!
+    \fn TQByteArray tqUncompress( const TQByteArray& data )
+
+    \relates TQByteArray
+
+    Uncompresses the array \a data and returns the uncompressed byte
+    array.
+
+    Returns an empty TQByteArray if the input data was corrupt.
+    \omit
+    ADD THE FOLLOWING FOR TQt 4.0
+    This function will uncompress data compressed with tqCompress()
+    from this and any earlier TQt version, back to TQt 3.1 when this
+    feature was added.
+    \endomit
+
+    \sa tqCompress()
+*/
+
+/*!
+    \relates TQByteArray
+
+    \overload
+
+    Uncompresses the array \a data which is \a nbytes long and returns
+    the uncompressed byte array.
+*/
+
+#ifndef TQT_NO_COMPRESS
+TQByteArray tqUncompress( const uchar* data, int nbytes )
+{
+    if ( !data ) {
+#if defined(TQT_CHECK_RANGE)
+	qWarning( "tqUncompress: data is NULL." );
+#endif
+	return TQByteArray();
+    }
+    if ( nbytes <= 4 ) {
+#if defined(TQT_CHECK_RANGE)
+	if ( nbytes < 4 || ( data[0]!=0 || data[1]!=0 || data[2]!=0 || data[3]!=0 ) )
+	    qWarning( "tqUncompress: Input data is corrupted." );
+#endif
+	return TQByteArray();
+    }
+    ulong expectedSize = ( data[0] << 24 ) | ( data[1] << 16 ) | ( data[2] << 8 ) | data[3];
+    ulong len = TQMAX( expectedSize,  1 );
+    TQByteArray baunzip;
+    int res;
+    do {
+        if ( baunzip.tqresize( len ) ) {
+	    res = ::uncompress( (uchar*)baunzip.data(), &len,
+				    (uchar*)data+4, nbytes-4 );
+        } else {
+            res = Z_MEM_ERROR;
+        }
+
+	switch ( res ) {
+	case Z_OK:
+	    if ( len != baunzip.size() )
+		baunzip.resize( len );
+	    break;
+	case Z_MEM_ERROR:
+#if defined(TQT_CHECK_RANGE)
+	    qWarning( "tqUncompress: Z_MEM_ERROR: Not enough memory." );
+#endif
+	    break;
+	case Z_BUF_ERROR:
+	    len *= 2;
+	    break;
+	case Z_DATA_ERROR:
+#if defined(TQT_CHECK_RANGE)
+	    qWarning( "tqUncompress: Z_DATA_ERROR: Input data is corrupted." );
+#endif
+	    break;
+	}
+    } while ( res == Z_BUF_ERROR );
+
+    if ( res != Z_OK )
+	baunzip = TQByteArray();
+
+    return baunzip;
+}
+#endif
+
+/*****************************************************************************
+  TQByteArray documentation
+ *****************************************************************************/
+
+/*!
+    \class TQByteArray
+    \reentrant
+    \brief The TQByteArray class provides an array of bytes.
+
+    \ingroup collection
+    \ingroup tools
+
+    The TQByteArray class provides an explicitly shared array of bytes.
+    It is useful for manipulating memory areas with custom data.
+    TQByteArray is implemented as a TQMemArray\<char\>. See the \l
+    TQMemArray documentation for further information.
+*/
+
+/*!
+    \fn TQByteArray::TQByteArray()
+
+    Constructs an empty TQByteArray.
+*/
+
+/*!
+    \fn TQByteArray::TQByteArray( int size )
+
+    Constructs a TQByteArray of size \a size.
+*/
+
+// /*****************************************************************************
+//   TQByteArray stream functions
+//  *****************************************************************************/
+//
+// /*!
+//     \relates TQMemArray
+//
+//     Writes byte array \a a to the stream \a s and returns a reference
+//     to the stream.
+//
+//     \sa \link datastreamformat.html Format of the TQDataStream operators \endlink
+// */
+// #ifndef TQT_NO_DATASTREAM
+//
+// TQDataStream &operator<<( TQDataStream &s, const TQByteArray &a )
+// {
+//     return s.writeBytes( a.data(), a.size() );
+// }
+//
+// /*!
+//     \relates TQMemArray
+//
+//     Reads a byte array into \a a from the stream \a s and returns a
+//     reference to the stream.
+//
+//     \sa \link datastreamformat.html Format of the TQDataStream operators \endlink
+// */
+//
+// TQDataStream &operator>>( TQDataStream &s, TQByteArray &a )
+// {
+//     TQ_UINT32 len;
+//     s >> len;					// read size of array
+//     if ( len == 0 || s.eof() ) {		// end of file reached
+// 	a.resize( 0 );
+// 	return s;
+//     }
+//     if ( !a.resize( (uint)len ) ) {		// resize array
+// #if defined(TQT_CHECK_NULL)
+// 	qWarning( "TQDataStream: Not enough memory to read TQByteArray" );
+// #endif
+// 	len = 0;
+//     }
+//     if ( len > 0 )				// not null array
+// 	s.readRawBytes( a.data(), (uint)len );
+//     return s;
+// }
+//
+// #endif //TQT_NO_DATASTREAM
+
+#ifdef USE_QT4
+
+/*****************************************************************************
+  TQByteArray stream functions
+ *****************************************************************************/
+#ifndef TQT_NO_DATASTREAM
+TQDataStream &operator<<( TQDataStream &d, const TQByteArray &s ) {
+	if (d.version() >= QDataStream::Qt_4_0) {
+		QDataStream &qds = operator<<(static_cast<QDataStream &>(d), static_cast<const QByteArray &>(s));
+		TQDataStream &tqds = *static_cast<TQDataStream*>(&qds);
+		return tqds;
+	}
+
+	// we need to add a NUL to keep compatibility with Qt 3's QByteArray
+	QByteArray copy = s;
+	copy.append('\0');
+
+	QDataStream &qds = operator<<(static_cast<QDataStream &>(d), static_cast<const QByteArray &>(s));
+	TQDataStream &tqds = *static_cast<TQDataStream*>(&qds);
+	return tqds;
+}
+
+TQDataStream &operator>>( TQDataStream &d, TQByteArray &s ) {
+	operator>>(d, static_cast<QByteArray &>(s));
+	if (d.version() < QDataStream::Qt_4_0 && s.endsWith('\0'))
+		s.chop(1);                  // ending NUL
+	return d;
+}
+#endif // TQT_NO_DATASTREAM
+
+#endif // USE_QT4
+
+#ifdef USE_QT4
+
+/*!
+  \reimp
+*/
+
+TQByteArray::~TQByteArray()
+{
+}
+
+#endif // USE_QT4
+
+/*****************************************************************************
+  TQCString member functions
+ *****************************************************************************/
+
+// #ifdef USE_QT4
+#if 0
+
+QT_BEGIN_NAMESPACE
+
+/*!
+    Constructs a string with room for \a size characters, including
+    the '\0'-terminator. Makes a null string if \a size == 0.
+
+    If \a size \> 0, then the first and last characters in the string
+    are initialized to '\0'. All other characters are uninitialized.
+
+    \sa resize(), isNull()
+*/
+
+// TQCString::TQCString( int size )
+//     : TQByteArray( size )
+// {
+//     if ( size > 0 ) {
+// 	*data() = '\0';				// set terminator
+// 	*(data()+(size-1)) = '\0';
+//     }
+// }
+
+TQCString::TQCString( int size )
+    : TQByteArray(size, '\0')
+{
+}
+
+/*!
+    Constructs a string that is a deep copy of \a str.
+
+    If \a str is 0 a null string is created.
+
+    \sa isNull()
+*/
+
+TQCString::TQCString( const char *str )
+{
+    duplicate( str, tqstrlen(str) + 1 );
+}
+
+
+/*!
+    Constructs a string that is a deep copy of \a str. The copy will
+    be at most \a maxsize bytes long including the '\0'-terminator.
+
+    Example:
+    \code
+    TQCString str( "helloworld", 6 ); // assigns "hello" to str
+    \endcode
+
+    If \a str tqcontains a 0 byte within the first \a maxsize bytes, the
+    resulting TQCString will be terminated by this 0. If \a str is 0 a
+    null string is created.
+
+    \sa isNull()
+*/
+
+TQCString::TQCString( const char *str, uint maxsize )
+{
+    if ( str == 0 )
+	return;
+    uint len; // index of first '\0'
+    for ( len = 0; len < maxsize - 1; len++ ) {
+	if ( str[len] == '\0' )
+	    break;
+    }
+    TQByteArray::tqresize( len + 1 );
+    memcpy( data(), str, len );
+    data()[len] = 0;
+}
+
+//     TQCString(int size) : TQByteArray(size, '\0') {}
+//     TQCString(const char *str) : TQByteArray(str) {}
+//     TQCString(const char *str, uint maxlen) : TQByteArray(str, qMin(tqstrlen(str), maxlen - 1)) {}
+// //     TQCString(const char *str, uint maxlen) : TQByteArray(str, TQMIN(tqstrlen(str)+1, maxlen)) {}	// This would seem to be more correct at first glance, however it completely breaks kconfig_compiler.  As to why, I don't know!!! [FIXME]
+
+TQCString &TQCString::operator=(const TQCString &s) {
+	TQByteArray::operator=(s);
+	return *this;
+}
+
+TQCString &TQCString::operator=(const char *str) {
+// 	TQByteArray::operator=(str); return *this;
+	TQByteArray::operator=(duplicate( str, tqstrlen(str)+1 ));
+	return *this;
+}
+
+TQCString &TQCString::operator=(const QByteArray &ba) {
+	TQByteArray::operator=(ba);
+	return *this;
+}
+
+/*****************************************************************************
+  TQCString member functions
+ *****************************************************************************/
+
+/*!
+    \class TQCString
+    \reentrant
+    \brief The TQCString class provides an abstraction of the classic C
+    zero-terminated char array (char *).
+
+    \compat
+
+    TQCString tries to behave like a more convenient \c{const char *}.
+    The price of doing this is that some algorithms will perform
+    badly. For example, append() is O(length()) since it scans for a
+    null terminator. Although you might use TQCString for text that is
+    never exposed to the user, for most purposes, and especially for
+    user-visible text, you should use QString. QString provides
+    implicit sharing, Unicode and other internationalization support,
+    and is well optimized.
+
+    Note that for the TQCString methods that take a \c{const char *}
+    parameter the \c{const char *} must either be 0 (null) or not-null
+    and '\0' (NUL byte) terminated; otherwise the results are
+    undefined.
+
+    A default constructed TQCString is \e null, i.e. both the length
+    and the data pointer are 0 and isNull() returns true.
+
+    \note However, if you ask for the data pointer of a null TQCString
+    by calling data(), then because the internal representation of the
+    null TQCString is shared, it will be detached and tqreplaced with a
+    non-shared, empty representation, a non-null data pointer will be
+    returned, and subsequent calls to isNull() will return false. But
+    if you ask for the data pointer of a null TQCString by calling
+    constData(), the shared internal representation is not detached, a
+    null data pointer is returned, and subsequent calls to isNull()
+    will continue to return true.
+
+    A TQCString that references the empty string ("", a single '\0'
+    char) is \e empty, i.e. isEmpty() returns true.  Both null and
+    empty TQCStrings are legal parameters to the methods.  Assigning
+    \c{const char *} 0 to TQCString produces a null TQCString.
+
+    The length() function returns the length of the string; resize()
+    resizes the string and truncate() truncates the string. A string
+    can be filled with a character using fill(). Strings can be left
+    or right padded with characters using leftJustify() and
+    rightJustify(). Characters, strings and regular expressions can be
+    searched for using find() and findRev(), and counted using
+    tqcontains().
+
+    Strings and characters can be inserted with insert() and appended
+    with append(). A string can be prepended with prepend().
+    Characters can be removed from the string with remove() and
+    tqreplaced with tqreplace().
+
+    Portions of a string can be extracted using left(), right() and
+    mid(). Whitespace can be removed using stripWhiteSpace() and
+    simplifyWhiteSpace(). Strings can be converted to uppercase or
+    lowercase with upper() and lower() respectively.
+
+    Strings that contain numbers can be converted to numbers with
+    toShort(), toInt(), toLong(), toULong(), toFloat() and toDouble().
+    Numbers can be converted to strings with setNum().
+
+    Many operators are overloaded to work with TQCStrings. TQCString
+    also supports some more obscure functions, e.g. sprintf(),
+    setStr() and setExpand().
+
+    \sidebar Note on Character Comparisons
+
+    In TQCString the notion of uppercase and lowercase and of which
+    character is greater than or less than another character is locale
+    dependent. This affects functions which support a case insensitive
+    option or which compare or lowercase or uppercase their arguments.
+    Case insensitive operations and comparisons will be accurate if
+    both strings contain only ASCII characters. (If \c $LC_CTYPE is
+    set, most Unix systems do "the right thing".) Functions that this
+    affects include tqcontains(), find(), findRev(), \l operator<(), \l
+    operator<=(), \l operator>(), \l operator>=(), lower() and
+    upper().
+
+    This issue does not apply to \l{QString}s since they represent
+    characters using Unicode.
+    \endsidebar
+
+    Performance note: The TQCString methods for QRegExp searching are
+    implemented by converting the TQCString to a QString and performing
+    the search on that. This implies a deep copy of the TQCString data.
+    If you are going to perform many QRegExp searches on a large
+    TQCString, you will get better performance by converting the
+    TQCString to a QString yourself, and then searching in the QString.
+*/
+
+/*!
+    \fn TQCString TQCString::left(uint len)  const
+
+    \internal
+*/
+
+/*!
+    \fn TQCString TQCString::right(uint len) const
+
+    \internal
+*/
+
+/*!
+    \fn TQCString TQCString::mid(uint index, uint len) const
+
+    \internal
+*/
+
+/*!
+    \fn TQCString  TQCString::lower() const
+
+    Use QByteArray::toLower() instead.
+*/
+
+/*!
+    \fn TQCString  TQCString::upper() const
+
+    Use QByteArray::toUpper() instead.
+*/
+
+/*!
+    \fn TQCString  TQCString::stripWhiteSpace() const
+
+    Use QByteArray::trimmed() instead.
+*/
+
+/*!
+    \fn TQCString  TQCString::simplifyWhiteSpace() const
+
+    Use QByteArray::simplified() instead.
+*/
+
+/*!
+    \fn TQCString& TQCString::insert(uint index, const char *c)
+
+    \internal
+*/
+
+/*!
+    \fn TQCString& TQCString::insert(uint index, char c)
+
+    \internal
+*/
+
+/*!
+    \fn TQCString& TQCString::prepend(const char *c)
+
+    \internal
+*/
+
+/*!
+    \fn TQCString& TQCString::remove(uint index, uint len)
+
+    \internal
+*/
+
+/*!
+    \fn TQCString& TQCString::tqreplace(uint index, uint len, const char *c)
+
+    \internal
+*/
+
+/*!
+    \fn TQCString& TQCString::tqreplace(char c, const TQCString &after)
+
+    \internal
+*/
+
+/*!
+    \fn TQCString& TQCString::tqreplace(char c, const char *after)
+
+    \internal
+*/
+
+/*!
+    \fn TQCString& TQCString::tqreplace(const TQCString &b, const TQCString &a)
+
+    \internal
+*/
+
+/*!
+    \fn TQCString& TQCString::tqreplace(const char *b, const char *a)
+
+    \internal
+*/
+
+/*!
+    \fn TQCString& TQCString::tqreplace(char b, char a)
+
+    \internal
+*/
+
+/*!
+    \fn TQCString::TQCString()
+
+    Constructs a null string.
+
+    \sa isNull()
+*/
+
+/*!
+    \fn TQCString::TQCString(const QByteArray &ba)
+
+    Constructs a copy of \a ba.
+*/
+
+/*!
+    \fn TQCString::TQCString(const TQCString &s)
+
+    Constructs a shallow copy \a s.
+*/
+
+/*! \fn TQCString::TQCString(int size)
+    Constructs a string with room for \a size characters, including
+    the '\0'-terminator. Makes a null string if \a size == 0.
+
+    If \a size \> 0, then the first and last characters in the string
+    are initialized to '\0'. All other characters are uninitialized.
+
+    \sa resize(), isNull()
+*/
+
+/*! \fn TQCString::TQCString(const char *str)
+    Constructs a string that is a deep copy of \a str.
+
+    If \a str is 0 a null string is created.
+
+    \sa isNull()
+*/
+
+
+/*! \fn TQCString::TQCString(const char *str, uint maxsize)
+
+    Constructs a string that is a deep copy of \a str. The copy will
+    be at most \a maxsize bytes long including the '\0'-terminator.
+
+    Example:
+    \snippet doc/src/snippets/code/src_qt3support_tools_q3cstring.cpp 0
+
+    If \a str tqcontains a 0 byte within the first \a maxsize bytes, the
+    resulting TQCString will be terminated by this 0. If \a str is 0 a
+    null string is created.
+
+    \sa isNull()
+*/
+
+/*!
+    \fn TQCString &TQCString::operator=(const QByteArray &ba)
+
+    Assigns byte array \a ba to this TQCString.
+*/
+
+/*!
+    \fn TQCString &TQCString::operator=(const TQCString &s)
+
+    Assigns a shallow copy of \a s to this string and returns a
+    reference to this string.
+*/
+
+/*!
+    \fn TQCString &TQCString::operator=(const char *str)
+    \overload
+
+    Assigns a deep copy of \a str to this string and returns a
+    reference to this string.
+
+    If \a str is 0 a null string is created.
+
+    \sa isNull()
+*/
+
+/*
+    \fn bool TQCString::isNull() const
+
+    Returns true if the string is null, i.e. if data() == 0; otherwise
+    returns false. A null string is also an empty string.
+
+    \note If you ask for the data pointer of a null TQCString by
+    calling data(), then because the internal representation of the
+    null TQCString is shared, it will be detached and tqreplaced with a
+    non-shared, empty representation, a non-null data pointer will be
+    returned, and subsequent calls to isNull() will return false. But
+    if you ask for the data pointer of a null TQCString by calling
+    constData(), the shared internal representation is not detached, a
+    null data pointer is returned, and subsequent calls to isNull()
+    will continue to return true.
+
+    Example:
+    \snippet doc/src/snippets/code/src.qt3support.tools.q3cstring.cpp 1
+
+    \sa isEmpty(), length(), size()
+*/
+
+/*
+    \fn bool TQCString::isEmpty() const
+
+    Returns true if the string is empty, i.e. if length() == 0;
+    otherwise returns false. An empty string is not always a null
+    string.
+
+    See example in isNull().
+
+    \sa isNull(), length(), size()
+*/
+
+/*
+    \fn uint TQCString::length() const
+
+    Returns the length of the string, excluding the '\0'-terminator.
+    Equivalent to calling \c strlen(data()).
+
+    Null strings and empty strings have zero length.
+
+    \sa size(), isNull(), isEmpty()
+*/
+
+/*
+    \fn bool TQCString::truncate(uint pos)
+
+    Truncates the string at position \a pos.
+
+    Equivalent to calling \c resize(pos+1).
+
+    Example:
+    \snippet doc/src/snippets/code/src.qt3support.tools.q3cstring.cpp 2
+
+    \sa resize()
+*/
+
+/*!
+  \reimp
+*/
+
+TQCString::~TQCString()
+{
+}
+
+/*!
+    Implemented as a call to the native vsprintf() (see the manual for
+    your C library).
+
+    If the string is shorter than 256 characters, this sprintf() calls
+    resize(256) to decrease the chance of memory corruption. The
+    string is resized back to its actual length before sprintf()
+    returns.
+
+    Example:
+    \snippet doc/src/snippets/code/src_qt3support_tools_q3cstring.cpp 3
+
+    \warning All vsprintf() implementations will write past the end of
+    the target string (*this) if the \a format specification and
+    arguments happen to be longer than the target string, and some
+    will also fail if the target string is longer than some arbitrary
+    implementation limit.
+
+    Giving user-supplied arguments to sprintf() is risky: Sooner or
+    later someone will paste a huge line into your application.
+*/
+
+TQCString &TQCString::sprintf(const char *format, ...)
+{
+    detach();
+    va_list ap;
+    va_start(ap, format);
+    if (size() < 256)
+        resize(256);                // make string big enough
+    qvsnprintf(data(), size(), format, ap);
+    resize(qstrlen(constData()));
+    va_end(ap);
+    return *this;
+}
+
+
+
+/*!
+    \fn TQCString TQCString::copy() const
+
+    Returns a deep copy of this string.
+*/
+
+
+/*!
+    Returns a string of length \a width (plus one for the terminating
+    '\0') that tqcontains this string padded with the \a fill character.
+
+    If the length of the string exceeds \a width and \a truncate is
+    false (the default), then the returned string is a copy of the
+    string. If the length of the string exceeds \a width and \a
+    truncate is true, then the returned string is a left(\a width).
+
+    Example:
+    \snippet doc/src/snippets/code/src_qt3support_tools_q3cstring.cpp 4
+
+    \sa rightJustify()
+*/
+
+TQCString TQCString::leftJustify(uint width, char fill, bool truncate) const
+{
+    TQCString result;
+    int len = qstrlen(constData());
+    int padlen = width - len;
+    if (padlen > 0) {
+        result.resize(len+padlen);
+        memcpy(result.data(), constData(), len);
+        memset(result.data()+len, fill, padlen);
+    } else {
+        if (truncate)
+            result = left(width);
+        else
+            result = *this;
+    }
+    return result;
+}
+
+/*!
+    Returns a string of length \a width (plus one for the terminating
+    '\0') that tqcontains zero or more of the \a fill character followed
+    by this string.
+
+    If the length of the string exceeds \a width and \a truncate is
+    false (the default), then the returned string is a copy of the
+    string. If the length of the string exceeds \a width and \a
+    truncate is true, then the returned string is a left(\a width).
+
+    Example:
+    \snippet doc/src/snippets/code/src_qt3support_tools_q3cstring.cpp 5
+
+    \sa leftJustify()
+*/
+
+TQCString TQCString::rightJustify(uint width, char fill, bool truncate) const
+{
+    TQCString result;
+    int len = qstrlen(constData());
+    int padlen = width - len;
+    if (padlen > 0) {
+        result.resize(len+padlen);
+        memset(result.data(), fill, padlen);
+        memcpy(result.data()+padlen, constData(), len);
+    } else {
+        if (truncate)
+            result = left(width);
+        else
+            result = *this;
+    }
+    return result;
+}
+
+/*!
+    Returns the string converted to a \c long value.
+
+    If \a ok is not 0: *\a ok is set to false if the string is not a
+    number, or if it has trailing garbage; otherwise *\a ok is set to
+    true.
+*/
+
+long TQCString::toLong(bool *ok) const
+{
+    const char *p = constData();
+    long val=0;
+    const long max_mult = 214748364;
+    bool is_ok = false;
+    int neg = 0;
+    if (!p)
+        goto bye;
+    while (isspace((uchar) *p))                // skip leading space
+        p++;
+    if (*p == '-') {
+        p++;
+        neg = 1;
+    } else if (*p == '+') {
+        p++;
+    }
+    if (!isdigit((uchar) *p))
+        goto bye;
+    while (isdigit((uchar) *p)) {
+        if (val > max_mult || (val == max_mult && (*p-'0') > 7+neg))
+            goto bye;
+        val = 10*val + (*p++ - '0');
+    }
+    if (neg)
+        val = -val;
+    while (isspace((uchar) *p))                // skip trailing space
+        p++;
+    if (*p == '\0')
+        is_ok = true;
+bye:
+    if (ok)
+        *ok = is_ok;
+    return is_ok ? val : 0;
+}
+
+/*!
+    Returns the string converted to an \c{unsigned long} value.
+
+    If \a ok is not 0: *\a ok is set to false if the string is not a
+    number, or if it has trailing garbage; otherwise *\a ok is set to
+    true.
+*/
+
+ulong TQCString::toULong(bool *ok) const
+{
+    const char *p = constData();
+    ulong val=0;
+    const ulong max_mult = 429496729;
+    bool is_ok = false;
+    if (!p)
+        goto bye;
+    while (isspace((uchar) *p))                // skip leading space
+        p++;
+    if (*p == '+')
+        p++;
+    if (!isdigit((uchar) *p))
+        goto bye;
+    while (isdigit((uchar) *p)) {
+        if (val > max_mult || (val == max_mult && (*p-'0') > 5))
+            goto bye;
+        val = 10*val + (*p++ - '0');
+    }
+    while (isspace((uchar) *p))                // skip trailing space
+        p++;
+    if (*p == '\0')
+        is_ok = true;
+bye:
+    if (ok)
+        *ok = is_ok;
+    return is_ok ? val : 0;
+}
+
+/*!
+    Returns the string converted to a \c{short} value.
+
+    If \a ok is not 0: *\a ok is set to false if the string is not a
+    number, is out of range, or if it has trailing garbage; otherwise
+    *\a ok is set to true.
+*/
+
+short TQCString::toShort(bool *ok) const
+{
+    long v = toLong(ok);
+    if (ok && *ok && (v < -32768 || v > 32767))
+        *ok = false;
+    return (short)v;
+}
+
+/*!
+    Returns the string converted to an \c{unsigned short} value.
+
+    If \a ok is not 0: *\a ok is set to false if the string is not a
+    number, is out of range, or if it has trailing garbage; otherwise
+    *\a ok is set to true.
+*/
+
+ushort TQCString::toUShort(bool *ok) const
+{
+    ulong v = toULong(ok);
+    if (ok && *ok && (v > 65535))
+        *ok = false;
+    return (ushort)v;
+}
+
+
+/*!
+    Returns the string converted to a \c{int} value.
+
+    If \a ok is not 0: *\a ok is set to false if the string is not a
+    number, or if it has trailing garbage; otherwise *\a ok is set to
+    true.
+*/
+
+int TQCString::toInt(bool *ok) const
+{
+    return (int)toLong(ok);
+}
+
+/*!
+    Returns the string converted to an \c{unsigned int} value.
+
+    If \a ok is not 0: *\a ok is set to false if the string is not a
+    number, or if it has trailing garbage; otherwise *\a ok is set to
+    true.
+*/
+
+uint TQCString::toUInt(bool *ok) const
+{
+    return (uint)toULong(ok);
+}
+
+/*!
+    Returns the string converted to a \c{double} value.
+
+    If \a ok is not 0: *\a ok is set to false if the string is not a
+    number, or if it has trailing garbage; otherwise *\a ok is set to
+    true.
+*/
+
+double TQCString::toDouble(bool *ok) const
+{
+    char *end;
+    double val = strtod(constData() ? constData() : "", &end);
+    if (ok)
+        *ok = (constData() && *constData() && (end == 0 || *end == '\0'));
+    return val;
+}
+
+/*!
+    Returns the string converted to a \c{float} value.
+
+    If \a ok is not 0: *\a ok is set to false if the string is not a
+    number, or if it has trailing garbage; otherwise *\a ok is set to
+    true.
+*/
+
+float TQCString::toFloat(bool *ok) const
+{
+    return (float)toDouble(ok);
+}
+
+
+/*! \fn TQCString &TQCString::setStr(const char *str)
+    Makes a deep copy of \a str. Returns a reference to the string.
+*/
+
+/*!
+    \overload
+
+    Sets the string to the string representation of the number \a n
+    and returns a reference to the string.
+*/
+
+TQCString &TQCString::setNum(long n)
+{
+    data();
+    char buf[20];
+    register char *p = &buf[19];
+    bool neg;
+    if (n < 0) {
+        neg = true;
+        n = -n;
+    } else {
+        neg = false;
+    }
+    *p = '\0';
+    do {
+        *--p = ((int)(n%10)) + '0';
+        n /= 10;
+    } while (n);
+    if (neg)
+        *--p = '-';
+    *this = p;
+    return *this;
+}
+
+/*!
+    \overload
+
+    Sets the string to the string representation of the number \a n
+    and returns a reference to the string.
+*/
+
+TQCString &TQCString::setNum(ulong n)
+{
+    data();
+    char buf[20];
+    register char *p = &buf[19];
+    *p = '\0';
+    do {
+        *--p = ((int)(n%10)) + '0';
+        n /= 10;
+    } while (n);
+    *this = p;
+    return *this;
+}
+
+/*!
+    \fn TQCString &TQCString::setNum(int n)
+    \overload
+
+    Sets the string to the string representation of the number \a n
+    and returns a reference to the string.
+*/
+
+/*!
+    \fn TQCString &TQCString::setNum(uint n)
+    \overload
+
+    Sets the string to the string representation of the number \a n
+    and returns a reference to the string.
+*/
+
+/*!
+    \fn TQCString &TQCString::setNum(short n)
+    \overload
+
+    Sets the string to the string representation of the number \a n
+    and returns a reference to the string.
+*/
+
+/*!
+    \fn TQCString &TQCString::setNum(ushort n)
+    \overload
+
+    Sets the string to the string representation of the number \a n
+    and returns a reference to the string.
+*/
+
+/*!
+    Sets the string to the string representation of the number \a n
+    and returns a reference to the string.
+
+    The format of the string representation is specified by the format
+    character \a f, and the precision (number of digits after the
+    decimal point) is specified with \a prec.
+
+    The valid formats for \a f are 'e', 'E', 'f', 'g' and 'G'. The
+    formats are the same as for sprintf(); they are explained in \l
+    QString::arg().
+*/
+
+TQCString &TQCString::setNum(double n, char f, int prec)
+{
+#ifndef QT_NO_DEBUG
+    if (!(f=='f' || f=='F' || f=='e' || f=='E' || f=='g' || f=='G'))
+        qWarning("TQCString::setNum: Invalid format char '%c'", f);
+#endif
+    char format[20];
+    register char *fs = format;                        // generate format string
+    *fs++ = '%';                                //   "%.<prec>l<f>"
+    if (prec > 99)
+        prec = 99;
+    *fs++ = '.';
+    if (prec >= 10) {
+        *fs++ = prec / 10 + '0';
+        *fs++ = prec % 10 + '0';
+    } else {
+        *fs++ = prec + '0';
+    }
+    *fs++ = 'l';
+    *fs++ = f;
+    *fs = '\0';
+    return sprintf(format, n);
+}
+
+/*! \fn TQCString &TQCString::setNum(float n, char f, int prec)
+    \overload
+*/
+
+/*!
+    Sets the character at position \a index to \a c and expands the
+    string if necessary, padding with spaces.
+
+    Returns false if \a index was out of range and the string could
+    not be expanded; otherwise returns true.
+*/
+
+bool TQCString::setExpand(uint index, char c)
+{
+    uint oldlen = length();
+    if (index >= oldlen) {
+        resize(index+1);
+        if (index > oldlen)
+            memset(data() + oldlen, ' ', index - oldlen);
+    }
+    *(data() + index) = c;
+    return true;
+}
+
+
+/*
+    \fn TQCString::operator const char *() const
+
+    Returns the string data.
+*/
+
+
+/*!
+    \fn TQCString& TQCString::append(const char *str)
+
+    Appends string \a str to the string and returns a reference to the
+    string. Equivalent to operator+=().
+*/
+
+#ifndef QT_NO_DATASTREAM
+/*! \fn QDataStream &operator<<(QDataStream &s, const TQCString &str)
+    \relates TQCString
+
+    Writes string \a str to the stream \a s.
+
+    \sa \link datastreamformat.html Format of the QDataStream operators \endlink
+*/
+QDataStream &operator<<(QDataStream &d, const TQCString &s)
+{
+printf("[WARNING] When using << on a QDataStream instead of a TQDataStream functionality may differ from Qt3\n\r");
+    if (d.version() >= QDataStream::Qt_4_0)
+        return operator<<(d, static_cast<const QByteArray &>(s));
+
+    // we need to add a NUL to keep compatibility with Qt 3's QByteArray
+    QByteArray copy = s;
+    copy.append('\0');
+    return operator<<(d, copy);
+}
+
+/*!
+  \fn QDataStream &operator>>(QDataStream &s, TQCString &str)
+    \relates TQCString
+
+    Reads a string into \a str from the stream \a s.
+
+    \sa \link datastreamformat.html Format of the QDataStream operators \endlink
+*/
+QDataStream &operator>>(QDataStream &d, TQCString &s) {
+printf("[WARNING] When using << on a QDataStream instead of a TQDataStream functionality may differ from Qt3\n\r");
+    operator>>(d, static_cast<QByteArray &>(s));
+    if (d.version() < QDataStream::Qt_4_0 && s.endsWith('\0'))
+        s.chop(1);                  // ending NUL
+    return d;
+}
+
+#if 0
+// I don't think this works...
+
+/*! \fn TQDataStream &operator<<(TQDataStream &s, const TQCString &str)
+    \relates TQCString
+
+    Writes string \a str to the stream \a s.
+
+    \sa \link datastreamformat.html Format of the TQDataStream operators \endlink
+*/
+TQDataStream &operator<<(TQDataStream &d, const TQCString &s)
+{
+	if (d.version() >= QDataStream::Qt_4_0) {
+		QDataStream &qds = operator<<(static_cast<QDataStream &>(d), static_cast<const QByteArray &>(s));
+		TQDataStream &tqds = *static_cast<TQDataStream*>(&qds);
+		return tqds;
+	}
+
+	// we need to add a NUL to keep compatibility with Qt 3's QByteArray
+	QByteArray copy = s;
+	copy.append('\0');
+
+	QDataStream &qds = operator<<(static_cast<QDataStream &>(d), static_cast<const QByteArray &>(s));
+	TQDataStream &tqds = *static_cast<TQDataStream*>(&qds);
+	return tqds;
+}
+
+/*!
+  \fn TQDataStream &operator>>(TQDataStream &s, TQCString &str)
+    \relates TQCString
+
+    Reads a string into \a str from the stream \a s.
+
+    \sa \link datastreamformat.html Format of the TQDataStream operators \endlink
+*/
+TQDataStream &operator>>(TQDataStream &d, TQCString &s) {
+    operator>>(d, static_cast<QByteArray &>(s));
+    if (d.version() < QDataStream::Qt_4_0 && s.endsWith('\0'))
+        s.chop(1);                  // ending NUL
+    return d;
+}
+
+#endif
+
+#endif
+
+/*****************************************************************************
+  TQCString stream functions
+ *****************************************************************************/
+#ifndef TQT_NO_DATASTREAM
+/*!
+    \relates TQCString
+
+    Writes string \a str to the stream \a s.
+
+    \sa \link datastreamformat.html Format of the TQDataStream operators \endlink
+*/
+TQDataStream &operator<<( TQDataStream &s, const TQCString &str )
+{
+    return static_cast<TQDataStream &>(s.writeBytes( str.data(), str.size() ));
+}
+
+/*!
+    \relates TQCString
+
+    Reads a string into \a str from the stream \a s.
+
+    \sa \link datastreamformat.html Format of the TQDataStream operators \endlink
+*/
+
+TQDataStream &operator>>( TQDataStream &s, TQCString &str )
+{
+    str.detach();
+    TQ_UINT32 len;
+    s >> len;					// read size of string
+    if ( len == 0 || s.eof() ) {		// end of file reached
+	str.resize( 0 );
+	return s;
+    }
+    if ( !str.TQByteArray::tqresize( (uint)len )) {// resize string
+#if defined(TQT_CHECK_NULL)
+	qWarning( "TQDataStream: Not enough memory to read TQCString" );
+#endif
+	len = 0;
+    }
+    if ( len > 0 )				// not null array
+	s.readRawBytes( str.data(), (uint)len );
+    return s;
+}
+#endif //TQT_NO_DATASTREAM
+
+/*****************************************************************************
+  Documentation for related functions
+ *****************************************************************************/
+
+/*!
+    \fn bool operator==(const TQCString &s1, const TQCString &s2)
+
+    \relates TQCString
+
+    Returns true if \a s1 and \a s2 are equal; otherwise returns false.
+
+    Equivalent to qstrcmp(\a s1, \a s2) == 0.
+*/
+
+/*!
+    \fn bool operator==(const TQCString &s1, const char *s2)
+    \overload
+
+    \relates TQCString
+
+    Returns true if \a s1 and \a s2 are equal; otherwise returns false.
+
+    Equivalent to qstrcmp(\a s1, \a s2) == 0.
+*/
+
+/*!
+    \fn bool operator==(const char *s1, const TQCString &s2)
+    \overload
+
+    \relates TQCString
+
+    Returns true if \a s1 and \a s2 are equal; otherwise returns false.
+
+    Equivalent to qstrcmp(\a s1, \a s2) == 0.
+*/
+
+/*!
+    \fn bool operator!=(const TQCString &s1, const TQCString &s2)
+
+    \relates TQCString
+
+    Returns true if \a s1 and \a s2 are different; otherwise returns false.
+
+    Equivalent to qstrcmp(\a s1, \a s2) != 0.
+*/
+
+/*!
+    \fn bool operator!=(const TQCString &s1, const char *s2)
+    \overload
+
+    \relates TQCString
+
+    Returns true if \a s1 and \a s2 are different; otherwise returns false.
+
+    Equivalent to qstrcmp(\a s1, \a s2) != 0.
+*/
+
+/*!
+    \fn bool operator!=(const char *s1, const TQCString &s2)
+    \overload
+
+    \relates TQCString
+
+    Returns true if \a s1 and \a s2 are different; otherwise returns false.
+
+    Equivalent to qstrcmp(\a s1, \a s2) != 0.
+*/
+
+/*!
+    \fn bool operator<(const TQCString &s1, const char *s2)
+
+    \relates TQCString
+
+    Returns true if \a s1 is less than \a s2; otherwise returns false.
+
+    Equivalent to qstrcmp(\a s1, \a s2) \< 0.
+*/
+
+/*!
+    \fn bool operator<(const char *s1, const TQCString &s2)
+    \overload
+
+    \relates TQCString
+
+    Returns true if \a s1 is less than \a s2; otherwise returns false.
+
+    Equivalent to qstrcmp(\a s1, \a s2) \< 0.
+*/
+
+/*!
+    \fn bool operator<=(const TQCString &s1, const char *s2)
+
+    \relates TQCString
+
+    Returns true if \a s1 is less than or equal to \a s2; otherwise
+    returns false.
+
+    Equivalent to qstrcmp(\a s1, \a s2) \<= 0.
+*/
+
+/*!
+    \fn bool operator<=(const char *s1, const TQCString &s2)
+    \overload
+
+    \relates TQCString
+
+    Returns true if \a s1 is less than or equal to \a s2; otherwise
+    returns false.
+
+    Equivalent to qstrcmp(\a s1, \a s2) \<= 0.
+*/
+
+/*!
+    \fn bool operator>(const TQCString &s1, const char *s2)
+
+    \relates TQCString
+
+    Returns true if \a s1 is greater than \a s2; otherwise returns false.
+
+    Equivalent to qstrcmp(\a s1, \a s2) \> 0.
+*/
+
+/*!
+    \fn bool operator>(const char *s1, const TQCString &s2)
+    \overload
+
+    \relates TQCString
+
+    Returns true if \a s1 is greater than \a s2; otherwise returns false.
+
+    Equivalent to qstrcmp(\a s1, \a s2) \> 0.
+*/
+
+/*!
+    \fn bool operator>=(const TQCString &s1, const char *s2)
+
+    \relates TQCString
+
+    Returns true if \a s1 is greater than or equal to \a s2; otherwise
+    returns false.
+
+    Equivalent to qstrcmp(\a s1, \a s2) \>= 0.
+*/
+
+/*!
+    \fn bool operator>=(const char *s1, const TQCString &s2)
+    \overload
+
+    \relates TQCString
+
+    Returns true if \a s1 is greater than or equal to \a s2; otherwise
+    returns false.
+
+    Equivalent to qstrcmp(\a s1, \a s2) \>= 0.
+*/
+
+/*!
+    \fn const TQCString operator+(const TQCString &s1, const TQCString &s2)
+
+    \relates TQCString
+
+    Returns a string which consists of the concatenation of \a s1 and
+    \a s2.
+*/
+
+/*!
+    \fn const TQCString operator+(const TQCString &s1, const char *s2)
+    \overload
+
+    \relates TQCString
+
+    Returns a string which consists of the concatenation of \a s1 and \a s2.
+*/
+
+/*!
+    \fn const TQCString operator+(const char *s1, const TQCString &s2)
+    \overload
+
+    \relates TQCString
+
+    Returns a string which consists of the concatenation of \a s1 and \a s2.
+*/
+
+/*!
+    \fn const TQCString operator+(const TQCString &s, char c)
+    \overload
+
+    \relates TQCString
+
+    Returns a string which consists of the concatenation of \a s and \a c.
+*/
+
+/*!
+    \fn const TQCString operator+(char c, const TQCString &s)
+    \overload
+
+    \relates TQCString
+    Returns a string which consists of the concatenation of \a c and \a s.
+*/
+
+/*!
+    Returns the number of times the character \a c occurs in the
+    string.
+
+    The match is case sensitive if \a cs is TRUE, or case insensitive
+    if \a cs if FALSE.
+
+    \sa \link #asciinotion Note on character comparisons \endlink
+*/
+
+int TQCString::tqcontains( char c, bool cs ) const
+{
+    int count = 0;
+    const char *d = data();
+    if ( !d )
+	return 0;
+    if ( cs ) {					// case sensitive
+	while ( *d )
+	    if ( *d++ == c )
+		count++;
+    } else {					// case insensitive
+	c = tolower( (uchar) c );
+	while ( *d ) {
+	    if ( tolower((uchar) *d) == c )
+		count++;
+	    d++;
+	}
+    }
+    return count;
+}
+
+/*!
+    \overload
+
+    Counts the number of overlapping occurrences of \a rx in the string.
+
+    Example:
+    \code
+    TQString s = "banana and panama";
+    TQRegExp r = TQRegExp( "a[nm]a", TRUE, FALSE );
+    s.tqcontains( r ); // 4 matches
+    \endcode
+
+    \sa tqfind(), tqfindRev()
+
+    \warning If you want to apply this function repeatedly to the same
+    string it is more efficient to convert the string to a TQString and
+    apply the function to that.
+*/
+
+int TQCString::tqcontains( const QRegExp &rx ) const
+{
+    TQString d = TQString::fromAscii( data() );
+    return d.tqcontains( rx );
+}
+
+/*!
+    \overload
+
+    Returns the number of times \a str occurs in the string.
+
+    The match is case sensitive if \a cs is TRUE, or case insensitive
+    if \a cs if FALSE.
+
+    This function counts overlapping substrings, for example, "banana"
+    tqcontains two occurrences of "ana".
+
+    \sa tqfindRev()
+	\link #asciinotion Note on character comparisons \endlink
+*/
+
+int TQCString::tqcontains( const char *str, bool cs ) const
+{
+    int count = 0;
+    int i = -1;
+    uint l = length();
+    // use tqfind for the faster hashing algorithm
+    while ( ( i = tqfind ( str, i+1, cs, l ) ) != -1 )
+	count++;
+    return count;
+}
+
+#define REHASH( a ) \
+    if ( sl_minus_1 < sizeof(uint) * CHAR_BIT ) \
+	hashHaystack -= (a) << sl_minus_1; \
+    hashHaystack <<= 1
+
+/*!
+    Finds the first occurrence of the character \a c, starting at
+    position \a index.
+
+    The search is case sensitive if \a cs is TRUE, or case insensitive
+    if \a cs is FALSE.
+
+    Returns the position of \a c, or -1 if \a c could not be found.
+
+    \sa \link #asciinotion Note on character comparisons \endlink
+*/
+
+int TQCString::tqfind( char c, int index, bool cs ) const
+{
+    if ( (uint)index >= size() )		// index outside string
+	return -1;
+    register const char *d;
+    if ( cs ) {					// case sensitive
+	d = strchr( data()+index, c );
+    } else {
+	d = data()+index;
+	c = tolower( (uchar) c );
+	while ( *d && tolower((uchar) *d) != c )
+	    d++;
+	if ( !*d && c )				// not found
+	    d = 0;
+    }
+    return d ? (int)(d - data()) : -1;
+}
+
+/*!
+    \overload
+
+    Finds the first occurrence of the string \a str, starting at
+    position \a index.
+
+    The search is case sensitive if \a cs is TRUE, or case insensitive
+    if \a cs is FALSE.
+
+    Returns the position of \a str, or -1 if \a str could not be
+    found.
+
+    \sa \link #asciinotion Note on character comparisons \endlink
+*/
+
+int TQCString::tqfind( const char *str, int index, bool cs ) const
+{
+    return tqfind( str, index, cs, length() );
+}
+
+#ifndef TQT_NO_REGEXP_CAPTURE
+/*!
+    \overload
+
+    Finds the first occurrence of the regular expression \a rx,
+    starting at position \a index.
+
+    Returns the position of the next match, or -1 if \a rx was not
+    found.
+
+    \warning If you want to apply this function repeatedly to the same
+    string it is more efficient to convert the string to a TQString and
+    apply the function to that.
+*/
+
+int TQCString::tqfind( const QRegExp& rx, int index ) const
+{
+    TQString d = TQString::fromAscii( data() );
+    return d.tqfind( rx, index );
+}
+#endif // TQT_NO_REGEXP_CAPTURE
+
+int TQCString::tqfind( const char *str, int index, bool cs, uint l ) const
+{
+    if ( (uint)index >= size() )
+	return -1;
+    if ( !str )
+	return -1;
+    if ( !*str )
+	return index;
+    const uint sl = tqstrlen( str );
+    if ( sl + index > l )
+	return -1;
+
+    if ( sl == 1 )
+	return tqfind( *str, index, cs );
+
+    /*
+      See TQString::tqfind() for details.
+    */
+    const char* needle = str;
+    const char* haystack = data() + index;
+    const char* end = data() + (l-sl);
+    const uint sl_minus_1 = sl-1;
+    uint hashNeedle = 0, hashHaystack = 0,i;
+
+    if ( cs ) {
+	for ( i = 0; i < sl; ++i ) {
+	    hashNeedle = ((hashNeedle<<1) + needle[i] );
+	    hashHaystack = ((hashHaystack<<1) + haystack[i] );
+	}
+	hashHaystack -= *(haystack+sl_minus_1);
+
+	while ( haystack <= end ) {
+	    hashHaystack += *(haystack+sl_minus_1);
+ 	    if ( hashHaystack == hashNeedle  && *needle == *haystack
+		 && tqstrncmp( needle, haystack, sl ) == 0 )
+		return haystack - data();
+
+	    REHASH( *haystack );
+	    ++haystack;
+	}
+    } else {
+	for ( i = 0; i < sl; ++i ) {
+	    hashNeedle = ((hashNeedle<<1) +
+			  tolower( needle[i] ) );
+	    hashHaystack = ((hashHaystack<<1) +
+			    tolower( haystack[i] ) );
+	}
+	hashHaystack -= tolower(*(haystack+sl_minus_1));
+
+	while ( haystack <= end ) {
+	    hashHaystack += tolower(*(haystack+sl_minus_1));
+	    if ( hashHaystack == hashNeedle
+		 && qstrnicmp( needle, haystack, sl ) == 0 )
+		return haystack - data();
+
+	    REHASH( tolower(*haystack) );
+	    ++haystack;
+	}
+    }
+    return -1;
+}
+
+#ifndef TQT_NO_REGEXP
+/*!
+    \overload
+
+    Replaces every occurrence of \a rx in the string with \a str.
+    Returns a reference to the string.
+
+    Example:
+    \code
+    TQString s = "banana";
+    s.tqreplace( TQRegExp("a.*a"), "" );     // becomes "b"
+
+    s = "banana";
+    s.tqreplace( TQRegExp("^[bn]a"), "X" );  // becomes "Xnana"
+
+    s = "banana";
+    s.tqreplace( TQRegExp("^[bn]a"), "" );   // becomes "nana"
+    \endcode
+
+    \warning If you want to apply this function repeatedly to the same
+    string it is more efficient to convert the string to a TQString and
+    apply the function to that.
+*/
+
+TQCString &TQCString::tqreplace( const QRegExp &rx, const char *str )
+{
+    TQString d = TQString::fromAscii( data() );
+    TQString r = TQString::fromAscii( str );
+    d.tqreplace( rx, r );
+    setStr( d.ascii() );
+    return *this;
+}
+#endif //TQT_NO_REGEXP
+
+/*!
+    Appends string \a str to the string and returns a reference to the string.
+*/
+
+TQCString& TQCString::operator+=( const char *str )
+{
+//     if ( !str )
+// 	return *this;				// nothing to append
+//     detach();
+//     uint len1 = length();
+//     uint len2 = tqstrlen(str);
+//     if ( !TQByteArray::tqresize( len1 + len2 + 1 ) )
+// 	return *this;				// no memory
+//     memcpy( data() + len1, str, len2 + 1 );
+//     return *this;
+
+	uint len2 = tqstrlen(QByteArray::constData());
+	QByteArray::tqresize(len2);	// Get rid of the old null terminator
+	QByteArray::append(str);
+	return *this;
+}
+
+/*!
+    \overload
+
+    Appends character \a c to the string and returns a reference to the string.
+*/
+
+TQCString &TQCString::operator+=( char c )
+{
+//     detach();
+//     uint len = length();
+//     if ( !TQByteArray::tqresize( len + 2  ) )
+// 	return *this;				// no memory
+//     *(data() + len) = c;
+//     *(data() + len+1) = '\0';
+//     return *this;
+
+	uint len2 = tqstrlen(QByteArray::constData());
+	QByteArray::tqresize(len2);	// Get rid of the old null terminator
+	QByteArray::append(c);
+	return *this;
+}
+
+TQCString& TQCString::operator+=( const QString qs )
+{
+	uint len2 = tqstrlen(QByteArray::constData());
+	QByteArray::tqresize(len2);	// Get rid of the old null terminator
+	QByteArray tmp = qs.toAscii();
+	return append(tmp);
+}
+
+TQCString& TQCString::operator+=( const QByteArray qba )
+{
+	uint len2 = tqstrlen(QByteArray::constData());
+	QByteArray::tqresize(len2);	// Get rid of the old null terminator
+	return append(qba);
+}
+
+TQCString& TQCString::operator+=( const TQCString tqcs ) {
+	return operator+=(tqcs.constData());
+}
+
+QT_END_NAMESPACE
+
+#else // USE_QT4
+
+/*!
+    \class TQCString tqcstring.h
+    \reentrant
+    \brief The TQCString class provides an abstraction of the classic C
+    zero-terminated char array (char *).
+
+    \ingroup text
+    \ingroup collection
+    \ingroup tools
+    \ingroup shared
+
+    TQCString inherits TQByteArray, which is defined as
+    TQMemArray\<char\>. Since TQCString is a TQMemArray, it uses \link
+    shclass.html explicit sharing\endlink with a reference count.
+
+    TQCString tries to behave like a more convenient \c{const char *}.
+    The price of doing this is that some algorithms will perform
+    badly. For example, append() is O(length()) since it scans for a
+    null terminator. Although you might use TQCString for text that is
+    never exposed to the user, for most purposes, and especially for
+    user-visible text, you should use TQString. TQString provides
+    implicit sharing, Unicode and other internationalization support,
+    and is well optimized.
+
+    Note that for the TQCString methods that take a \c{const char *}
+    parameter the \c{const char *} must either be 0 (null) or not-null
+    and '\0' (NUL byte) terminated; otherwise the results are
+    undefined.
+
+    A TQCString that has not been assigned to anything is \e null, i.e.
+    both the length and the data pointer is 0. A TQCString that
+    references the empty string ("", a single '\0' char) is \e empty.
+    Both null and empty TQCStrings are legal parameters to the methods.
+    Assigning \c{const char *} 0 to TQCString produces a null TQCString.
+
+    The length() function returns the length of the string; resize()
+    resizes the string and truncate() truncates the string. A string
+    can be filled with a character using fill(). Strings can be left
+    or right padded with characters using leftJustify() and
+    rightJustify(). Characters, strings and regular expressions can be
+    searched for using tqfind() and tqfindRev(), and counted using
+    tqcontains().
+
+    Strings and characters can be inserted with insert() and appended
+    with append(). A string can be prepended with prepend().
+    Characters can be removed from the string with remove() and
+    tqreplaced with tqreplace().
+
+    Portions of a string can be extracted using left(), right() and
+    mid(). Whitespace can be removed using stripWhiteSpace() and
+    simplifyWhiteSpace(). Strings can be converted to uppercase or
+    lowercase with upper() and lower() respectively.
+
+    Strings that contain numbers can be converted to numbers with
+    toShort(), toInt(), toLong(), toULong(), toFloat() and toDouble().
+    Numbers can be converted to strings with setNum().
+
+    Many operators are overloaded to work with TQCStrings. TQCString
+    also supports some more obscure functions, e.g. sprintf(),
+    setStr() and setExpand().
+
+    \target asciinotion
+    \sidebar Note on Character Comparisons
+
+    In TQCString the notion of uppercase and lowercase and of which
+    character is greater than or less than another character is locale
+    dependent. This affects functions which support a case insensitive
+    option or which compare or lowercase or uppercase their arguments.
+    Case insensitive operations and comparisons will be accurate if
+    both strings contain only ASCII characters. (If \c $LC_CTYPE is
+    set, most Unix systems do "the right thing".) Functions that this
+    affects include tqcontains(), tqfind(), tqfindRev(), \l operator<(), \l
+    operator<=(), \l operator>(), \l operator>=(), lower() and
+    upper().
+
+    This issue does not apply to \l{TQString}s since they represent
+    characters using Unicode.
+    \endsidebar
+
+    Performance note: The TQCString methods for TQRegExp searching are
+    implemented by converting the TQCString to a TQString and performing
+    the search on that. This implies a deep copy of the TQCString data.
+    If you are going to perform many TQRegExp searches on a large
+    TQCString, you will get better performance by converting the
+    TQCString to a TQString yourself, and then searching in the TQString.
+*/
+
+/*!
+    \fn TQCString::TQCString()
+
+    Constructs a null string.
+
+    \sa isNull()
+*/
+
+/*!
+    \fn TQCString::TQCString( const TQCString &s )
+
+    Constructs a shallow copy \a s.
+
+    \sa assign()
+*/
+
+/*!
+    Constructs a string with room for \a size characters, including
+    the '\0'-terminator. Makes a null string if \a size == 0.
+
+    If \a size \> 0, then the first and last characters in the string
+    are initialized to '\0'. All other characters are uninitialized.
+
+    \sa resize(), isNull()
+*/
+
+TQCString::TQCString( int size )
+    : TQByteArray( size )
+{
+    if ( size > 0 ) {
+	*data() = '\0';				// set terminator
+	*(data()+(size-1)) = '\0';
+    }
+}
+
+/*!
+    Constructs a string that is a deep copy of \a str.
+
+    If \a str is 0 a null string is created.
+
+    \sa isNull()
+*/
+
+TQCString::TQCString( const char *str )
+{
+    duplicate( str, tqstrlen(str) + 1 );
+}
+
+
+/*!
+    Constructs a string that is a deep copy of \a str. The copy will
+    be at most \a maxsize bytes long including the '\0'-terminator.
+
+    Example:
+    \code
+    TQCString str( "helloworld", 6 ); // assigns "hello" to str
+    \endcode
+
+    If \a str tqcontains a 0 byte within the first \a maxsize bytes, the
+    resulting TQCString will be terminated by this 0. If \a str is 0 a
+    null string is created.
+
+    \sa isNull()
+*/
+
+TQCString::TQCString( const char *str, uint maxsize )
+{
+    if ( str == 0 )
+	return;
+    uint len; // index of first '\0'
+    for ( len = 0; len < maxsize - 1; len++ ) {
+	if ( str[len] == '\0' )
+	    break;
+    }
+    TQByteArray::tqresize( len + 1 );
+    memcpy( data(), str, len );
+    data()[len] = 0;
+}
+
+/*!
+  \reimp
+*/
+
+TQCString::~TQCString()
+{
+}
+
+TQCString &TQCString::operator=(const QByteArray &ba) {
+	TQByteArray::operator=(ba);
+	return *this;
+}
+
+/*!
+    \fn TQCString &TQCString::operator=( const TQCString &s )
+
+    Assigns a shallow copy of \a s to this string and returns a
+    reference to this string.
+*/
+
+/*!
+    \overload TQCString &TQCString::operator=( const char *str )
+
+    Assigns a deep copy of \a str to this string and returns a
+    reference to this string.
+
+    If \a str is 0 a null string is created.
+
+    \sa isNull()
+*/
+
+/*!
+    \fn bool TQCString::isNull() const
+
+    Returns TRUE if the string is null, i.e. if data() == 0; otherwise
+    returns FALSE. A null string is also an empty string.
+
+    Example:
+    \code
+    TQCString a;		// a.data() == 0,  a.size() == 0, a.length() == 0
+    TQCString b == "";	// b.data() == "", b.size() == 1, b.length() == 0
+    a.isNull();		// TRUE  because a.data() == 0
+    a.isEmpty();	// TRUE  because a.length() == 0
+    b.isNull();		// FALSE because b.data() == ""
+    b.isEmpty();	// TRUE  because b.length() == 0
+    \endcode
+
+    \sa isEmpty(), length(), size()
+*/
+
+/*!
+    \fn bool TQCString::isEmpty() const
+
+    Returns TRUE if the string is empty, i.e. if length() == 0;
+    otherwise returns FALSE. An empty string is not always a null
+    string.
+
+    See example in isNull().
+
+    \sa isNull(), length(), size()
+*/
+
+/*!
+    \fn uint TQCString::length() const
+
+    Returns the length of the string, excluding the '\0'-terminator.
+    Equivalent to calling \c strlen(data()).
+
+    Null strings and empty strings have zero length.
+
+    \sa size(), isNull(), isEmpty()
+*/
+
+/*!
+    \fn bool TQCString::truncate( uint pos )
+
+    Truncates the string at position \a pos.
+
+    Equivalent to calling \c resize(pos+1).
+
+    Example:
+    \code
+    TQCString s = "truncate this string";
+    s.truncate( 5 );                      // s == "trunc"
+    \endcode
+
+    \sa resize()
+*/
+
+/*!
+    Extends or shrinks the string to \a len bytes, including the
+    '\0'-terminator.
+
+    A '\0'-terminator is set at position \c{len - 1} unless
+    \c{len == 0}.
+
+    Example:
+    \code
+    TQCString s = "resize this string";
+    s.resize( 7 );                      // s == "resize"
+    \endcode
+
+    \sa truncate()
+*/
+
+bool TQCString::tqresize( uint len )
+{
+    detach();
+    uint wasNull = isNull();
+    if ( !TQByteArray::tqresize(len) )
+	return FALSE;
+    if ( len )
+	data()[len - 1] = '\0';
+    if ( len > 0 && wasNull )
+	data()[0] = '\0';
+    return TRUE;
+}
+
+
+/*!
+    Implemented as a call to the native vsprintf() (see the manual for
+    your C library).
+
+    If the string is shorter than 256 characters, this sprintf() calls
+    resize(256) to decrease the chance of memory corruption. The
+    string is resized back to its actual length before sprintf()
+    returns.
+
+    Example:
+    \code
+    TQCString s;
+    s.sprintf( "%d - %s", 1, "first" );		// result < 256 chars
+
+    TQCString big( 25000 );			// very long string
+    big.sprintf( "%d - %s", 2, longString );	// result < 25000 chars
+    \endcode
+
+    \warning All vsprintf() implementations will write past the end of
+    the target string (*this) if the \a format specification and
+    arguments happen to be longer than the target string, and some
+    will also fail if the target string is longer than some arbitrary
+    implementation limit.
+
+    Giving user-supplied arguments to sprintf() is risky: Sooner or
+    later someone will paste a huge line into your application.
+*/
+
+TQCString &TQCString::sprintf( const char *format, ... )
+{
+    detach();
+    va_list ap;
+    va_start( ap, format );
+    if ( size() < 256 )
+	TQByteArray::tqresize( 256 );		// make string big enough
+#ifdef TQT_VSNPRINTF
+    TQT_VSNPRINTF( data(), size(), format, ap );
+#else
+    vsprintf( data(), format, ap );
+#endif
+    resize( tqstrlen(data()) + 1 );		// truncate
+    va_end( ap );
+    return *this;
+}
+
+
+/*!
+    Fills the string with \a len bytes of character \a c, followed by
+    a '\0'-terminator.
+
+    If \a len is negative, then the current string length is used.
+
+    Returns FALSE is \a len is nonnegative and there is not enough
+    memory to resize the string; otherwise returns TRUE.
+*/
+
+bool TQCString::fill( char c, int len )
+{
+    detach();
+    if ( len < 0 )
+	len = length();
+    if ( !TQByteArray::fill(c,len+1) )
+	return FALSE;
+    *(data()+len) = '\0';
+    return TRUE;
+}
+
+
+/*!
+    \fn TQCString TQCString::copy() const
+
+    Returns a deep copy of this string.
+
+    \sa detach()
+*/
+
+
+/*!
+    Finds the first occurrence of the character \a c, starting at
+    position \a index.
+
+    The search is case sensitive if \a cs is TRUE, or case insensitive
+    if \a cs is FALSE.
+
+    Returns the position of \a c, or -1 if \a c could not be found.
+
+    \sa \link #asciinotion Note on character comparisons \endlink
+*/
+
+int TQCString::tqfind( char c, int index, bool cs ) const
+{
+    if ( (uint)index >= size() )		// index outside string
+	return -1;
+    register const char *d;
+    if ( cs ) {					// case sensitive
+	d = strchr( data()+index, c );
+    } else {
+	d = data()+index;
+	c = tolower( (uchar) c );
+	while ( *d && tolower((uchar) *d) != c )
+	    d++;
+	if ( !*d && c )				// not found
+	    d = 0;
+    }
+    return d ? (int)(d - data()) : -1;
+}
+
+#define REHASH( a ) \
+    if ( sl_minus_1 < sizeof(uint) * CHAR_BIT ) \
+	hashHaystack -= (a) << sl_minus_1; \
+    hashHaystack <<= 1
+
+/*!
+    \overload
+
+    Finds the first occurrence of the string \a str, starting at
+    position \a index.
+
+    The search is case sensitive if \a cs is TRUE, or case insensitive
+    if \a cs is FALSE.
+
+    Returns the position of \a str, or -1 if \a str could not be
+    found.
+
+    \sa \link #asciinotion Note on character comparisons \endlink
+*/
+
+int TQCString::tqfind( const char *str, int index, bool cs ) const
+{
+    return tqfind( str, index, cs, length() );
+}
+
+int TQCString::tqfind( const char *str, int index, bool cs, uint l ) const
+{
+    if ( (uint)index >= size() )
+	return -1;
+    if ( !str )
+	return -1;
+    if ( !*str )
+	return index;
+    const uint sl = tqstrlen( str );
+    if ( sl + index > l )
+	return -1;
+
+    if ( sl == 1 )
+	return tqfind( *str, index, cs );
+
+    /*
+      See TQString::tqfind() for details.
+    */
+    const char* needle = str;
+    const char* haystack = data() + index;
+    const char* end = data() + (l-sl);
+    const uint sl_minus_1 = sl-1;
+    uint hashNeedle = 0, hashHaystack = 0,i;
+
+    if ( cs ) {
+	for ( i = 0; i < sl; ++i ) {
+	    hashNeedle = ((hashNeedle<<1) + needle[i] );
+	    hashHaystack = ((hashHaystack<<1) + haystack[i] );
+	}
+	hashHaystack -= *(haystack+sl_minus_1);
+
+	while ( haystack <= end ) {
+	    hashHaystack += *(haystack+sl_minus_1);
+ 	    if ( hashHaystack == hashNeedle  && *needle == *haystack
+		 && tqstrncmp( needle, haystack, sl ) == 0 )
+		return haystack - data();
+
+	    REHASH( *haystack );
+	    ++haystack;
+	}
+    } else {
+	for ( i = 0; i < sl; ++i ) {
+	    hashNeedle = ((hashNeedle<<1) +
+			  tolower( needle[i] ) );
+	    hashHaystack = ((hashHaystack<<1) +
+			    tolower( haystack[i] ) );
+	}
+	hashHaystack -= tolower(*(haystack+sl_minus_1));
+
+	while ( haystack <= end ) {
+	    hashHaystack += tolower(*(haystack+sl_minus_1));
+	    if ( hashHaystack == hashNeedle
+		 && qstrnicmp( needle, haystack, sl ) == 0 )
+		return haystack - data();
+
+	    REHASH( tolower(*haystack) );
+	    ++haystack;
+	}
+    }
+    return -1;
+}
+
+
+/*!
+    Finds the first occurrence of the character \a c, starting at
+    position \a index and searching backwards.
+
+    The search is case sensitive if \a cs is TRUE, or case insensitive
+    if \a cs is FALSE.
+
+    Returns the position of \a c, or -1 if \a c could not be found.
+
+    \sa \link #asciinotion Note on character comparisons \endlink
+*/
+
+int TQCString::tqfindRev( char c, int index, bool cs ) const
+{
+    register const char *b = data();
+    register const char *d;
+    if ( index < 0 )
+	index = length();
+    if ( (uint)index >= size() )
+	return -1;
+    d = b + index;
+    if ( cs ) {
+	while ( d >= b && *d != c )
+	    d--;
+    } else {
+	c = tolower( (uchar) c );
+	while ( d >= b && tolower((uchar) *d) != c )
+	    d--;
+    }
+    return d >= b ? (int)(d - b) : -1;
+}
+
+/*!
+    \overload
+
+    Finds the first occurrence of the string \a str, starting at
+    position \a index and searching backwards.
+
+    The search is case sensitive if \a cs is TRUE, or case insensitive
+    if \a cs is FALSE.
+
+    Returns the position of \a str, or -1 if \a str could not be
+    found.
+
+    \sa \link #asciinotion Note on character comparisons \endlink
+*/
+
+int TQCString::tqfindRev( const char *str, int index, bool cs ) const
+{
+    /*
+      See TQString::tqfind() for explanations.
+    */
+    const uint sl = tqstrlen( str );
+    const uint l = length();
+    int delta = l-sl;
+    if ( index < 0 )
+	index = delta;
+    if ( index < 0 || index > (int)l )
+	return -1;
+    if ( index > delta )
+	index = delta;
+
+    if ( sl == 1 )
+	return tqfindRev( *str, index, cs );
+
+    const char* needle = str;
+    const char* haystack = data() + index;
+    const char* end = data();
+    const uint sl_minus_1 = sl-1;
+    const char* n = needle+sl_minus_1;
+    const char* h = haystack+sl_minus_1;
+    uint hashNeedle = 0, hashHaystack = 0, i;
+
+    if ( cs ) {
+	for ( i = 0; i < sl; ++i ) {
+	    hashNeedle = ((hashNeedle<<1) + *(n-i) );
+	    hashHaystack = ((hashHaystack<<1) + *(h-i) );
+	}
+	hashHaystack -= *haystack;
+	while ( haystack >= end ) {
+	    hashHaystack += *haystack;
+ 	    if ( hashHaystack == hashNeedle  && tqstrncmp( needle, haystack, sl ) == 0 )
+		return haystack-data();
+	    --haystack;
+	    REHASH( *(haystack+sl) );
+	}
+    } else {
+	for ( i = 0; i < sl; ++i ) {
+	    hashNeedle = ((hashNeedle<<1) + tolower( *(n-i) ) );
+	    hashHaystack = ((hashHaystack<<1) + tolower( *(h-i) ) );
+	}
+	hashHaystack -= tolower(*haystack);
+	while ( haystack >= end ) {
+	    hashHaystack += tolower(*haystack);
+	    if ( hashHaystack == hashNeedle && qstrnicmp( needle, haystack, sl ) == 0 )
+		return haystack-data();
+	    --haystack;
+	    REHASH( tolower(*(haystack+sl)) );
+	}
+    }
+    return -1;
+}
+
+
+/*!
+    Returns the number of times the character \a c occurs in the
+    string.
+
+    The match is case sensitive if \a cs is TRUE, or case insensitive
+    if \a cs if FALSE.
+
+    \sa \link #asciinotion Note on character comparisons \endlink
+*/
+
+int TQCString::tqcontains( char c, bool cs ) const
+{
+    int count = 0;
+    const char *d = data();
+    if ( !d )
+	return 0;
+    if ( cs ) {					// case sensitive
+	while ( *d )
+	    if ( *d++ == c )
+		count++;
+    } else {					// case insensitive
+	c = tolower( (uchar) c );
+	while ( *d ) {
+	    if ( tolower((uchar) *d) == c )
+		count++;
+	    d++;
+	}
+    }
+    return count;
+}
+
+/*!
+    \overload
+
+    Returns the number of times \a str occurs in the string.
+
+    The match is case sensitive if \a cs is TRUE, or case insensitive
+    if \a cs if FALSE.
+
+    This function counts overlapping substrings, for example, "banana"
+    tqcontains two occurrences of "ana".
+
+    \sa tqfindRev()
+	\link #asciinotion Note on character comparisons \endlink
+*/
+
+int TQCString::tqcontains( const char *str, bool cs ) const
+{
+    int count = 0;
+    int i = -1;
+    uint l = length();
+    // use tqfind for the faster hashing algorithm
+    while ( ( i = tqfind ( str, i+1, cs, l ) ) != -1 )
+	count++;
+    return count;
+}
+
+/*!
+    Returns a substring that tqcontains the \a len leftmost characters
+    of the string.
+
+    The whole string is returned if \a len exceeds the length of the
+    string.
+
+    Example:
+    \code
+    TQCString s = "Pineapple";
+    TQCString t = s.left( 4 );  // t == "Pine"
+    \endcode
+
+    \sa right(), mid()
+*/
+TQCString TQCString::left( uint len ) const
+{
+    if ( isEmpty() ) {
+	TQCString empty;
+	return empty;
+    } else if ( len >= size() ) {
+	TQCString same( data() );
+	return same;
+    } else {
+	TQCString s( len+1 );
+	strncpy( s.data(), data(), len );
+	*(s.data()+len) = '\0';
+	return s;
+    }
+}
+
+/*!
+    Returns a substring that tqcontains the \a len rightmost characters
+    of the string.
+
+    The whole string is returned if \a len exceeds the length of the
+    string.
+
+    Example:
+    \code
+    TQCString s = "Pineapple";
+    TQCString t = s.right( 5 );  // t == "apple"
+    \endcode
+
+    \sa left(), mid()
+*/
+
+TQCString TQCString::right( uint len ) const
+{
+    if ( isEmpty() ) {
+	TQCString empty;
+	return empty;
+    } else {
+	uint l = length();
+	if ( len > l )
+	    len = l;
+	char *p = const_cast<char*>(data()) + (l - len);
+	return TQCString( p );
+    }
+}
+
+/*!
+    Returns a substring that tqcontains at most \a len characters from
+    this string, starting at position \a index.
+
+    Returns a null string if the string is empty or if \a index is out
+    of range. Returns the whole string from \a index if \a index+len
+    exceeds the length of the string.
+
+    Example:
+    \code
+    TQCString s = "Two pineapples";
+    TQCString t = s.mid( 4, 3 );     // t == "pin"
+    \endcode
+
+    \sa left(), right()
+*/
+
+TQCString TQCString::mid( uint index, uint len ) const
+{
+    uint slen = tqstrlen( data() );
+    if ( isEmpty() || index >= slen ) {
+	TQCString empty;
+	return empty;
+    } else {
+	if ( len > slen-index )
+	    len = slen - index;
+	register char *p = const_cast<char*>(data())+index;
+	TQCString s( len+1 );
+	strncpy( s.data(), p, len );
+	*(s.data()+len) = '\0';
+	return s;
+    }
+}
+
+/*!
+    Returns a string of length \a width (plus one for the terminating
+    '\0') that tqcontains this string padded with the \a fill character.
+
+    If the length of the string exceeds \a width and \a truncate is
+    FALSE (the default), then the returned string is a copy of the
+    string. If the length of the string exceeds \a width and \a
+    truncate is TRUE, then the returned string is a left(\a width).
+
+    Example:
+    \code
+    TQCString s("apple");
+    TQCString t = s.leftJustify(8, '.');  // t == "apple..."
+    \endcode
+
+    \sa rightJustify()
+*/
+
+TQCString TQCString::leftJustify( uint width, char fill, bool truncate ) const
+{
+    TQCString result;
+    int len = tqstrlen(data());
+    int padlen = width - len;
+    if ( padlen > 0 ) {
+	result.TQByteArray::tqresize( len+padlen+1 );
+	memcpy( result.data(), data(), len );
+	memset( result.data()+len, fill, padlen );
+	result[len+padlen] = '\0';
+    } else {
+	if ( truncate )
+	    result = left( width );
+	else
+	    result = copy();
+    }
+    return result;
+}
+
+/*!
+    Returns a string of length \a width (plus one for the terminating
+    '\0') that tqcontains zero or more of the \a fill character followed
+    by this string.
+
+    If the length of the string exceeds \a width and \a truncate is
+    FALSE (the default), then the returned string is a copy of the
+    string. If the length of the string exceeds \a width and \a
+    truncate is TRUE, then the returned string is a left(\a width).
+
+    Example:
+    \code
+    TQCString s("pie");
+    TQCString t = s.rightJustify(8, '.');  // t == ".....pie"
+    \endcode
+
+    \sa leftJustify()
+*/
+
+TQCString TQCString::rightJustify( uint width, char fill, bool truncate ) const
+{
+    TQCString result;
+    int len = tqstrlen(data());
+    int padlen = width - len;
+    if ( padlen > 0 ) {
+	result.TQByteArray::tqresize( len+padlen+1 );
+	memset( result.data(), fill, padlen );
+	memcpy( result.data()+padlen, data(), len );
+	result[len+padlen] = '\0';
+    } else {
+	if ( truncate )
+	    result = left( width );
+	else
+	    result = copy();
+    }
+    return result;
+}
+
+/*!
+    Returns a new string that is a copy of this string converted to lower
+    case.
+
+    Example:
+    \code
+    TQCString s("Credit");
+    TQCString t = s.lower();  // t == "credit"
+    \endcode
+
+    \sa upper()
+      \link #asciinotion Note on character comparisons \endlink
+*/
+
+TQCString TQCString::lower() const
+{
+    TQCString s( data() );
+    register char *p = s.data();
+    if ( p ) {
+	while ( *p ) {
+	    *p = tolower( (uchar) *p );
+	    p++;
+	}
+    }
+    return s;
+}
+
+/*!
+    Returns a new string that is a copy of this string converted to upper case.
+
+    Example:
+    \code
+    TQCString s( "Debit" );
+    TQCString t = s.upper();  // t == "DEBIT"
+    \endcode
+
+    \sa lower()
+      \link #asciinotion Note on character comparisons \endlink
+*/
+
+TQCString TQCString::upper() const
+{
+    TQCString s( data() );
+    register char *p = s.data();
+    if ( p ) {
+	while ( *p ) {
+	    *p = toupper(*p);
+	    p++;
+	}
+    }
+    return s;
+}
+
+
+/*!
+    Returns a new string that has white space removed from the start
+    and the end.
+
+    White space means the decimal ASCII codes 9, 10, 11, 12, 13 and
+    32.
+
+    Example:
+    \code
+    TQCString s = " space ";
+    TQCString t = s.stripWhiteSpace();		// t == "space"
+    \endcode
+
+    \sa simplifyWhiteSpace()
+*/
+
+TQCString TQCString::stripWhiteSpace() const
+{
+    if ( isEmpty() )				// nothing to do
+	return copy();
+
+    register char *s = const_cast<char*>(data());
+    TQCString result = s;
+    int reslen = result.length();
+    if ( !isspace((uchar) s[0]) && !isspace((uchar) s[reslen-1]) )
+	return result;				// returns a copy
+
+    s = result.data();
+    int start = 0;
+    int end = reslen - 1;
+    while ( isspace((uchar) s[start]) )		// skip white space from start
+	start++;
+    if ( s[start] == '\0' ) {			// only white space
+	result.resize( 1 );
+	return result;
+    }
+    while ( end && isspace((uchar) s[end]) )	// skip white space from end
+	end--;
+    end -= start - 1;
+    memmove( result.data(), &s[start], end );
+    result.resize( end + 1 );
+    return result;
+}
+
+
+/*!
+    Returns a new string that has white space removed from the start
+    and the end, plus any sequence of internal white space tqreplaced
+    with a single space (ASCII 32).
+
+    White space means the decimal ASCII codes 9, 10, 11, 12, 13 and
+    32.
+
+    \code
+    TQCString s = "  lots\t of\nwhite    space ";
+    TQCString t = s.simplifyWhiteSpace(); // t == "lots of white space"
+    \endcode
+
+    \sa stripWhiteSpace()
+*/
+
+TQCString TQCString::simplifyWhiteSpace() const
+{
+    if ( isEmpty() )				// nothing to do
+	return copy();
+    TQCString result( size() );
+    char *from	= const_cast<char*>(data());
+    char *to	= result.data();
+    char *first = to;
+    for ( ;; ) {
+	while ( isspace((uchar) *from) )
+	    from++;
+	while ( *from && !isspace((uchar) *from) )
+	    *to++ = *from++;
+	if ( *from )
+	    *to++ = 0x20;			// ' '
+	else
+	    break;
+    }
+    if ( to > first && *(to-1) == 0x20 )
+	to--;
+    *to = '\0';
+    result.resize( (int)(to - result.data()) + 1 );
+    return result;
+}
+
+
+/*!
+    \overload
+
+    Inserts string \a s into the string at position \a index.
+
+    If \a index is beyond the end of the string, the string is
+    padded with spaces (ASCII 32) to length \a index and then \a s
+    is appended.
+
+    \code
+    TQCString s = "I like fish";
+    s.insert( 2, "don't ");     // s == "I don't like fish"
+
+    s = "x";                    // index 01234
+    s.insert( 3, "yz" );        // s == "x  yz"
+    \endcode
+*/
+
+TQCString &TQCString::insert( uint index, const char *s )
+{
+    int len = tqstrlen(s);
+    if ( len == 0 )
+	return *this;
+    uint olen = length();
+    int nlen = olen + len;
+    if ( index >= olen ) {			// insert after end of string
+	detach();
+	if ( TQByteArray::tqresize(nlen+index-olen+1 ) ) {
+	    memset( data()+olen, ' ', index-olen );
+	    memcpy( data()+index, s, len+1 );
+	}
+    } else {
+	detach();
+	if ( TQByteArray::tqresize(nlen+1 ) ) {	// normal insert
+	    memmove( data()+index+len, data()+index, olen-index+1 );
+	    memcpy( data()+index, s, len );
+	}
+    }
+    return *this;
+}
+
+/*!
+    Inserts character \a c into the string at position \a index and
+    returns a reference to the string.
+
+    If \a index is beyond the end of the string, the string is
+    padded with spaces (ASCII 32) to length \a index and then \a c
+    is appended.
+
+    Example:
+    \code
+    TQCString s = "Yes";
+    s.insert( 3, '!');   // s == "Yes!"
+    \endcode
+
+    \sa remove(), tqreplace()
+*/
+
+TQCString &TQCString::insert( uint index, char c )	// insert char
+{
+    char buf[2];
+    buf[0] = c;
+    buf[1] = '\0';
+    return insert( index, buf );
+}
+
+/*!
+    \fn TQCString &TQCString::prepend( const char *s )
+
+    Prepend \a s to the string. Equivalent to insert(0, s).
+
+    \sa insert()
+*/
+
+/*!
+    Removes \a len characters from the string, starting at position \a
+    index, and returns a reference to the string.
+
+    If \a index is out of range, nothing happens. If \a index is
+    valid, but \a index + \a len is larger than the length of the
+    string, the string is truncated at position \a index.
+
+    \code
+    TQCString s = "Montreal";
+    s.remove( 1, 4 );         // s == "Meal"
+    \endcode
+
+    \sa insert(), tqreplace()
+*/
+
+TQCString &TQCString::remove( uint index, uint len )
+{
+    uint olen = length();
+    if ( index + len >= olen ) {		// range problems
+	if ( index < olen ) {			// index ok
+	    detach();
+	    resize( index+1 );
+	}
+    } else if ( len != 0 ) {
+	detach();
+	memmove( data()+index, data()+index+len, olen-index-len+1 );
+	TQByteArray::tqresize(olen-len+1 );
+    }
+    return *this;
+}
+
+/*!
+    Replaces \a len characters from the string, starting at position
+    \a index, with \a str, and returns a reference to the string.
+
+    If \a index is out of range, nothing is removed and \a str is
+    appended at the end of the string. If \a index is valid, but \a
+    index + \a len is larger than the length of the string, \a str
+    tqreplaces the rest of the string from position \a index.
+
+    \code
+    TQCString s = "Say yes!";
+    s.tqreplace( 4, 3, "NO" );  // s == "Say NO!"
+    \endcode
+
+    \sa insert(), remove()
+*/
+
+TQCString &TQCString::tqreplace( uint index, uint len, const char *str )
+{
+    remove( index, len );
+    insert( index, str );
+    return *this;
+}
+
+
+/*! \overload
+
+    Replaces every occurrence of the character \a c in the string
+    with \a after. Returns a reference to the string.
+
+    Example:
+    \code
+    TQCString s = "a,b,c";
+    s.tqreplace( ',', " or " );
+    // s == "a or b or c"
+    \endcode
+*/
+TQCString &TQCString::tqreplace( char c, const char *after )
+{
+    char str[2];
+    str[0] = c;
+    str[1] = '\0';
+    return tqreplace( str, after );
+}
+
+/*! \overload
+
+    Replaces every occurrence of the string \a before in the string
+    with the string \a after. Returns a reference to the string.
+
+    Example:
+    \code
+    TQCString s = "Greek is Greek";
+    s.tqreplace( "Greek", "English" );
+    // s == "English is English"
+    \endcode
+*/
+
+TQCString &TQCString::tqreplace( const char *before, const char *after )
+{
+    if ( before == after || isNull() )
+	return *this;
+
+    detach();
+
+    int index = 0;
+    const int bl = before ? int(strlen( before )) : 0;
+    const int al = after ? int(strlen( after )) : 0;
+    char *d = data();
+    uint len = length();
+
+    if ( bl == al ) {
+	if ( bl ) {
+	    while( (index = tqfind( before, index, TRUE, len ) ) != -1 ) {
+		memcpy( d+index, after, al );
+		index += bl;
+	    }
+	}
+    } else if ( al < bl ) {
+	uint to = 0;
+	uint movestart = 0;
+	uint num = 0;
+	while( (index = tqfind( before, index, TRUE, len ) ) != -1 ) {
+	    if ( num ) {
+		int msize = index - movestart;
+		if ( msize > 0 ) {
+		    memmove( d + to, d + movestart, msize );
+		    to += msize;
+		}
+	    } else {
+		to = index;
+	    }
+	    if ( al ) {
+		memcpy( d + to, after, al );
+		to += al;
+	    }
+	    index += bl;
+	    movestart = index;
+	    num++;
+	}
+	if ( num ) {
+	    int msize = len - movestart;
+	    if ( msize > 0 )
+		memmove( d + to, d + movestart, msize );
+	    resize( len - num*(bl-al) + 1 );
+	}
+    } else {
+	// the most complex case. We don't want to loose performance by doing repeated
+	// copies and reallocs of the string.
+	while( index != -1 ) {
+	    uint indices[4096];
+	    uint pos = 0;
+	    while( pos < 4095 ) {
+		index = tqfind(before, index, TRUE, len);
+		if ( index == -1 )
+		    break;
+		indices[pos++] = index;
+		index += bl;
+		// avoid infinite loop
+		if ( !bl )
+		    index++;
+	    }
+	    if ( !pos )
+		break;
+
+	    // we have a table of tqreplacement positions, use them for fast replacing
+	    int adjust = pos*(al-bl);
+	    // index has to be adjusted in case we get back into the loop above.
+	    if ( index != -1 )
+		index += adjust;
+	    uint newlen = len + adjust;
+	    int moveend = len;
+	    if ( newlen > len ) {
+		resize( newlen + 1 );
+		len = newlen;
+	    }
+	    d = data();
+
+	    while( pos ) {
+		pos--;
+		int movestart = indices[pos] + bl;
+		int insertstart = indices[pos] + pos*(al-bl);
+		int moveto = insertstart + al;
+		memmove( d + moveto, d + movestart, (moveend - movestart) );
+		if ( after )
+		    memcpy( d + insertstart, after, al );
+		moveend = movestart - bl;
+	    }
+	}
+    }
+    return *this;
+}
+
+/*! \overload
+
+  Replaces every occurrence of \a c1 with the char \a c2.
+  Returns a reference to the string.
+*/
+TQCString &TQCString::tqreplace( char c1, char c2 )
+{
+    detach();
+    uint i = 0;
+    char *d = data();
+    uint len = length();
+    while ( i < len ) {
+	if ( d[i] == c1 )
+	    d[i] = c2;
+	i++;
+    }
+    return *this;
+}
+
+
+#ifndef TQT_NO_REGEXP_CAPTURE
+/*!
+    \overload
+
+    Finds the first occurrence of the regular expression \a rx,
+    starting at position \a index.
+
+    Returns the position of the next match, or -1 if \a rx was not
+    found.
+
+    \warning If you want to apply this function repeatedly to the same
+    string it is more efficient to convert the string to a TQString and
+    apply the function to that.
+*/
+
+int TQCString::tqfind( const TQRegExp& rx, int index ) const
+{
+    TQString d = TQString::fromAscii( data() );
+    return d.tqfind( rx, index );
+}
+
+/*!
+    \overload
+
+    Finds the first occurrence of the regular expression \a rx,
+    starting at position \a index and searching backwards.
+
+    Returns the position of the next match (backwards), or -1 if \a rx
+    was not found.
+
+    \warning If you want to apply this function repeatedly to the same
+    string it is more efficient to convert the string to a TQString and
+    apply the function to that.
+*/
+
+int TQCString::tqfindRev( const TQRegExp& rx, int index ) const
+{
+    TQString d = TQString::fromAscii( data() );
+    return d.tqfindRev( rx, index );
+}
+
+/*!
+    \overload
+
+    Counts the number of overlapping occurrences of \a rx in the string.
+
+    Example:
+    \code
+    TQString s = "banana and panama";
+    TQRegExp r = TQRegExp( "a[nm]a", TRUE, FALSE );
+    s.tqcontains( r ); // 4 matches
+    \endcode
+
+    \sa tqfind(), tqfindRev()
+
+    \warning If you want to apply this function repeatedly to the same
+    string it is more efficient to convert the string to a TQString and
+    apply the function to that.
+*/
+
+int TQCString::tqcontains( const TQRegExp &rx ) const
+{
+    TQString d = TQString::fromAscii( data() );
+    return d.tqcontains( rx );
+}
+
+
+/*!
+    \overload
+
+    Replaces every occurrence of \a rx in the string with \a str.
+    Returns a reference to the string.
+
+    Example:
+    \code
+    TQString s = "banana";
+    s.tqreplace( TQRegExp("a.*a"), "" );     // becomes "b"
+
+    s = "banana";
+    s.tqreplace( TQRegExp("^[bn]a"), "X" );  // becomes "Xnana"
+
+    s = "banana";
+    s.tqreplace( TQRegExp("^[bn]a"), "" );   // becomes "nana"
+    \endcode
+
+    \warning If you want to apply this function repeatedly to the same
+    string it is more efficient to convert the string to a TQString and
+    apply the function to that.
+*/
+
+TQCString &TQCString::tqreplace( const TQRegExp &rx, const char *str )
+{
+    TQString d = TQString::fromAscii( data() );
+    TQString r = TQString::fromAscii( str );
+    d.tqreplace( rx, r );
+    setStr( d.ascii() );
+    return *this;
+}
+#endif //TQT_NO_REGEXP
+
+/*!
+    Returns the string converted to a \c long value.
+
+    If \a ok is not 0: \a *ok is set to FALSE if the string is not a
+    number, or if it has trailing garbage; otherwise \a *ok is set to
+    TRUE.
+*/
+
+long TQCString::toLong( bool *ok ) const
+{
+    char *p = const_cast<char*>(data());
+    long val=0;
+    const long max_mult = LONG_MAX / 10;
+    bool is_ok = FALSE;
+    int neg = 0;
+    if ( !p )
+	goto bye;
+    while ( isspace((uchar) *p) )		// skip leading space
+	p++;
+    if ( *p == '-' ) {
+	p++;
+	neg = 1;
+    } else if ( *p == '+' ) {
+	p++;
+    }
+    if ( !isdigit((uchar) *p) )
+	goto bye;
+    while ( isdigit((uchar) *p) ) {
+	if ( val > max_mult || (val == max_mult && (*p-'0') > 7+neg) )
+	    goto bye;
+	val = 10*val + (*p++ - '0');
+    }
+    if ( neg )
+	val = -val;
+    while ( isspace((uchar) *p) )		// skip trailing space
+	p++;
+    if ( *p == '\0' )
+	is_ok = TRUE;
+bye:
+    if ( ok )
+	*ok = is_ok;
+    return is_ok ? val : 0;
+}
+
+/*!
+    Returns the string converted to an \c{unsigned long} value.
+
+    If \a ok is not 0: \a *ok is set to FALSE if the string is not a
+    number, or if it has trailing garbage; otherwise \a *ok is set to
+    TRUE.
+*/
+
+ulong TQCString::toULong( bool *ok ) const
+{
+    char *p = const_cast<char*>(data());
+    ulong val=0;
+    const ulong max_mult = ULONG_MAX / 10;
+    bool is_ok = FALSE;
+    if ( !p )
+	goto bye;
+    while ( isspace((uchar) *p) )		// skip leading space
+	p++;
+    if ( *p == '+' )
+	p++;
+    if ( !isdigit((uchar) *p) )
+	goto bye;
+    while ( isdigit((uchar) *p) ) {
+	if ( val > max_mult || (val == max_mult && (*p-'0') > 5) )
+	    goto bye;
+	val = 10*val + (*p++ - '0');
+    }
+    while ( isspace((uchar) *p) )		// skip trailing space
+	p++;
+    if ( *p == '\0' )
+	is_ok = TRUE;
+bye:
+    if ( ok )
+	*ok = is_ok;
+    return is_ok ? val : 0;
+}
+
+/*!
+    Returns the string converted to a \c{short} value.
+
+    If \a ok is not 0: \a *ok is set to FALSE if the string is not a
+    number, is out of range, or if it has trailing garbage; otherwise
+    \a *ok is set to TRUE.
+*/
+
+short TQCString::toShort( bool *ok ) const
+{
+    long v = toLong( ok );
+    if ( v < SHRT_MIN || v > SHRT_MAX ) {
+	if ( ok )
+	    *ok = FALSE;
+	v = 0;
+    }
+    return (short)v;
+}
+
+/*!
+    Returns the string converted to an \c{unsigned short} value.
+
+    If \a ok is not 0: \a *ok is set to FALSE if the string is not a
+    number, is out of range, or if it has trailing garbage; otherwise
+    \a *ok is set to TRUE.
+*/
+
+ushort TQCString::toUShort( bool *ok ) const
+{
+    ulong v = toULong( ok );
+    if ( v > USHRT_MAX ) {
+	if ( ok )
+	    *ok = FALSE;
+	v = 0;
+    }
+    return (ushort)v;
+}
+
+
+/*!
+    Returns the string converted to a \c{int} value.
+
+    If \a ok is not 0: \a *ok is set to FALSE if the string is not a
+    number, or if it has trailing garbage; otherwise \a *ok is set to
+    TRUE.
+*/
+
+int TQCString::toInt( bool *ok ) const
+{
+    long v = toLong( ok );
+    if ( v < INT_MIN || v > INT_MAX ) {
+	if ( ok )
+	    *ok = FALSE;
+	v = 0;
+    }
+    return (int)v;
+}
+
+/*!
+    Returns the string converted to an \c{unsigned int} value.
+
+    If \a ok is not 0: \a *ok is set to FALSE if the string is not a
+    number, or if it has trailing garbage; otherwise \a *ok is set to
+    TRUE.
+*/
+
+uint TQCString::toUInt( bool *ok ) const
+{
+    ulong v = toULong( ok );
+    if ( v > UINT_MAX ) {
+	if ( ok )
+	    *ok = FALSE;
+	v = 0;
+    }
+    return (uint)v;
+}
+
+/*!
+    Returns the string converted to a \c{double} value.
+
+    If \a ok is not 0: \a *ok is set to FALSE if the string is not a
+    number, or if it has trailing garbage; otherwise \a *ok is set to
+    TRUE.
+*/
+
+double TQCString::toDouble( bool *ok ) const
+{
+    char *end;
+    double val = strtod( data() ? data() : "", &end );
+    if ( ok )
+	*ok = ( data() && *data() && ( end == 0 || *end == '\0' ) );
+    return val;
+}
+
+/*!
+    Returns the string converted to a \c{float} value.
+
+    If \a ok is not 0: \a *ok is set to FALSE if the string is not a
+    number, or if it has trailing garbage; otherwise \a *ok is set to
+    TRUE.
+*/
+
+float TQCString::toFloat( bool *ok ) const
+{
+    return (float)toDouble( ok );
+}
+
+
+/*!
+    Makes a deep copy of \a str. Returns a reference to the string.
+*/
+
+TQCString &TQCString::setStr( const char *str )
+{
+    detach();
+    if ( str ) {				// valid string
+// 	store( str, tqstrlen(str)+1 );
+	int slen = tqstrlen(str)+1;
+	resize(slen);
+	memcpy(QByteArray::data(), str, slen);
+    }
+    else					// empty
+	resize( 0 );
+    return *this;
+}
+
+/*!
+    \overload
+
+    Sets the string to the string representation of the number \a n
+    and returns a reference to the string.
+*/
+
+TQCString &TQCString::setNum( long n )
+{
+    detach();
+    char buf[20];
+    register char *p = &buf[19];
+    bool neg;
+    if ( n < 0 ) {
+	neg = TRUE;
+	n = -n;
+    } else {
+	neg = FALSE;
+    }
+    *p = '\0';
+    do {
+	*--p = ((int)(n%10)) + '0';
+	n /= 10;
+    } while ( n );
+    if ( neg )
+	*--p = '-';
+//     store( p, tqstrlen(p)+1 );
+	int slen = tqstrlen(p)+1;
+	resize(slen);
+	memcpy(QByteArray::data(), p, slen);
+    return *this;
+}
+
+/*!
+    \overload
+
+    Sets the string to the string representation of the number \a n
+    and returns a reference to the string.
+*/
+
+TQCString &TQCString::setNum( ulong n )
+{
+    detach();
+    char buf[20];
+    register char *p = &buf[19];
+    *p = '\0';
+    do {
+	*--p = ((int)(n%10)) + '0';
+	n /= 10;
+    } while ( n );
+//     store( p, tqstrlen(p)+1 );
+	int slen = tqstrlen(p)+1;
+	resize(slen);
+	memcpy(QByteArray::data(), p, slen);
+    return *this;
+}
+
+/*!
+    \overload TQCString &TQCString::setNum( int n )
+
+    Sets the string to the string representation of the number \a n
+    and returns a reference to the string.
+*/
+
+/*!
+    \overload TQCString &TQCString::setNum( uint n )
+
+    Sets the string to the string representation of the number \a n
+    and returns a reference to the string.
+*/
+
+/*!
+    \overload TQCString &TQCString::setNum( short n )
+
+    Sets the string to the string representation of the number \a n
+    and returns a reference to the string.
+*/
+
+/*!
+    \overload TQCString &TQCString::setNum( ushort n )
+
+    Sets the string to the string representation of the number \a n
+    and returns a reference to the string.
+*/
+
+/*!
+    Sets the string to the string representation of the number \a n
+    and returns a reference to the string.
+
+    The format of the string representation is specified by the format
+    character \a f, and the precision (number of digits after the
+    decimal point) is specified with \a prec.
+
+    The valid formats for \a f are 'e', 'E', 'f', 'g' and 'G'. The
+    formats are the same as for sprintf(); they are explained in \l
+    TQString::arg().
+*/
+
+TQCString &TQCString::setNum( double n, char f, int prec )
+{
+#if defined(TQT_CHECK_RANGE)
+    if ( !(f=='f' || f=='F' || f=='e' || f=='E' || f=='g' || f=='G') )
+	qWarning( "TQCString::setNum: Invalid format char '%c'", f );
+#endif
+    char format[20];
+    register char *fs = format;			// generate format string
+    *fs++ = '%';				//   "%.<prec>l<f>"
+    if ( prec > 99 )
+	prec = 99;
+    *fs++ = '.';
+    if ( prec >= 10 ) {
+	*fs++ = prec / 10 + '0';
+	*fs++ = prec % 10 + '0';
+    } else {
+	*fs++ = prec + '0';
+    }
+    *fs++ = 'l';
+    *fs++ = f;
+    *fs = '\0';
+    return sprintf( format, n );
+}
+
+/*! \overload TQCString &TQCString::setNum( float n, char f, int prec ) */
+
+
+/*!
+    Sets the character at position \a index to \a c and expands the
+    string if necessary, padding with spaces.
+
+    Returns FALSE if \a index was out of range and the string could
+    not be expanded; otherwise returns TRUE.
+*/
+
+bool TQCString::setExpand( uint index, char c )
+{
+    detach();
+    uint oldlen = length();
+    if ( index >= oldlen ) {
+	if ( !TQByteArray::tqresize( index+2 ) )	// no memory
+	    return FALSE;
+	if ( index > oldlen )
+	    memset( data() + oldlen, ' ', index - oldlen );
+	*(data() + index+1) = '\0';		// terminate padded string
+    }
+    *(data() + index) = c;
+    return TRUE;
+}
+
+
+/*!
+    \fn TQCString::operator const char *() const
+
+    Returns the string data.
+*/
+
+
+/*!
+    \fn TQCString& TQCString::append( const char *str )
+
+    Appends string \a str to the string and returns a reference to the
+    string. Equivalent to operator+=().
+*/
+
+/*!
+    Appends string \a str to the string and returns a reference to the string.
+*/
+
+TQCString& TQCString::operator+=( const char *str )
+{
+    if ( !str )
+	return *this;				// nothing to append
+    detach();
+    uint len1 = length();
+    uint len2 = tqstrlen(str);
+    if ( !TQByteArray::tqresize( len1 + len2 + 1 ) )
+	return *this;				// no memory
+    memcpy( data() + len1, str, len2 + 1 );
+    return *this;
+}
+
+/*!
+    \overload
+
+    Appends character \a c to the string and returns a reference to the string.
+*/
+
+TQCString &TQCString::operator+=( char c )
+{
+    detach();
+    uint len = length();
+    if ( !TQByteArray::tqresize( len + 2  ) )
+	return *this;				// no memory
+    *(data() + len) = c;
+    *(data() + len+1) = '\0';
+    return *this;
+}
+
+TQCString& TQCString::operator+=( const QString qs )
+{
+	uint len2 = tqstrlen(QByteArray::constData());
+	TQByteArray::tqresize(len2);	// Get rid of the old null terminator
+	QByteArray tmp = qs.toAscii();
+	return append(tmp);
+}
+
+TQCString& TQCString::operator+=( const QByteArray qba )
+{
+	uint len2 = tqstrlen(QByteArray::constData());
+	TQByteArray::tqresize(len2);	// Get rid of the old null terminator
+	return append(qba);
+}
+
+TQCString& TQCString::operator+=( const TQCString tqcs ) {
+	return operator+=(tqcs.constData());
+}
+
+
+/*****************************************************************************
+  TQCString stream functions
+ *****************************************************************************/
+#ifndef TQT_NO_DATASTREAM
+/*!
+    \relates TQCString
+
+    Writes string \a str to the stream \a s.
+
+    \sa \link datastreamformat.html Format of the TQDataStream operators \endlink
+*/
+TQDataStream &operator<<( TQDataStream &s, const TQCString &str )
+{
+    return static_cast<TQDataStream&>(s.writeBytes( str.data(), str.size() ));
+}
+
+/*!
+    \relates TQCString
+
+    Reads a string into \a str from the stream \a s.
+
+    \sa \link datastreamformat.html Format of the TQDataStream operators \endlink
+*/
+
+TQDataStream &operator>>( TQDataStream &s, TQCString &str )
+{
+    str.detach();
+    TQ_UINT32 len;
+    s >> len;					// read size of string
+    if ( len == 0 || s.eof() ) {		// end of file reached
+	str.resize( 0 );
+	return s;
+    }
+    if ( !str.TQByteArray::tqresize( (uint)len )) {// resize string
+#if defined(TQT_CHECK_NULL)
+	qWarning( "TQDataStream: Not enough memory to read TQCString" );
+#endif
+	len = 0;
+    }
+    if ( len > 0 )				// not null array
+	s.readRawBytes( str.data(), (uint)len );
+    return s;
+}
+#endif //TQT_NO_DATASTREAM
+
+/*****************************************************************************
+  Documentation for related functions
+ *****************************************************************************/
+
+/*!
+    \fn bool operator==( const TQCString &s1, const TQCString &s2 )
+
+    \relates TQCString
+
+    Returns TRUE if \a s1 and \a s2 are equal; otherwise returns FALSE.
+
+    Equivalent to qstrcmp(\a s1, \a s2) == 0.
+*/
+
+/*!
+    \overload bool operator==( const TQCString &s1, const char *s2 )
+
+    \relates TQCString
+
+    Returns TRUE if \a s1 and \a s2 are equal; otherwise returns FALSE.
+
+    Equivalent to qstrcmp(\a s1, \a s2) == 0.
+*/
+
+/*!
+    \overload bool operator==( const char *s1, const TQCString &s2 )
+
+    \relates TQCString
+
+    Returns TRUE if \a s1 and \a s2 are equal; otherwise returns FALSE.
+
+    Equivalent to qstrcmp(\a s1, \a s2) == 0.
+*/
+
+/*!
+    \fn bool operator!=( const TQCString &s1, const TQCString &s2 )
+
+    \relates TQCString
+
+    Returns TRUE if \a s1 and \a s2 are different; otherwise returns FALSE.
+
+    Equivalent to qstrcmp(\a s1, \a s2) != 0.
+*/
+
+/*!
+    \overload bool operator!=( const TQCString &s1, const char *s2 )
+
+    \relates TQCString
+
+    Returns TRUE if \a s1 and \a s2 are different; otherwise returns FALSE.
+
+    Equivalent to qstrcmp(\a s1, \a s2) != 0.
+*/
+
+/*!
+    \overload bool operator!=( const char *s1, const TQCString &s2 )
+
+    \relates TQCString
+
+    Returns TRUE if \a s1 and \a s2 are different; otherwise returns FALSE.
+
+    Equivalent to qstrcmp(\a s1, \a s2) != 0.
+*/
+
+/*!
+    \fn bool operator<( const TQCString &s1, const char *s2 )
+
+    \relates TQCString
+
+    Returns TRUE if \a s1 is less than \a s2; otherwise returns FALSE.
+
+    Equivalent to qstrcmp(\a s1, \a s2) \< 0.
+
+    \sa \link #asciinotion Note on character comparisons \endlink
+*/
+
+/*!
+    \overload bool operator<( const char *s1, const TQCString &s2 )
+
+    \relates TQCString
+
+    Returns TRUE if \a s1 is less than \a s2; otherwise returns FALSE.
+
+    Equivalent to qstrcmp(\a s1, \a s2) \< 0.
+
+    \sa \link #asciinotion Note on character comparisons \endlink
+*/
+
+/*!
+    \fn bool operator<=( const TQCString &s1, const char *s2 )
+
+    \relates TQCString
+
+    Returns TRUE if \a s1 is less than or equal to \a s2; otherwise
+    returns FALSE.
+
+    Equivalent to qstrcmp(\a s1, \a s2) \<= 0.
+
+    \sa \link #asciinotion Note on character comparisons \endlink
+*/
+
+/*!
+    \overload bool operator<=( const char *s1, const TQCString &s2 )
+
+    \relates TQCString
+
+    Returns TRUE if \a s1 is less than or equal to \a s2; otherwise
+    returns FALSE.
+
+    Equivalent to qstrcmp(\a s1, \a s2) \<= 0.
+
+    \sa \link #asciinotion Note on character comparisons \endlink
+*/
+
+/*!
+    \fn bool operator>( const TQCString &s1, const char *s2 )
+
+    \relates TQCString
+
+    Returns TRUE if \a s1 is greater than \a s2; otherwise returns FALSE.
+
+    Equivalent to qstrcmp(\a s1, \a s2) \> 0.
+
+    \sa \link #asciinotion Note on character comparisons \endlink
+*/
+
+/*!
+    \overload bool operator>( const char *s1, const TQCString &s2 )
+
+    \relates TQCString
+
+    Returns TRUE if \a s1 is greater than \a s2; otherwise returns FALSE.
+
+    Equivalent to qstrcmp(\a s1, \a s2) \> 0.
+
+    \sa \link #asciinotion Note on character comparisons \endlink
+*/
+
+/*!
+    \fn bool operator>=( const TQCString &s1, const char *s2 )
+
+    \relates TQCString
+
+    Returns TRUE if \a s1 is greater than or equal to \a s2; otherwise
+    returns FALSE.
+
+    Equivalent to qstrcmp(\a s1, \a s2) \>= 0.
+
+    \sa \link #asciinotion Note on character comparisons \endlink
+*/
+
+/*!
+    \overload bool operator>=( const char *s1, const TQCString &s2 )
+
+    \relates TQCString
+
+    Returns TRUE if \a s1 is greater than or equal to \a s2; otherwise
+    returns FALSE.
+
+    Equivalent to qstrcmp(\a s1, \a s2) \>= 0.
+
+    \sa \link #asciinotion Note on character comparisons \endlink
+*/
+
+/*!
+    \fn const TQCString operator+( const TQCString &s1, const TQCString &s2 )
+
+    \relates TQCString
+
+    Returns a string which consists of the concatenation of \a s1 and
+    \a s2.
+*/
+
+/*!
+    \overload const TQCString operator+( const TQCString &s1, const char *s2 )
+
+    \relates TQCString
+
+    Returns a string which consists of the concatenation of \a s1 and \a s2.
+*/
+
+/*!
+    \overload const TQCString operator+( const char *s1, const TQCString &s2 )
+
+    \relates TQCString
+
+    Returns a string which consists of the concatenation of \a s1 and \a s2.
+*/
+
+/*!
+    \overload const TQCString operator+( const TQCString &s, char c )
+
+    \relates TQCString
+
+    Returns a string which consists of the concatenation of \a s and \a c.
+*/
+
+/*!
+    \overload const TQCString operator+( char c, const TQCString &s )
+
+    \relates TQCString
+
+    Returns a string which consists of the concatenation of \a c and \a s.
+*/
+
+#endif // USE_QT4
\ No newline at end of file
diff --git a/tqtinterface/qt4/src/tools/tqcstring.h b/tqtinterface/qt4/src/tools/tqcstring.h
new file mode 100644
index 0000000..8568713
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqcstring.h
@@ -0,0 +1,792 @@
+/****************************************************************************
+**
+** Definition of the extended char array operations,
+** and TQByteArray and TQCString classes
+**
+** Created : 920609
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQCSTRING_H
+#define TQCSTRING_H
+
+#include "tqtglobaldefines.h"
+
+#ifndef TQT_H
+#include "tqmemarray.h"
+#endif // TQT_H
+
+#include <string.h>
+
+#ifdef USE_QT4
+
+#include <Qt/qbytearray.h>
+#include <Qt/qregexp.h>
+#include <Qt/qstring.h>
+
+#endif // USE_QT4
+
+/*****************************************************************************
+  Safe and portable C string functions; extensions to standard string.h
+ *****************************************************************************/
+
+TQ_EXPORT void *tqmemmove( void *dst, const void *src, uint len );
+
+TQ_EXPORT char *tqstrdup( const char * );
+
+TQ_EXPORT inline uint tqstrlen( const char *str )
+{ return str ? (uint)strlen(str) : 0u; }
+
+TQ_EXPORT inline char *tqstrcpy( char *dst, const char *src )
+{ return src ? strcpy(dst, src) : 0; }
+
+TQ_EXPORT char *tqstrncpy( char *dst, const char *src, uint len );
+
+TQ_EXPORT inline int tqstrcmp( const char *str1, const char *str2 )
+{
+    return ( str1 && str2 ) ? strcmp( str1, str2 )
+			    : ( str1 ? 1 : ( str2 ? -1 : 0 ) );
+}
+
+TQ_EXPORT inline int tqstrncmp( const char *str1, const char *str2, uint len )
+{
+    return ( str1 && str2 ) ? strncmp( str1, str2, len )
+			    : ( str1 ? 1 : ( str2 ? -1 : 0 ) );
+}
+
+TQ_EXPORT int tqstricmp( const char *, const char * );
+
+TQ_EXPORT int tqstrnicmp( const char *, const char *, uint len );
+
+#ifndef TQT_CLEAN_NAMESPACE
+TQ_EXPORT inline uint cstrlen( const char *str )
+{ return (uint)strlen(str); }
+
+TQ_EXPORT inline char *cstrcpy( char *dst, const char *src )
+{ return strcpy(dst,src); }
+
+TQ_EXPORT inline int cstrcmp( const char *str1, const char *str2 )
+{ return strcmp(str1,str2); }
+
+TQ_EXPORT inline int cstrncmp( const char *str1, const char *str2, uint len )
+{ return strncmp(str1,str2,len); }
+#endif
+
+
+// qChecksum: Internet checksum
+
+TQ_EXPORT TQ_UINT16 qChecksum( const char *s, uint len );
+
+/*****************************************************************************
+  TQByteArray class
+ *****************************************************************************/
+
+#ifdef USE_QT4
+
+// NOTE: Qt4 uses implicit sharing
+// Qt3 used explicit sharing
+
+class TQ_EXPORT TQByteArray : public QByteArray
+{
+public:
+	TQByteArray() : QByteArray() {}
+	TQByteArray( int size ) : QByteArray( size, '\0' ) {}
+	~TQByteArray();
+
+	TQByteArray(const char *cs) : QByteArray( cs ) {}
+	TQByteArray(const char *cs, int size) : QByteArray( cs, size ) {}
+	TQByteArray(int size, char c) : QByteArray( size, c ) {}
+	TQByteArray(int size, Qt::Initialization init ) : QByteArray( size, init ) {}
+	TQByteArray(const TQByteArray &ba ) : QByteArray( ba/*.data(), ba.size()*/ ) {}
+	TQByteArray(const QByteArray &ba ) : QByteArray( ba/*.data(), ba.size()*/ ) {}
+
+	inline char *data() { if (isNull()) return 0; return QByteArray::data(); }
+	inline const char *data() const { if (isNull()) return 0; return QByteArray::data(); }
+	inline const char *constData() const { if (isNull()) return 0; return QByteArray::constData(); }
+
+	inline TQByteArray& assign( const TQByteArray& a ) { *this->operator=(a); return *this; }
+	inline TQByteArray& assign( const char *a, uint n ) { clear(); resize(n); insert(0, a, n); return *this; }
+	inline TQByteArray& duplicate(const TQByteArray& a) { *this = a; return *this; }
+	inline TQByteArray& duplicate(const char *a, uint n) { *this = TQByteArray(a, n); return *this; }
+	inline bool fill( char ch, int size = -1 ) { QByteArray::fill(ch, size); return TRUE; }
+	inline void resetRawData(const char *, uint) { clear(); }
+	inline QByteArray& setRawData(const char *a, uint n) { *this = fromRawData(a, n); return *this; }	// Yes, I know about the built-in Qt4 version of this function.  It is potentially unstable (corrupts memory) as of Qt4.7 and should not yet be used.  Reevaluate this at Qt4.8 or above. [FIXME]
+	inline QByteArray lower() const { return toLower(); }
+	inline QByteArray upper() const { return toUpper(); }
+	inline QByteArray stripWhiteSpace() const { return trimmed(); }
+	inline QByteArray simplifyWhiteSpace() const { return simplified(); }
+	inline int tqfind(int c, int from = 0) const { return indexOf(c, from); }
+	inline int tqfind(char c, int from = 0) const { return indexOf(c, from); }
+	inline int tqfind(const char *c, int from = 0) const { return indexOf(c, from); }
+	inline int tqfind(const QByteArray &ba, int from = 0) const { return indexOf(ba, from); }
+	inline int tqfindRev(char c, int from = -1) const { return lastIndexOf(c, from); }
+	inline int tqfindRev(const char *c, int from = -1) const { return lastIndexOf(c, from); }
+	inline int tqfindRev(const QByteArray &ba, int from = -1) const { return lastIndexOf(ba, from); }
+#ifndef QT_NO_CAST_TO_ASCII
+	inline int tqfind(const QString &s, int from = 0) const;
+	inline int tqfindRev(const QString &s, int from = -1) const;
+#endif
+	inline TQByteArray copy() const { return TQByteArray(*this); }
+	inline QByteRef tqat( int i ) {
+// #ifdef TQT_CHECK_RANGE
+		if ( (i >= size()) || (i < 0) ) {
+			qWarning( "TQByteArray::tqat: Absolute index %d out of range", i );
+			i = 0;
+		}
+// #endif
+		return QByteArray::operator[](i);
+	}
+	inline bool tqresize( uint newlen ) { resize(newlen); return true; }
+	inline bool tqresize( uint newlen, TQGArray::Optimization ) { resize(newlen); return true; }
+
+	inline char &operator[]( int i ) {
+// #ifdef TQT_CHECK_RANGE
+		if ( (i >= size()) || (i < 0) ) {
+			qWarning( "TQByteArray::operator[]: Absolute index %d out of range", i );
+			i = 0;
+		}
+// #endif
+		return *(this->data()+i);
+	}
+
+	using QByteArray::operator=;
+
+	// Interoperability
+// 	static const TQByteArray& convertFromQByteArray( QByteArray& qba );
+	static const TQByteArray convertFromQByteArray( QByteArray& qba );
+};
+
+// Interoperability
+// inline static const TQByteArray& convertFromQByteArray( const QByteArray& qba ) {
+// 	return (*static_cast<const TQByteArray*>(&qba));
+// }
+inline static const TQByteArray convertFromQByteArray( const QByteArray& qba ) {
+	return TQByteArray(qba);
+}
+
+#ifndef TQT_NO_COMPRESS
+TQ_EXPORT TQByteArray tqCompress( const uchar* data, int nbytes );
+TQ_EXPORT TQByteArray tqUncompress( const uchar* data, int nbytes );
+TQ_EXPORT inline TQByteArray tqCompress( const TQByteArray& data)
+{ return tqCompress( (const uchar*)data.data(), data.size() ); }
+TQ_EXPORT inline TQByteArray tqUncompress( const TQByteArray& data )
+{ return tqUncompress( (const uchar*)data.data(), data.size() ); }
+#endif
+
+/*****************************************************************************
+  TQByteArray stream functions
+ *****************************************************************************/
+#ifndef TQT_NO_DATASTREAM
+TQ_EXPORT TQDataStream &operator<<( TQDataStream &tqds, const TQByteArray &tqba );
+TQ_EXPORT TQDataStream &operator>>( TQDataStream &tqds, TQByteArray &tqba );
+#endif
+
+#else // USE_QT4
+
+#if defined(TQ_TQDOC)
+/*
+  We want qdoc to document TQByteArray as a real class that inherits
+  TQMemArray<char> and that is inherited by TQBitArray.
+*/
+class TQByteArray : public TQMemArray<char>
+{
+public:
+    TQByteArray();
+    TQByteArray( int size );
+};
+#else
+typedef TQMemArray<char> TQByteArray;
+#endif
+
+#ifndef TQT_NO_COMPRESS
+TQ_EXPORT TQByteArray tqCompress( const uchar* data, int nbytes );
+TQ_EXPORT TQByteArray tqUncompress( const uchar* data, int nbytes );
+TQ_EXPORT inline TQByteArray tqCompress( const TQByteArray& data)
+{ return tqCompress( (const uchar*)data.data(), data.size() ); }
+TQ_EXPORT inline TQByteArray tqUncompress( const TQByteArray& data )
+{ return tqUncompress( (const uchar*)data.data(), data.size() ); }
+#endif
+
+/*****************************************************************************
+  TQByteArray stream functions
+ *****************************************************************************/
+#ifndef TQT_NO_DATASTREAM
+TQ_EXPORT TQDataStream &operator<<( TQDataStream &, const TQByteArray & );
+TQ_EXPORT TQDataStream &operator>>( TQDataStream &, TQByteArray & );
+#endif
+
+#endif // USE_QT4
+
+/*****************************************************************************
+  TQCString class
+ *****************************************************************************/
+
+// #ifdef USE_QT4
+#if 0
+
+#include <QtCore/qbytearray.h>
+#include <QtCore/qdatastream.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Qt3SupportLight)
+
+/*****************************************************************************
+  QCString class
+ *****************************************************************************/
+
+class QRegExp;
+
+class TQCString : public TQByteArray
+{
+public:
+    TQCString() : TQByteArray() {}
+    TQCString(int size);
+    TQCString(const TQCString &s) : TQByteArray(s) {}
+    TQCString(const QByteArray &ba) : TQByteArray(ba.constData()) {}
+    TQCString(const char *str);
+    TQCString(const char *str, uint maxlen);
+
+    ~TQCString();
+
+    TQCString    &operator=(const TQCString &s);
+    TQCString    &operator=(const char *str);
+    TQCString    &operator=(const QByteArray &ba);
+
+    TQCString    copy()        const { return *this; }
+    TQCString    &sprintf(const char *format, ...);
+
+    TQCString    left(uint len)  const { return QByteArray::left(len); }
+    TQCString    right(uint len) const { return QByteArray::right(len); }
+    TQCString    mid(uint index, uint len=0xffffffff) const { return QByteArray::mid(index, len); }
+
+    TQCString    leftJustify(uint width, char fill=' ', bool trunc=false)const;
+    TQCString    rightJustify(uint width, char fill=' ',bool trunc=false)const;
+
+    TQCString    lower() const { return QByteArray::toLower(); }
+    TQCString    upper() const { return QByteArray::toUpper(); }
+
+    TQCString    stripWhiteSpace()        const { return QByteArray::trimmed(); }
+    TQCString    simplifyWhiteSpace()        const { return QByteArray::simplified(); }
+
+    uint         length() const;
+    bool         truncate( uint pos );
+
+    TQCString    &insert(uint index, const char *c) { QByteArray::insert(index, c); return *this; }
+    TQCString    &insert(uint index, char c) { QByteArray::insert(index, c); return *this; }
+    TQCString    &append(const char *c) { QByteArray::append(c); return *this; }
+    TQCString    &prepend(const char *c) { QByteArray::prepend(c); return *this; }
+    TQCString    &remove(uint index, uint len) { QByteArray::remove(index, len); return *this; }
+    TQCString    &tqreplace(uint index, uint len, const char *c)
+    { TQByteArray::replace(index, len, c); return *this; }
+    TQCString    &tqreplace(char c, const TQCString &after) { return tqreplace(c, after.constData()); }
+    TQCString    &tqreplace(char c, const char *after) { QByteArray::replace(c, after); return *this; }
+    TQCString    &tqreplace(const TQCString &b, const TQCString &a)
+    { return tqreplace(b.constData(), a.constData()); }
+    TQCString    &tqreplace(const char *b, const char *a) { QByteArray::replace(b, a); return *this; }
+    TQCString    &tqreplace(char b, char a) { QByteArray::replace(b, a); return *this; }
+
+    short        toShort(bool *ok=0)        const;
+    ushort        toUShort(bool *ok=0)        const;
+    int                toInt(bool *ok=0)        const;
+    uint        toUInt(bool *ok=0)        const;
+    long        toLong(bool *ok=0)        const;
+    ulong        toULong(bool *ok=0)        const;
+    float        toFloat(bool *ok=0)        const;
+    double        toDouble(bool *ok=0)        const;
+
+    TQCString    &setStr(const char *s) { *this = s; return *this; }
+    TQCString    &setNum(short);
+    TQCString    &setNum(ushort);
+    TQCString    &setNum(int);
+    TQCString    &setNum(uint);
+    TQCString    &setNum(long);
+    TQCString    &setNum(ulong);
+    TQCString    &setNum(float, char f='g', int prec=6);
+    TQCString    &setNum(double, char f='g', int prec=6);
+
+    bool        setExpand(uint index, char c);
+
+    int tqcontains( char c, bool cs=TRUE ) const;
+    int tqcontains( const char *str, bool cs=TRUE ) const;
+#ifndef TQT_NO_REGEXP
+    int tqcontains( const QRegExp & ) const;
+#endif
+
+    int tqfind( char c, int index=0, bool cs=TRUE ) const;
+    int tqfind( const char *str, int index=0, bool cs=TRUE ) const;
+#ifndef TQT_NO_REGEXP
+    int tqfind( const QRegExp &re, int index=0 ) const;
+#endif
+
+#ifndef TQT_NO_REGEXP
+    TQCString &tqreplace( const QRegExp &, const char * );
+#endif
+
+//     inline const char * tqstringFromPos( int index ) { const char & ref = (*this)[index]; return &ref; }
+    inline const char * tqstringFromPos( int index ) { return constData() + index; }
+
+    operator const char *() const;
+
+    TQCString &operator+=( const char *str );
+    TQCString &operator+=( char c );
+    TQCString &operator+=( const QString qs );
+    TQCString &operator+=( const QByteArray qba );
+    TQCString &operator+=( const TQCString tqcs );
+
+private:
+    int	tqfind( const char *str, int index, bool cs, uint l ) const;
+};
+
+inline TQCString::operator const char *() const
+{ return (const char *)data(); }
+
+/*****************************************************************************
+  TQCString stream functions
+ *****************************************************************************/
+#ifndef QT_NO_DATASTREAM
+QDataStream &operator<<(QDataStream &d, const TQCString &s);
+QDataStream &operator>>(QDataStream &d, TQCString &s);
+
+TQDataStream &operator<<(TQDataStream &d, const TQCString &s);
+TQDataStream &operator>>(TQDataStream &d, TQCString &s);
+#endif
+
+/*****************************************************************************
+  TQCString inline functions
+ *****************************************************************************/
+
+inline TQCString &TQCString::setNum(short n)
+{ return setNum(long(n)); }
+
+inline TQCString &TQCString::setNum(ushort n)
+{ return setNum(ulong(n)); }
+
+inline TQCString &TQCString::setNum(int n)
+{ return setNum(long(n)); }
+
+inline TQCString &TQCString::setNum(uint n)
+{ return setNum(ulong(n)); }
+
+inline TQCString &TQCString::setNum(float n, char f, int prec)
+{ return setNum(double(n),f,prec); }
+
+/*****************************************************************************
+  TQCString non-member operators
+ *****************************************************************************/
+
+Q_COMPAT_EXPORT inline bool operator==(const TQCString &s1, const TQCString &s2)
+{ return tqstrcmp(s1, s2) == 0; }
+
+Q_COMPAT_EXPORT inline bool operator==(const TQCString &s1, const char *s2)
+{ return tqstrcmp(s1, s2) == 0; }
+
+Q_COMPAT_EXPORT inline bool operator==(const char *s1, const TQCString &s2)
+{ return tqstrcmp(s1, s2) == 0; }
+
+Q_COMPAT_EXPORT inline bool operator!=(const TQCString &s1, const TQCString &s2)
+{ return tqstrcmp(s1, s2) != 0; }
+
+Q_COMPAT_EXPORT inline bool operator!=(const TQCString &s1, const char *s2)
+{ return tqstrcmp(s1, s2) != 0; }
+
+Q_COMPAT_EXPORT inline bool operator!=(const char *s1, const TQCString &s2)
+{ return tqstrcmp(s1, s2) != 0; }
+
+Q_COMPAT_EXPORT inline bool operator<(const TQCString &s1, const TQCString& s2)
+{ return tqstrcmp(s1, s2) < 0; }
+
+Q_COMPAT_EXPORT inline bool operator<(const TQCString &s1, const char *s2)
+{ return tqstrcmp(s1, s2) < 0; }
+
+Q_COMPAT_EXPORT inline bool operator<(const char *s1, const TQCString &s2)
+{ return tqstrcmp(s1, s2) < 0; }
+
+Q_COMPAT_EXPORT inline bool operator<=(const TQCString &s1, const TQCString &s2)
+{ return tqstrcmp(s1, s2) <= 0; }
+
+Q_COMPAT_EXPORT inline bool operator<=(const TQCString &s1, const char *s2)
+{ return tqstrcmp(s1, s2) <= 0; }
+
+Q_COMPAT_EXPORT inline bool operator<=(const char *s1, const TQCString &s2)
+{ return tqstrcmp(s1, s2) <= 0; }
+
+Q_COMPAT_EXPORT inline bool operator>(const TQCString &s1, const TQCString &s2)
+{ return tqstrcmp(s1, s2) > 0; }
+
+Q_COMPAT_EXPORT inline bool operator>(const TQCString &s1, const char *s2)
+{ return tqstrcmp(s1, s2) > 0; }
+
+Q_COMPAT_EXPORT inline bool operator>(const char *s1, const TQCString &s2)
+{ return tqstrcmp(s1, s2) > 0; }
+
+Q_COMPAT_EXPORT inline bool operator>=(const TQCString &s1, const TQCString& s2)
+{ return tqstrcmp(s1, s2) >= 0; }
+
+Q_COMPAT_EXPORT inline bool operator>=(const TQCString &s1, const char *s2)
+{ return tqstrcmp(s1, s2) >= 0; }
+
+Q_COMPAT_EXPORT inline bool operator>=(const char *s1, const TQCString &s2)
+{ return tqstrcmp(s1, s2) >= 0; }
+
+Q_COMPAT_EXPORT inline const TQCString operator+(const TQCString &s1,
+                                          const TQCString &s2)
+{
+    TQCString tmp(s1);
+    tmp += s2;
+    return tmp;
+}
+Q_COMPAT_EXPORT inline const TQCString operator+(const TQCString &s1,
+                                          const QByteArray &s2)
+{
+    QByteArray tmp(s1);
+    tmp += s2;
+    return tmp;
+}
+Q_COMPAT_EXPORT inline const TQCString operator+(const QByteArray &s1,
+                                          const TQCString &s2)
+{
+    QByteArray tmp(s1);
+    tmp += s2;
+    return tmp;
+}
+
+Q_COMPAT_EXPORT inline const TQCString operator+(const TQCString &s1, const char *s2)
+{
+    TQCString tmp(s1);
+    tmp += s2;
+    return tmp;
+}
+
+Q_COMPAT_EXPORT inline const TQCString operator+(const char *s1, const TQCString &s2)
+{
+    TQCString tmp(s1);
+    tmp += s2;
+    return tmp;
+}
+
+Q_COMPAT_EXPORT inline const TQCString operator+(const TQCString &s1, char c2)
+{
+    TQCString tmp(s1);
+    tmp += c2;
+    return tmp;
+}
+
+Q_COMPAT_EXPORT inline const TQCString operator+(char c1, const TQCString &s2)
+{
+    TQCString tmp;
+    tmp += c1;
+    tmp += s2;
+    return tmp;
+}
+
+inline uint TQCString::length() const
+{
+	return tqstrlen( data() );
+}
+
+inline bool TQCString::truncate( uint pos )
+{
+	return tqresize(pos+1);
+}
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#else // USE_QT4
+
+class TQRegExp;
+
+class TQ_EXPORT TQCString : public TQByteArray	// C string class
+{
+public:
+    TQCString() {}				// make null string
+    TQCString( int size );			// allocate size incl. \0
+    TQCString( const TQCString &s ) : TQByteArray( s ) {}
+    TQCString( const QByteArray ba ) : TQByteArray( ba ) {}
+    TQCString( const char *str );		// deep copy
+    TQCString( const char *str, uint maxlen );	// deep copy, max length
+    ~TQCString();
+
+    TQCString    &operator=( const TQCString &s );// shallow copy
+    TQCString    &operator=( const char *str );	// deep copy
+    TQCString    &operator=(const QByteArray &ba);
+
+    bool	isNull()	const;
+    bool	isEmpty()	const;
+    uint	length()	const;
+    bool	resize( uint newlen ) { return tqresize(newlen); }
+    bool	tqresize( uint newlen );
+    bool	truncate( uint pos );
+    bool	fill( char c, int len = -1 );
+
+    TQCString	copy()	const;
+
+    TQCString    &sprintf( const char *format, ... );
+
+    int		tqfind( char c, int index=0, bool cs=TRUE ) const;
+    int		tqfind( const char *str, int index=0, bool cs=TRUE ) const;
+#ifndef TQT_NO_REGEXP
+    int		tqfind( const TQRegExp &, int index=0 ) const;
+#endif
+    int		tqfindRev( char c, int index=-1, bool cs=TRUE) const;
+    int		tqfindRev( const char *str, int index=-1, bool cs=TRUE) const;
+#ifndef TQT_NO_REGEXP_CAPTURE
+    int		tqfindRev( const TQRegExp &, int index=-1 ) const;
+#endif
+    int		tqcontains( char c, bool cs=TRUE ) const;
+    int		tqcontains( const char *str, bool cs=TRUE ) const;
+#ifndef TQT_NO_REGEXP
+    int		tqcontains( const TQRegExp & ) const;
+#endif
+    TQCString	left( uint len )  const;
+    TQCString	right( uint len ) const;
+    TQCString	mid( uint index, uint len=0xffffffff) const;
+
+    TQCString	leftJustify( uint width, char fill=' ', bool trunc=FALSE)const;
+    TQCString	rightJustify( uint width, char fill=' ',bool trunc=FALSE)const;
+
+    TQCString	lower() const;
+    TQCString	upper() const;
+
+    TQCString	stripWhiteSpace()	const;
+    TQCString	simplifyWhiteSpace()	const;
+
+    TQCString    &insert( uint index, const char * );
+    TQCString    &insert( uint index, char );
+    TQCString    &append( const char * );
+    TQCString    &prepend( const char * );
+    TQCString    &remove( uint index, uint len );
+    TQCString    &tqreplace( uint index, uint len, const char * );
+#ifndef TQT_NO_REGEXP
+    TQCString    &tqreplace( const TQRegExp &, const char * );
+#endif
+    TQCString    &tqreplace( char c, const char *after );
+    TQCString    &tqreplace( const char *, const char * );
+    TQCString    &tqreplace( char, char );
+
+    short	toShort( bool *ok=0 )	const;
+    ushort	toUShort( bool *ok=0 )	const;
+    int		toInt( bool *ok=0 )	const;
+    uint	toUInt( bool *ok=0 )	const;
+    long	toLong( bool *ok=0 )	const;
+    ulong	toULong( bool *ok=0 )	const;
+    float	toFloat( bool *ok=0 )	const;
+    double	toDouble( bool *ok=0 )	const;
+
+    TQCString    &setStr( const char *s );
+    TQCString    &setNum( short );
+    TQCString    &setNum( ushort );
+    TQCString    &setNum( int );
+    TQCString    &setNum( uint );
+    TQCString    &setNum( long );
+    TQCString    &setNum( ulong );
+    TQCString    &setNum( float, char f='g', int prec=6 );
+    TQCString    &setNum( double, char f='g', int prec=6 );
+
+    inline const char * tqstringFromPos( int index ) { return constData() + index; }
+
+    bool	setExpand( uint index, char c );
+
+		operator const char *() const;
+    TQCString    &operator+=( const char *str );
+    TQCString    &operator+=( char c );
+    TQCString &operator+=( const QString qs );
+    TQCString &operator+=( const QByteArray qba );
+    TQCString &operator+=( const TQCString tqcs );
+private:
+    int	tqfind( const char *str, int index, bool cs, uint l ) const;
+};
+
+/*****************************************************************************
+  TQCString stream functions
+ *****************************************************************************/
+#ifndef TQT_NO_DATASTREAM
+TQ_EXPORT TQDataStream &operator<<( TQDataStream &, const TQCString & );
+TQ_EXPORT TQDataStream &operator>>( TQDataStream &, TQCString & );
+#endif
+
+/*****************************************************************************
+  TQCString inline functions
+ *****************************************************************************/
+
+inline TQCString &TQCString::operator=( const TQCString &s )
+{ return (TQCString&)assign( s ); }
+
+inline TQCString &TQCString::operator=( const char *str )
+{ return (TQCString&)duplicate( str, tqstrlen(str)+1 ); }
+
+inline bool TQCString::isNull() const
+{ return data() == 0; }
+
+inline bool TQCString::isEmpty() const
+{ return data() == 0 || *data() == '\0'; }
+
+inline uint TQCString::length() const
+{ return tqstrlen( data() ); }
+
+inline bool TQCString::truncate( uint pos )
+{ return resize(pos+1); }
+
+inline TQCString TQCString::copy() const
+{ return TQCString( data() ); }
+
+inline TQCString &TQCString::prepend( const char *s )
+{ return insert(0,s); }
+
+inline TQCString &TQCString::append( const char *s )
+{ return operator+=(s); }
+
+inline TQCString &TQCString::setNum( short n )
+{ return setNum((long)n); }
+
+inline TQCString &TQCString::setNum( ushort n )
+{ return setNum((ulong)n); }
+
+inline TQCString &TQCString::setNum( int n )
+{ return setNum((long)n); }
+
+inline TQCString &TQCString::setNum( uint n )
+{ return setNum((ulong)n); }
+
+inline TQCString &TQCString::setNum( float n, char f, int prec )
+{ return setNum((double)n,f,prec); }
+
+inline TQCString::operator const char *() const
+{ return (const char *)data(); }
+
+
+/*****************************************************************************
+  TQCString non-member operators
+ *****************************************************************************/
+
+TQ_EXPORT inline bool operator==( const TQCString &s1, const TQCString &s2 )
+{ return tqstrcmp( s1.data(), s2.data() ) == 0; }
+
+TQ_EXPORT inline bool operator==( const TQCString &s1, const char *s2 )
+{ return tqstrcmp( s1.data(), s2 ) == 0; }
+
+TQ_EXPORT inline bool operator==( const char *s1, const TQCString &s2 )
+{ return tqstrcmp( s1, s2.data() ) == 0; }
+
+TQ_EXPORT inline bool operator!=( const TQCString &s1, const TQCString &s2 )
+{ return tqstrcmp( s1.data(), s2.data() ) != 0; }
+
+TQ_EXPORT inline bool operator!=( const TQCString &s1, const char *s2 )
+{ return tqstrcmp( s1.data(), s2 ) != 0; }
+
+TQ_EXPORT inline bool operator!=( const char *s1, const TQCString &s2 )
+{ return tqstrcmp( s1, s2.data() ) != 0; }
+
+TQ_EXPORT inline bool operator<( const TQCString &s1, const TQCString& s2 )
+{ return tqstrcmp( s1.data(), s2.data() ) < 0; }
+
+TQ_EXPORT inline bool operator<( const TQCString &s1, const char *s2 )
+{ return tqstrcmp( s1.data(), s2 ) < 0; }
+
+TQ_EXPORT inline bool operator<( const char *s1, const TQCString &s2 )
+{ return tqstrcmp( s1, s2.data() ) < 0; }
+
+TQ_EXPORT inline bool operator<=( const TQCString &s1, const TQCString &s2 )
+{ return tqstrcmp( s1.data(), s2.data() ) <= 0; }
+
+TQ_EXPORT inline bool operator<=( const TQCString &s1, const char *s2 )
+{ return tqstrcmp( s1.data(), s2 ) <= 0; }
+
+TQ_EXPORT inline bool operator<=( const char *s1, const TQCString &s2 )
+{ return tqstrcmp( s1, s2.data() ) <= 0; }
+
+TQ_EXPORT inline bool operator>( const TQCString &s1, const TQCString &s2 )
+{ return tqstrcmp( s1.data(), s2.data() ) > 0; }
+
+TQ_EXPORT inline bool operator>( const TQCString &s1, const char *s2 )
+{ return tqstrcmp( s1.data(), s2 ) > 0; }
+
+TQ_EXPORT inline bool operator>( const char *s1, const TQCString &s2 )
+{ return tqstrcmp( s1, s2.data() ) > 0; }
+
+TQ_EXPORT inline bool operator>=( const TQCString &s1, const TQCString& s2 )
+{ return tqstrcmp( s1.data(), s2.data() ) >= 0; }
+
+TQ_EXPORT inline bool operator>=( const TQCString &s1, const char *s2 )
+{ return tqstrcmp( s1.data(), s2 ) >= 0; }
+
+TQ_EXPORT inline bool operator>=( const char *s1, const TQCString &s2 )
+{ return tqstrcmp( s1, s2.data() ) >= 0; }
+
+TQ_EXPORT inline const TQCString operator+( const TQCString &s1,
+					  const TQCString &s2 )
+{
+    TQCString tmp( s1.data() );
+    tmp += static_cast<const char *>(s2);
+    return tmp;
+}
+
+TQ_EXPORT inline const TQCString operator+( const TQCString &s1, const char *s2 )
+{
+    TQCString tmp( s1.data() );
+    tmp += s2;
+    return tmp;
+}
+
+TQ_EXPORT inline const TQCString operator+( const char *s1, const TQCString &s2 )
+{
+    TQCString tmp( s1 );
+    tmp += static_cast<const char *>(s2);
+    return tmp;
+}
+
+TQ_EXPORT inline const TQCString operator+( const TQCString &s1, char c2 )
+{
+    TQCString tmp( s1.data() );
+    tmp += c2;
+    return tmp;
+}
+
+TQ_EXPORT inline const TQCString operator+( char c1, const TQCString &s2 )
+{
+    TQCString tmp;
+    tmp += c1;
+    tmp += static_cast<const char *>(s2);
+    return tmp;
+}
+#include "tqwinexport.h"
+
+#endif // USE_QT4
+
+#endif // TQCSTRING_H
diff --git a/tqtinterface/qt4/src/tools/tqdatastream.cpp b/tqtinterface/qt4/src/tools/tqdatastream.cpp
new file mode 100644
index 0000000..bf9955a
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqdatastream.cpp
@@ -0,0 +1,1176 @@
+/****************************************************************************
+**
+** Implementation of TQDataStream class
+**
+** Created : 930831
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "tqdatastream.h"
+
+#ifndef TQT_NO_DATASTREAM
+#include "tqbuffer.h"
+#include <stdio.h>
+#include <ctype.h>
+#include <stdlib.h>
+#ifndef TQ_OS_TEMP
+#include <locale.h>
+#else
+#include "tqt_windows.h"
+#endif
+
+#ifdef USE_QT4
+
+#else // USE_QT4
+
+/*!
+    \class TQDataStream tqdatastream.h
+    \reentrant
+    \brief The TQDataStream class provides serialization of binary data
+    to a TQIODevice.
+
+    \ingroup io
+
+    A data stream is a binary stream of encoded information which is
+    100% independent of the host computer's operating system, CPU or
+    byte order. For example, a data stream that is written by a PC
+    under Windows can be read by a Sun SPARC running Solaris.
+
+    You can also use a data stream to read/write \link #raw raw
+    unencoded binary data\endlink. If you want a "parsing" input
+    stream, see TQTextStream.
+
+    The TQDataStream class implements the serialization of C++'s basic
+    data types, like \c char, \c short, \c int, \c char*, etc.
+    Serialization of more complex data is accomplished by breaking up
+    the data into primitive units.
+
+    A data stream cooperates closely with a TQIODevice. A TQIODevice
+    represents an input/output medium one can read data from and write
+    data to. The TQFile class is an example of an IO tqdevice.
+
+    Example (write binary data to a stream):
+    \code
+    TQFile file( "file.dat" );
+    file.open( IO_WriteOnly );
+    TQDataStream stream( &file ); // we will serialize the data into the file
+    stream << "the answer is";   // serialize a string
+    stream << (TQ_INT32)42;       // serialize an integer
+    \endcode
+
+    Example (read binary data from a stream):
+    \code
+    TQFile file( "file.dat" );
+    file.open( IO_ReadOnly );
+    TQDataStream stream( &file );  // read the data serialized from the file
+    TQString str;
+    TQ_INT32 a;
+    stream >> str >> a;           // extract "the answer is" and 42
+    \endcode
+
+    Each item written to the stream is written in a predefined binary
+    format that varies depending on the item's type. Supported TQt
+    types include TQBrush, TQColor, TQDateTime, TQFont, TQPixmap, TQString,
+    TQVariant and many others. For the complete list of all TQt types
+    supporting data streaming see the \link datastreamformat.html
+    Format of the TQDataStream operators \endlink.
+
+    For integers it is best to always cast to a TQt integer type for
+    writing, and to read back into the same TQt integer type. This
+    ensures that you get integers of the size you want and insulates
+    you from compiler and platform differences.
+
+    To take one example, a \c char* string is written as a 32-bit
+    integer equal to the length of the string including the NUL byte
+    ('\0'), followed by all the characters of the string including the
+    NUL byte. When reading a \c char* string, 4 bytes are read to
+    create the 32-bit length value, then that many characters for the
+    \c char* string including the NUL are read.
+
+    The initial IODevice is usually set in the constructor, but can be
+    changed with setDevice(). If you've reached the end of the data
+    (or if there is no IODevice set) atEnd() will return TRUE.
+
+    If you want the data to be compatible with an earlier version of
+    TQt use setVersion().
+
+    If you want the data to be human-readable, e.g. for debugging, you
+    can set the data stream into printable data mode with
+    setPrintableData(). The data is then written slower, in a bloated
+    but human readable format.
+
+    If you are producing a new binary data format, such as a file
+    format for documents created by your application, you could use a
+    TQDataStream to write the data in a portable format. Typically, you
+    would write a brief header containing a magic string and a version
+    number to give yourself room for future expansion. For example:
+
+    \code
+    TQFile file( "file.xxx" );
+    file.open( IO_WriteOnly );
+    TQDataStream stream( &file );
+
+    // Write a header with a "magic number" and a version
+    stream << (TQ_UINT32)0xA0B0C0D0;
+    stream << (TQ_INT32)123;
+
+    // Write the data
+    stream << [lots of interesting data]
+    \endcode
+
+    Then read it in with:
+
+    \code
+    TQFile file( "file.xxx" );
+    file.open( IO_ReadOnly );
+    TQDataStream stream( &file );
+
+    // Read and check the header
+    TQ_UINT32 magic;
+    stream >> magic;
+    if ( magic != 0xA0B0C0D0 )
+	return XXX_BAD_FILE_FORMAT;
+
+    // Read the version
+    TQ_INT32 version;
+    stream >> version;
+    if ( version < 100 )
+	return XXX_BAD_FILE_TOO_OLD;
+    if ( version > 123 )
+	return XXX_BAD_FILE_TOO_NEW;
+    if ( version <= 110 )
+	stream.setVersion(1);
+
+    // Read the data
+    stream >> [lots of interesting data];
+    if ( version > 120 )
+	stream >> [data new in XXX version 1.2];
+    stream >> [other interesting data];
+    \endcode
+
+    You can select which byte order to use when serializing data. The
+    default setting is big endian (MSB first). Changing it to little
+    endian breaks the portability (unless the reader also changes to
+    little endian). We recommend keeping this setting unless you have
+    special requirements.
+
+    \target raw
+    \section1 Reading and writing raw binary data
+
+    You may wish to read/write your own raw binary data to/from the
+    data stream directly. Data may be read from the stream into a
+    preallocated char* using readRawBytes(). Similarly data can be
+    written to the stream using writeRawBytes(). Notice that any
+    encoding/decoding of the data must be done by you.
+
+    A similar pair of functions is readBytes() and writeBytes(). These
+    differ from their \e raw counterparts as follows: readBytes()
+    reads a TQ_UINT32 which is taken to be the length of the data to be
+    read, then that number of bytes is read into the preallocated
+    char*; writeBytes() writes a TQ_UINT32 containing the length of the
+    data, followed by the data. Notice that any encoding/decoding of
+    the data (apart from the length TQ_UINT32) must be done by you.
+
+    \sa TQTextStream TQVariant
+*/
+
+/*!
+    \enum TQDataStream::ByteOrder
+
+    The byte order used for reading/writing the data.
+
+    \value BigEndian the default
+    \value LittleEndian
+*/
+
+
+/*****************************************************************************
+  TQDataStream member functions
+ *****************************************************************************/
+
+#if defined(TQT_CHECK_STATE)
+#undef  CHECK_STREAM_PRECOND
+#define CHECK_STREAM_PRECOND  if ( !dev ) {				\
+				qWarning( "TQDataStream: No tqdevice" );	\
+				return *this; }
+#else
+#define CHECK_STREAM_PRECOND
+#endif
+
+static int  systemWordSize = 0;
+static bool systemBigEndian;
+
+static const int DefaultStreamVersion = 6;
+// ### On next version bump, TQPen::width() should not be restricted to 8-bit values.
+// ### On next version bump, when streaming invalid TQVariants, just the type should
+// be written, no "data" after it
+// 6 is default in TQt 3.3
+// 5 is default in TQt 3.1
+// 4 is default in TQt 3.0
+// 3 is default in TQt 2.1
+// 2 is the TQt 2.0.x format
+// 1 is the TQt 1.x format
+
+/*!
+    Constructs a data stream that has no IO tqdevice.
+
+    \sa setDevice()
+*/
+
+TQDataStream::TQDataStream()
+{
+    if ( systemWordSize == 0 )			// get system features
+	qSysInfo( &systemWordSize, &systemBigEndian );
+    dev	      = 0;				// no tqdevice set
+    owndev    = FALSE;
+    byteorder = BigEndian;			// default byte order
+    printable = FALSE;
+    ver	      = DefaultStreamVersion;
+    noswap    = systemBigEndian;
+}
+
+/*!
+    Constructs a data stream that uses the IO tqdevice \a d.
+
+    \warning If you use TQSocket or TQSocketDevice as the IO tqdevice \a d
+    for reading data, you must make sure that enough data is available
+    on the socket for the operation to successfully proceed;
+    TQDataStream does not have any means to handle or recover from
+    short-reads.
+
+    \sa setDevice(), tqdevice()
+*/
+
+TQDataStream::TQDataStream( TQIODevice *d )
+{
+    if ( systemWordSize == 0 )			// get system features
+	qSysInfo( &systemWordSize, &systemBigEndian );
+    dev	      = d;				// set tqdevice
+    owndev    = FALSE;
+    byteorder = BigEndian;			// default byte order
+    printable = FALSE;
+    ver	      = DefaultStreamVersion;
+    noswap    = systemBigEndian;
+}
+
+/*!
+    Constructs a data stream that operates on a byte array, \a a,
+    through an internal TQBuffer tqdevice. The \a mode is a
+    TQIODevice::mode(), usually either \c IO_ReadOnly or \c
+    IO_WriteOnly.
+
+    Example:
+    \code
+    static char bindata[] = { 231, 1, 44, ... };
+    TQByteArray a;
+    a.setRawData( bindata, sizeof(bindata) );	// a points to bindata
+    TQDataStream stream( a, IO_ReadOnly );	// open on a's data
+    stream >> [something];			// read raw bindata
+    a.resetRawData( bindata, sizeof(bindata) ); // finished
+    \endcode
+
+    The TQByteArray::setRawData() function is not for the inexperienced.
+*/
+
+TQDataStream::TQDataStream( TQByteArray a, int mode )
+{
+    if ( systemWordSize == 0 )			// get system features
+	qSysInfo( &systemWordSize, &systemBigEndian );
+    dev	      = new TQBuffer( a );		// create tqdevice
+    ((TQBuffer *)dev)->open( mode );		// open tqdevice
+    owndev    = TRUE;
+    byteorder = BigEndian;			// default byte order
+    printable = FALSE;
+    ver	      = DefaultStreamVersion;
+    noswap    = systemBigEndian;
+}
+
+/*!
+    Destroys the data stream.
+
+    The destructor will not affect the current IO tqdevice, unless it is
+    an internal IO tqdevice processing a TQByteArray passed in the \e
+    constructor, in which case the internal IO tqdevice is destroyed.
+*/
+
+TQDataStream::~TQDataStream()
+{
+    if ( owndev )
+	delete dev;
+}
+
+
+/*!
+    \fn TQIODevice *TQDataStream::tqdevice() const
+
+    Returns the IO tqdevice currently set.
+
+    \sa setDevice(), unsetDevice()
+*/
+
+/*!
+    void TQDataStream::setDevice(TQIODevice *d )
+
+    Sets the IO tqdevice to \a d.
+
+    \sa tqdevice(), unsetDevice()
+*/
+
+void TQDataStream::setDevice(TQIODevice *d )
+{
+    if ( owndev ) {
+	delete dev;
+	owndev = FALSE;
+    }
+    dev = d;
+}
+
+/*!
+    Unsets the IO tqdevice. This is the same as calling setDevice( 0 ).
+
+    \sa tqdevice(), setDevice()
+*/
+
+void TQDataStream::unsetDevice()
+{
+    setDevice( 0 );
+}
+
+
+/*!
+    \fn bool TQDataStream::atEnd() const
+
+    Returns TRUE if the IO tqdevice has reached the end position (end of
+    the stream or file) or if there is no IO tqdevice set; otherwise
+    returns FALSE, i.e. if the current position of the IO tqdevice is
+    before the end position.
+
+    \sa TQIODevice::atEnd()
+*/
+
+/*!\fn bool TQDataStream::eof() const
+
+  \obsolete
+
+  Returns TRUE if the IO tqdevice has reached the end position (end of
+  stream or file) or if there is no IO tqdevice set.
+
+  Returns FALSE if the current position of the read/write head of the IO
+  tqdevice is somewhere before the end position.
+
+  \sa TQIODevice::atEnd()
+*/
+
+/*!
+    \fn int TQDataStream::byteOrder() const
+
+    Returns the current byte order setting -- either \c BigEndian or
+    \c LittleEndian.
+
+    \sa setByteOrder()
+*/
+
+/*!
+    Sets the serialization byte order to \a bo.
+
+    The \a bo parameter can be \c TQDataStream::BigEndian or \c
+    TQDataStream::LittleEndian.
+
+    The default setting is big endian. We recommend leaving this
+    setting unless you have special requirements.
+
+    \sa byteOrder()
+*/
+
+void TQDataStream::setByteOrder( int bo )
+{
+    byteorder = bo;
+    if ( systemBigEndian )
+	noswap = byteorder == BigEndian;
+    else
+	noswap = byteorder == LittleEndian;
+}
+
+
+/*!
+    \fn bool TQDataStream::isPrintableData() const
+
+    Returns TRUE if the printable data flag has been set; otherwise
+    returns FALSE.
+
+    \sa setPrintableData()
+*/
+
+/*!
+    \fn void TQDataStream::setPrintableData( bool enable )
+
+    If \a enable is TRUE, data will be output in a human readable
+    format. If \a enable is FALSE, data will be output in a binary
+    format.
+
+    If \a enable is TRUE, the write functions will generate output
+    that consists of printable characters (7 bit ASCII). This output
+    will typically be a lot larger than the default binary output, and
+    consequently slower to write.
+
+    We recommend only enabling printable data for debugging purposes.
+*/
+
+
+/*!
+    \fn int TQDataStream::version() const
+
+    Returns the version number of the data serialization format. In TQt
+    3.1, this number is 5.
+
+    \sa setVersion()
+*/
+
+/*!
+    \fn void TQDataStream::setVersion( int v )
+
+    Sets the version number of the data serialization format to \a v.
+
+    You don't need to set a version if you are using the current
+    version of TQt.
+
+    In order to accommodate new functionality, the datastream
+    serialization format of some TQt classes has changed in some
+    versions of TQt. If you want to read data that was created by an
+    earlier version of TQt, or write data that can be read by a program
+    that was compiled with an earlier version of TQt, use this function
+    to modify the serialization format of TQDataStream.
+
+    \table
+    \header \i TQt Version         \i TQDataStream Version
+    \row \i TQt 3.3                \i11 6
+    \row \i TQt 3.2                \i11 5
+    \row \i TQt 3.1                \i11 5
+    \row \i TQt 3.0                \i11 4
+    \row \i TQt 2.1.x and TQt 2.2.x \i11 3
+    \row \i TQt 2.0.x              \i11 2
+    \row \i TQt 1.x                \i11 1
+    \endtable
+
+    \sa version()
+*/
+
+/*****************************************************************************
+  TQDataStream read functions
+ *****************************************************************************/
+
+#if defined(TQ_OS_HPUX) && !defined(__LP64__)
+extern "C" long long __strtoll( const char *, char**, int );
+#endif
+
+static TQ_INT64 read_int_ascii( TQDataStream *s )
+{
+    register int n = 0;
+    char buf[40];
+    for ( ;; ) {
+	buf[n] = s->tqdevice()->getch();
+	if ( buf[n] == '\n' || n > 38 )		// $-terminator
+	    break;
+	n++;
+    }
+    buf[n] = '\0';
+
+#if defined(__LP64__) || defined(TQ_OS_OSF)
+    // sizeof(long) == 8
+    return strtol(buf, (char **)0, 10);
+#else
+#  if defined(TQ_OS_TEMP)
+    return strtol( buf, (char**)0, 10 );
+#  elif defined(TQ_OS_WIN)
+    return _atoi64( buf );
+#  elif defined(TQ_OS_HPUX)
+    return __strtoll( buf, (char**)0, 10 );
+#  elif defined(TQ_OS_MACX) && defined(TQT_MACOSX_VERSION) && TQT_MACOSX_VERSION < 0x1020
+    return strtoq( buf, (char**)0, 10 );
+#  else
+    return strtoll( buf, (char**)0, 10 );	// C99 function
+#  endif
+#endif
+}
+
+/*!
+    \overload TQDataStream &TQDataStream::operator>>( TQ_UINT8 &i )
+
+    Reads an unsigned byte from the stream into \a i, and returns a
+    reference to the stream.
+*/
+
+/*!
+    Reads a signed byte from the stream into \a i, and returns a
+    reference to the stream.
+*/
+
+TQDataStream &TQDataStream::operator>>( TQ_INT8 &i )
+{
+    CHECK_STREAM_PRECOND
+    if ( printable ) {				// printable data
+	i = (TQ_INT8)dev->getch();
+	if ( i == '\\' ) {			// read octal code
+	    char buf[4];
+	    dev->readBlock( buf, 3 );
+	    i = (buf[2] & 0x07)+((buf[1] & 0x07) << 3)+((buf[0] & 0x07) << 6);
+	}
+    } else {					// data or text
+	i = (TQ_INT8)dev->getch();
+    }
+    return *this;
+}
+
+
+/*!
+    \overload TQDataStream &TQDataStream::operator>>( TQ_UINT16 &i )
+
+    Reads an unsigned 16-bit integer from the stream into \a i, and
+    returns a reference to the stream.
+*/
+
+/*!
+    \overload
+
+    Reads a signed 16-bit integer from the stream into \a i, and
+    returns a reference to the stream.
+*/
+
+TQDataStream &TQDataStream::operator>>( TQ_INT16 &i )
+{
+    CHECK_STREAM_PRECOND
+    if ( printable ) {				// printable data
+	i = (TQ_INT16)read_int_ascii( this );
+    } else if ( noswap ) {			// no conversion needed
+	dev->readBlock( (char *)&i, sizeof(TQ_INT16) );
+    } else {					// swap bytes
+	register uchar *p = (uchar *)(&i);
+	char b[2];
+	dev->readBlock( b, 2 );
+	*p++ = b[1];
+	*p   = b[0];
+    }
+    return *this;
+}
+
+
+/*!
+    \overload TQDataStream &TQDataStream::operator>>( TQ_UINT32 &i )
+
+    Reads an unsigned 32-bit integer from the stream into \a i, and
+    returns a reference to the stream.
+*/
+
+/*!
+    \overload
+
+    Reads a signed 32-bit integer from the stream into \a i, and
+    returns a reference to the stream.
+*/
+
+TQDataStream &TQDataStream::operator>>( TQ_INT32 &i )
+{
+    CHECK_STREAM_PRECOND
+    if ( printable ) {				// printable data
+	i = (TQ_INT32)read_int_ascii( this );
+    } else if ( noswap ) {			// no conversion needed
+	dev->readBlock( (char *)&i, sizeof(TQ_INT32) );
+    } else {					// swap bytes
+	uchar *p = (uchar *)(&i);
+	char b[4];
+	dev->readBlock( b, 4 );
+	*p++ = b[3];
+	*p++ = b[2];
+	*p++ = b[1];
+	*p   = b[0];
+    }
+    return *this;
+}
+
+/*!
+    \overload TQDataStream &TQDataStream::operator>>( TQ_UINT64 &i )
+
+    Reads an unsigned 64-bit integer from the stream, into \a i, and
+    returns a reference to the stream.
+*/
+
+/*!
+    \overload
+
+    Reads a signed 64-bit integer from the stream into \a i, and
+    returns a reference to the stream.
+*/
+
+TQDataStream &TQDataStream::operator>>( TQ_INT64 &i )
+{
+    CHECK_STREAM_PRECOND
+    if ( printable ) {				// printable data
+	i = read_int_ascii( this );
+    } else if ( version() < 6 ) {
+	TQ_UINT32 i1, i2;
+	*this >> i2 >> i1;
+	i = ((TQ_UINT64)i1 << 32) + i2;
+    } else if ( noswap ) {			// no conversion needed
+	dev->readBlock( (char *)&i, sizeof(TQ_INT64) );
+    } else {					// swap bytes
+	uchar *p = (uchar *)(&i);
+	char b[8];
+	dev->readBlock( b, 8 );
+	*p++ = b[7];
+	*p++ = b[6];
+	*p++ = b[5];
+	*p++ = b[4];
+	*p++ = b[3];
+	*p++ = b[2];
+	*p++ = b[1];
+	*p   = b[0];
+    }
+    return *this;
+}
+
+
+/*!
+    \overload TQDataStream &TQDataStream::operator>>( TQ_ULONG &i )
+
+    Reads an unsigned integer of the system's word length from the
+    stream, into \a i, and returns a reference to the stream.
+*/
+
+#if !defined(TQ_OS_WIN64)
+/*!
+    \overload
+
+    Reads a signed integer of the system's word length from the stream
+    into \a i, and returns a reference to the stream.
+
+*/
+
+TQDataStream &TQDataStream::operator>>( TQ_LONG &i )
+{
+    CHECK_STREAM_PRECOND
+    if ( printable ) {				// printable data
+	i = (TQ_LONG)read_int_ascii( this );
+    } else if ( noswap ) {			// no conversion needed
+	dev->readBlock( (char *)&i, sizeof(TQ_LONG) );
+    } else {					// swap bytes
+	register uchar *p = (uchar *)(&i);
+	char b[sizeof(TQ_LONG)];
+	dev->readBlock( b, sizeof(TQ_LONG) );
+	for ( int j = sizeof(TQ_LONG); j;  )
+	    *p++ = b[--j];
+    }
+    return *this;
+}
+#endif
+
+static double read_double_ascii( TQDataStream *s )
+{
+    register int n = 0;
+    char buf[80];
+    for ( ;; ) {
+	buf[n] = s->tqdevice()->getch();
+	if ( buf[n] == '\n' || n > 78 )		// $-terminator
+	    break;
+	n++;
+    }
+    buf[n] = '\0';
+    return atof( buf );
+}
+
+
+/*!
+    \overload
+
+    Reads a 32-bit floating point number from the stream into \a f,
+    using the standard IEEE754 format. Returns a reference to the
+    stream.
+*/
+
+TQDataStream &TQDataStream::operator>>( float &f )
+{
+    CHECK_STREAM_PRECOND
+    if ( printable ) {				// printable data
+	f = (float)read_double_ascii( this );
+    } else if ( noswap ) {			// no conversion needed
+	dev->readBlock( (char *)&f, sizeof(float) );
+    } else {					// swap bytes
+	uchar *p = (uchar *)(&f);
+	char b[4];
+	dev->readBlock( b, 4 );
+	*p++ = b[3];
+	*p++ = b[2];
+	*p++ = b[1];
+	*p   = b[0];
+    }
+    return *this;
+}
+
+
+/*!
+    \overload
+
+    Reads a 64-bit floating point number from the stream into \a f,
+    using the standard IEEE754 format. Returns a reference to the
+    stream.
+*/
+
+TQDataStream &TQDataStream::operator>>( double &f )
+{
+    CHECK_STREAM_PRECOND
+    if ( printable ) {				// printable data
+	f = read_double_ascii( this );
+    } else if ( noswap ) {			// no conversion needed
+	dev->readBlock( (char *)&f, sizeof(double) );
+    } else {					// swap bytes
+	register uchar *p = (uchar *)(&f);
+	char b[8];
+	dev->readBlock( b, 8 );
+	*p++ = b[7];
+	*p++ = b[6];
+	*p++ = b[5];
+	*p++ = b[4];
+	*p++ = b[3];
+	*p++ = b[2];
+	*p++ = b[1];
+	*p   = b[0];
+    }
+    return *this;
+}
+
+
+/*!
+    \overload
+
+    Reads the '\0'-terminated string \a s from the stream and returns
+    a reference to the stream.
+
+    Space for the string is allocated using \c new -- the caller must
+    destroy it with delete[].
+*/
+
+TQDataStream &TQDataStream::operator>>( char *&s )
+{
+    uint len = 0;
+    return readBytes( s, len );
+}
+
+
+/*!
+    Reads the buffer \a s from the stream and returns a reference to
+    the stream.
+
+    The buffer \a s is allocated using \c new. Destroy it with the \c
+    delete[] operator. If the length is zero or \a s cannot be
+    allocated, \a s is set to 0.
+
+    The \a l parameter will be set to the length of the buffer.
+
+    The serialization format is a TQ_UINT32 length specifier first,
+    then \a l bytes of data. Note that the data is \e not encoded.
+
+    \sa readRawBytes(), writeBytes()
+*/
+
+TQDataStream &TQDataStream::readBytes( char *&s, uint &l )
+{
+    CHECK_STREAM_PRECOND
+    TQ_UINT32 len;
+    *this >> len;				// first read length spec
+    l = (uint)len;
+    if ( len == 0 || eof() ) {
+	s = 0;
+	return *this;
+    } else {
+	s = new char[len];			// create char array
+	TQ_CHECK_PTR( s );
+	if ( !s )				// no memory
+	    return *this;
+	return readRawBytes( s, (uint)len );
+    }
+}
+
+
+/*!
+    Reads \a len bytes from the stream into \a s and returns a
+    reference to the stream.
+
+    The buffer \a s must be preallocated. The data is \e not encoded.
+
+    \sa readBytes(), TQIODevice::readBlock(), writeRawBytes()
+*/
+
+TQDataStream &TQDataStream::readRawBytes( char *s, uint len )
+{
+    CHECK_STREAM_PRECOND
+    if ( printable ) {				// printable data
+	register TQ_INT8 *p = (TQ_INT8*)s;
+	if ( version() < 4 ) {
+	    while ( len-- ) {
+		TQ_INT32 tmp;
+		*this >> tmp;
+		*p++ = tmp;
+	    }
+	} else {
+	    while ( len-- )
+		*this >> *p++;
+	}
+    } else {					// read data char array
+	dev->readBlock( s, len );
+    }
+    return *this;
+}
+
+
+/*****************************************************************************
+  TQDataStream write functions
+ *****************************************************************************/
+
+
+/*!
+    \overload TQDataStream &TQDataStream::operator<<( TQ_UINT8 i )
+
+    Writes an unsigned byte, \a i, to the stream and returns a
+    reference to the stream.
+*/
+
+/*!
+    Writes a signed byte, \a i, to the stream and returns a reference
+    to the stream.
+*/
+
+TQDataStream &TQDataStream::operator<<( TQ_INT8 i )
+{
+    CHECK_STREAM_PRECOND
+    if ( printable && (i == '\\' || !isprint((uchar) i)) ) {
+	char buf[6];				// write octal code
+	buf[0] = '\\';
+	buf[1] = '0' + ((i >> 6) & 0x07);
+	buf[2] = '0' + ((i >> 3) & 0x07);
+	buf[3] = '0' + (i & 0x07);
+	buf[4] = '\0';
+	dev->writeBlock( buf, 4 );
+    } else {
+	dev->putch( i );
+    }
+    return *this;
+}
+
+
+/*!
+    \overload TQDataStream &TQDataStream::operator<<( TQ_UINT16 i )
+
+    Writes an unsigned 16-bit integer, \a i, to the stream and returns
+    a reference to the stream.
+*/
+
+/*!
+    \overload
+
+    Writes a signed 16-bit integer, \a i, to the stream and returns a
+    reference to the stream.
+*/
+
+TQDataStream &TQDataStream::operator<<( TQ_INT16 i )
+{
+    CHECK_STREAM_PRECOND
+    if ( printable ) {				// printable data
+	char buf[16];
+	sprintf( buf, "%d\n", i );
+	dev->writeBlock( buf, strlen(buf) );
+    } else if ( noswap ) {			// no conversion needed
+	dev->writeBlock( (char *)&i, sizeof(TQ_INT16) );
+    } else {					// swap bytes
+	register uchar *p = (uchar *)(&i);
+	char b[2];
+	b[1] = *p++;
+	b[0] = *p;
+	dev->writeBlock( b, 2 );
+    }
+    return *this;
+}
+
+/*!
+    \overload
+
+    Writes a signed 32-bit integer, \a i, to the stream and returns a
+    reference to the stream.
+*/
+
+TQDataStream &TQDataStream::operator<<( TQ_INT32 i )
+{
+    CHECK_STREAM_PRECOND
+    if ( printable ) {				// printable data
+	char buf[16];
+	sprintf( buf, "%d\n", i );
+	dev->writeBlock( buf, strlen(buf) );
+    } else if ( noswap ) {			// no conversion needed
+	dev->writeBlock( (char *)&i, sizeof(TQ_INT32) );
+    } else {					// swap bytes
+	register uchar *p = (uchar *)(&i);
+	char b[4];
+	b[3] = *p++;
+	b[2] = *p++;
+	b[1] = *p++;
+	b[0] = *p;
+	dev->writeBlock( b, 4 );
+    }
+    return *this;
+}
+
+/*!
+    \overload TQDataStream &TQDataStream::operator<<( TQ_UINT64 i )
+
+    Writes an unsigned 64-bit integer, \a i, to the stream and returns a
+    reference to the stream.
+*/
+
+/*!
+    \overload
+
+    Writes a signed 64-bit integer, \a i, to the stream and returns a
+    reference to the stream.
+*/
+
+TQDataStream &TQDataStream::operator<<( TQ_INT64 i )
+{
+    CHECK_STREAM_PRECOND
+    if ( printable ) {				// printable data
+	char buf[16];
+#ifdef TQ_OS_WIN
+	sprintf( buf, "%I64d\n", i );
+#else
+	sprintf( buf, "%lld\n", i );
+#endif
+	dev->writeBlock( buf, strlen(buf) );
+    } else if ( version() < 6 ) {
+	TQ_UINT32 i1 = i & 0xffffffff;
+	TQ_UINT32 i2 = i >> 32;
+	*this << i2 << i1;
+    } else if ( noswap ) {			// no conversion needed
+	dev->writeBlock( (char *)&i, sizeof(TQ_INT64) );
+    } else {					// swap bytes
+	register uchar *p = (uchar *)(&i);
+	char b[8];
+	b[7] = *p++;
+	b[6] = *p++;
+	b[5] = *p++;
+	b[4] = *p++;
+	b[3] = *p++;
+	b[2] = *p++;
+	b[1] = *p++;
+	b[0] = *p;
+	dev->writeBlock( b, 8 );
+    }
+    return *this;
+}
+
+/*!
+    \overload TQDataStream &TQDataStream::operator<<( TQ_ULONG i )
+
+    Writes an unsigned integer \a i, of the system's word length, to
+    the stream and returns a reference to the stream.
+*/
+
+#if !defined(TQ_OS_WIN64)
+/*!
+    \overload
+
+    Writes a signed integer \a i, of the system's word length, to the
+    stream and returns a reference to the stream.
+*/
+
+TQDataStream &TQDataStream::operator<<( TQ_LONG i )
+{
+    CHECK_STREAM_PRECOND
+    if ( printable ) {				// printable data
+	char buf[20];
+	sprintf( buf, "%ld\n", i );
+	dev->writeBlock( buf, strlen(buf) );
+    } else if ( noswap ) {			// no conversion needed
+	dev->writeBlock( (char *)&i, sizeof(TQ_LONG) );
+    } else {					// swap bytes
+	register uchar *p = (uchar *)(&i);
+	char b[sizeof(TQ_LONG)];
+	for ( int j = sizeof(TQ_LONG); j;  )
+	    b[--j] = *p++;
+	dev->writeBlock( b, sizeof(TQ_LONG) );
+    }
+    return *this;
+}
+#endif
+
+
+/*!
+    \overload TQDataStream &TQDataStream::operator<<( TQ_UINT32 i )
+
+    Writes an unsigned integer, \a i, to the stream as a 32-bit
+    unsigned integer (TQ_UINT32). Returns a reference to the stream.
+*/
+
+/*!
+    \overload
+
+    Writes a 32-bit floating point number, \a f, to the stream using
+    the standard IEEE754 format. Returns a reference to the stream.
+*/
+
+TQDataStream &TQDataStream::operator<<( float f )
+{
+    CHECK_STREAM_PRECOND
+    if ( printable ) {				// printable data
+	TQString num = TQString::number((double)f);
+	dev->writeBlock(num.latin1(), num.length());
+	dev->putch('\n');
+    } else {
+	float g = f;				// fixes float-on-stack problem
+	if ( noswap ) {				// no conversion needed
+	    dev->writeBlock( (char *)&g, sizeof(float) );
+	} else {				// swap bytes
+	    register uchar *p = (uchar *)(&g);
+	    char b[4];
+	    b[3] = *p++;
+	    b[2] = *p++;
+	    b[1] = *p++;
+	    b[0] = *p;
+	    dev->writeBlock( b, 4 );
+	}
+    }
+    return *this;
+}
+
+
+/*!
+    \overload
+
+    Writes a 64-bit floating point number, \a f, to the stream using
+    the standard IEEE754 format. Returns a reference to the stream.
+*/
+
+TQDataStream &TQDataStream::operator<<( double f )
+{
+    CHECK_STREAM_PRECOND
+    if ( printable ) {				// printable data
+	TQString num = TQString::number((double)f);
+	dev->writeBlock(num.latin1(), num.length());
+	dev->putch('\n');
+    } else if ( noswap ) {			// no conversion needed
+	dev->writeBlock( (char *)&f, sizeof(double) );
+    } else {					// swap bytes
+	register uchar *p = (uchar *)(&f);
+	char b[8];
+	b[7] = *p++;
+	b[6] = *p++;
+	b[5] = *p++;
+	b[4] = *p++;
+	b[3] = *p++;
+	b[2] = *p++;
+	b[1] = *p++;
+	b[0] = *p;
+	dev->writeBlock( b, 8 );
+    }
+    return *this;
+}
+
+
+/*!
+    \overload
+
+    Writes the '\0'-terminated string \a s to the stream and returns a
+    reference to the stream.
+
+    The string is serialized using writeBytes().
+*/
+
+TQDataStream &TQDataStream::operator<<( const char *s )
+{
+    if ( !s ) {
+	*this << (TQ_UINT32)0;
+	return *this;
+    }
+    uint len = tqstrlen( s ) + 1;			// also write null terminator
+    *this << (TQ_UINT32)len;			// write length specifier
+    return writeRawBytes( s, len );
+}
+
+
+/*!
+    Writes the length specifier \a len and the buffer \a s to the
+    stream and returns a reference to the stream.
+
+    The \a len is serialized as a TQ_UINT32, followed by \a len bytes
+    from \a s. Note that the data is \e not encoded.
+
+    \sa writeRawBytes(), readBytes()
+*/
+
+TQDataStream &TQDataStream::writeBytes(const char *s, uint len)
+{
+    CHECK_STREAM_PRECOND
+    *this << (TQ_UINT32)len;			// write length specifier
+    if ( len )
+	writeRawBytes( s, len );
+    return *this;
+}
+
+
+/*!
+    Writes \a len bytes from \a s to the stream and returns a
+    reference to the stream. The data is \e not encoded.
+
+    \sa writeBytes(), TQIODevice::writeBlock(), readRawBytes()
+*/
+
+TQDataStream &TQDataStream::writeRawBytes( const char *s, uint len )
+{
+    CHECK_STREAM_PRECOND
+    if ( printable ) {				// write printable
+	if ( version() < 4 ) {
+	    register char *p = (char *)s;
+	    while ( len-- )
+		*this << *p++;
+	} else {
+	    register TQ_INT8 *p = (TQ_INT8*)s;
+	    while ( len-- )
+		*this << *p++;
+	}
+    } else {					// write data char array
+	dev->writeBlock( s, len );
+    }
+    return *this;
+}
+
+#endif // TQT_NO_DATASTREAM
+
+#endif // USE_QT4
diff --git a/tqtinterface/qt4/src/tools/tqdatastream.h b/tqtinterface/qt4/src/tools/tqdatastream.h
new file mode 100644
index 0000000..f47847f
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqdatastream.h
@@ -0,0 +1,353 @@
+/****************************************************************************
+**
+** Definition of TQDataStream class
+**
+** Created : 930831
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQDATASTREAM_H
+#define TQDATASTREAM_H
+
+#include "tqtglobaldefines.h"
+
+#ifndef TQT_H
+#include "tqiodevice.h"
+#include "tqstring.h"
+#endif // TQT_H
+
+#ifdef USE_QT4
+
+#include <Qt/qdatastream.h>
+
+#endif // USE_QT4
+
+#ifdef USE_QT4
+class TQ_EXPORT TQDataStream : public QDataStream
+{
+public:
+	TQDataStream() : QDataStream() {}
+	TQDataStream( QIODevice * tio ) : QDataStream( tio ) {}
+	TQDataStream( QByteArray &ba, int mode ) : QDataStream( &ba, (QIODevice::OpenModeFlag)mode ) {}
+	TQDataStream( TQByteArray &ba, int mode ) : QDataStream( &ba, (QIODevice::OpenModeFlag)mode ) {}
+// 	TQDataStream( const TQByteArray &ba, int mode ) : QDataStream( &const_cast<TQByteArray&>(ba), (QIODevice::OpenModeFlag)mode ) {}
+	TQDataStream( const TQByteArray &ba, int mode ) : QDataStream( static_cast<const QByteArray&>(ba) ) { TQ_UNUSED(mode); }
+// 	TQDataStream( const QByteArray &ba, int mode ) : QDataStream( ba ) { TQ_UNUSED(mode); }
+	inline QDataStream &readRawBytes(char *str, uint len) { readRawData(str, static_cast<int>(len)); return *this; }
+	inline QDataStream &writeRawBytes(const char *str, uint len) { writeRawData(str, static_cast<int>(len)); return *this; }
+	inline bool isPrintableData() const { return false; }
+	inline void setPrintableData(bool) {}
+	inline TQIODevice *tqdevice() const { return static_cast<TQIODevice*>(device()); }
+	inline bool eof() const { return atEnd(); }
+
+	TQDataStream &operator>>( TQ_INT8 &i );
+	TQDataStream &operator>>( TQ_UINT8 &i );
+	TQDataStream &operator>>( TQ_INT16 &i );
+	TQDataStream &operator>>( TQ_UINT16 &i );
+	TQDataStream &operator>>( TQ_INT32 &i );
+	TQDataStream &operator>>( TQ_UINT32 &i );
+	TQDataStream &operator>>( TQ_INT64 &i );
+	TQDataStream &operator>>( TQ_UINT64 &i );
+#if !defined(TQ_OS_WIN64)
+	TQDataStream &operator>>( TQ_LONG &i );
+	TQDataStream &operator>>( TQ_ULONG &i );
+#endif
+	
+	TQDataStream &operator>>( float &f );
+	TQDataStream &operator>>( double &f );
+	TQDataStream &operator>>( char *&str );
+
+	TQDataStream &operator>>( bool &i );
+	
+	TQDataStream &operator<<( TQ_INT8 i );
+	TQDataStream &operator<<( TQ_UINT8 i );
+	TQDataStream &operator<<( TQ_INT16 i );
+	TQDataStream &operator<<( TQ_UINT16 i );
+	TQDataStream &operator<<( TQ_INT32 i );
+	TQDataStream &operator<<( TQ_UINT32 i );
+	TQDataStream &operator<<( TQ_INT64 i );
+	TQDataStream &operator<<( TQ_UINT64 i );
+#if !defined(TQ_OS_WIN64)
+	TQDataStream &operator<<( TQ_LONG i );
+	TQDataStream &operator<<( TQ_ULONG i );
+#endif
+	TQDataStream &operator<<( float f );
+	TQDataStream &operator<<( double f );
+	TQDataStream &operator<<( const char *str );
+
+	TQDataStream &operator<<( bool i );
+};
+
+inline TQDataStream &TQDataStream::operator>>( bool &i )
+{ return static_cast<TQDataStream&>(this->QDataStream::operator>>((bool&)i)); }
+
+inline TQDataStream &TQDataStream::operator>>( float &f )
+{ return static_cast<TQDataStream&>(this->QDataStream::operator>>((float&)f)); }
+
+inline TQDataStream &TQDataStream::operator>>( double &d )
+{ return static_cast<TQDataStream&>(this->QDataStream::operator>>((double&)d)); }
+
+inline TQDataStream &TQDataStream::operator>>( char *&str )
+{ return static_cast<TQDataStream&>(this->QDataStream::operator>>((char*&)str)); }
+
+inline TQDataStream &TQDataStream::operator>>( TQ_INT8 &i )
+{ return static_cast<TQDataStream&>(this->QDataStream::operator>>((TQ_INT8&)i)); }
+
+inline TQDataStream &TQDataStream::operator>>( TQ_INT16 &i )
+{ return static_cast<TQDataStream&>(this->QDataStream::operator>>((TQ_INT16&)i)); }
+
+inline TQDataStream &TQDataStream::operator>>( TQ_INT32 &i )
+{ return static_cast<TQDataStream&>(this->QDataStream::operator>>((TQ_INT32&)i)); }
+
+inline TQDataStream &TQDataStream::operator>>( TQ_INT64 &i )
+{ return static_cast<TQDataStream&>(this->QDataStream::operator>>((TQ_INT64&)i)); }
+
+#if !defined(TQ_OS_WIN64)
+inline TQDataStream &TQDataStream::operator>>( TQ_LONG &i )
+{ return static_cast<TQDataStream&>(this->QDataStream::operator>>((qint64&)i)); }
+#endif
+
+inline TQDataStream &TQDataStream::operator>>( TQ_UINT8 &i )
+{ return static_cast<TQDataStream&>(this->QDataStream::operator>>((TQ_INT8&)i)); }
+
+inline TQDataStream &TQDataStream::operator>>( TQ_UINT16 &i )
+{ return static_cast<TQDataStream&>(this->QDataStream::operator>>((TQ_INT16&)i)); }
+
+inline TQDataStream &TQDataStream::operator>>( TQ_UINT32 &i )
+{ return static_cast<TQDataStream&>(this->QDataStream::operator>>((TQ_INT32&)i)); }
+
+inline TQDataStream &TQDataStream::operator>>( TQ_UINT64 &i )
+{ return static_cast<TQDataStream&>(this->QDataStream::operator>>((TQ_INT64&)i)); }
+
+#if !defined(TQ_OS_WIN64)
+inline TQDataStream &TQDataStream::operator>>( TQ_ULONG &i )
+{ return static_cast<TQDataStream&>(this->QDataStream::operator>>((quint64&)i)); }
+#endif
+
+inline TQDataStream &TQDataStream::operator<<( bool i )
+{ return static_cast<TQDataStream&>(this->QDataStream::operator<<((bool)i)); }
+
+inline TQDataStream &TQDataStream::operator<<( float f )
+{ return static_cast<TQDataStream&>(this->QDataStream::operator<<((float)f)); }
+
+inline TQDataStream &TQDataStream::operator<<( double d )
+{ return static_cast<TQDataStream&>(this->QDataStream::operator<<((double)d)); }
+
+inline TQDataStream &TQDataStream::operator<<( const char *str )
+{ return static_cast<TQDataStream&>(this->QDataStream::operator<<((const char*)str)); }
+
+inline TQDataStream &TQDataStream::operator<<( TQ_INT8 i )
+{ return static_cast<TQDataStream&>(this->QDataStream::operator<<((TQ_INT8)i)); }
+
+inline TQDataStream &TQDataStream::operator<<( TQ_INT16 i )
+{ return static_cast<TQDataStream&>(this->QDataStream::operator<<((TQ_INT16)i)); }
+
+inline TQDataStream &TQDataStream::operator<<( TQ_INT32 i )
+{ return static_cast<TQDataStream&>(this->QDataStream::operator<<((TQ_INT32)i)); }
+
+inline TQDataStream &TQDataStream::operator<<( TQ_INT64 i )
+{ return static_cast<TQDataStream&>(this->QDataStream::operator<<((TQ_INT64)i)); }
+
+#if !defined(TQ_OS_WIN64)
+inline TQDataStream &TQDataStream::operator<<( TQ_LONG i )
+{ return static_cast<TQDataStream&>(this->QDataStream::operator<<((qint64)i)); }
+#endif
+
+inline TQDataStream &TQDataStream::operator<<( TQ_UINT8 i )
+{ return static_cast<TQDataStream&>(this->QDataStream::operator<<((TQ_INT8)i)); }
+
+inline TQDataStream &TQDataStream::operator<<( TQ_UINT16 i )
+{ return static_cast<TQDataStream&>(this->QDataStream::operator<<((TQ_INT16)i)); }
+
+inline TQDataStream &TQDataStream::operator<<( TQ_UINT32 i )
+{ return static_cast<TQDataStream&>(this->QDataStream::operator<<((TQ_INT32)i)); }
+
+inline TQDataStream &TQDataStream::operator<<( TQ_UINT64 i )
+{ return static_cast<TQDataStream&>(this->QDataStream::operator<<((TQ_INT64)i)); }
+
+#if !defined(TQ_OS_WIN64)
+inline TQDataStream &TQDataStream::operator<<( TQ_ULONG i )
+{ return static_cast<TQDataStream&>(this->QDataStream::operator<<((quint64)i)); }
+#endif
+
+#else // USE_QT4
+
+#ifndef TQT_NO_DATASTREAM
+class TQ_EXPORT TQDataStream				// data stream class
+{
+public:
+    TQDataStream();
+    TQDataStream( TQIODevice * );
+    TQDataStream( TQByteArray, int mode );
+    virtual ~TQDataStream();
+
+    TQIODevice	*tqdevice() const;
+    void	 setDevice( TQIODevice * );
+    void	 unsetDevice();
+
+    bool	 atEnd() const;
+    bool	 eof() const;
+
+    enum ByteOrder { BigEndian, LittleEndian };
+    int		 byteOrder()	const;
+    void	 setByteOrder( int );
+
+    bool	 isPrintableData() const;
+    void	 setPrintableData( bool );
+
+    int		 version() const;
+    void	 setVersion( int );
+
+    TQDataStream &operator>>( TQ_INT8 &i );
+    TQDataStream &operator>>( TQ_UINT8 &i );
+    TQDataStream &operator>>( TQ_INT16 &i );
+    TQDataStream &operator>>( TQ_UINT16 &i );
+    TQDataStream &operator>>( TQ_INT32 &i );
+    TQDataStream &operator>>( TQ_UINT32 &i );
+    TQDataStream &operator>>( TQ_INT64 &i );
+    TQDataStream &operator>>( TQ_UINT64 &i );
+#if !defined(TQ_OS_WIN64)
+    TQDataStream &operator>>( TQ_LONG &i );
+    TQDataStream &operator>>( TQ_ULONG &i );
+#endif
+
+    TQDataStream &operator>>( float &f );
+    TQDataStream &operator>>( double &f );
+    TQDataStream &operator>>( char *&str );
+
+    TQDataStream &operator<<( TQ_INT8 i );
+    TQDataStream &operator<<( TQ_UINT8 i );
+    TQDataStream &operator<<( TQ_INT16 i );
+    TQDataStream &operator<<( TQ_UINT16 i );
+    TQDataStream &operator<<( TQ_INT32 i );
+    TQDataStream &operator<<( TQ_UINT32 i );
+    TQDataStream &operator<<( TQ_INT64 i );
+    TQDataStream &operator<<( TQ_UINT64 i );
+#if !defined(TQ_OS_WIN64)
+    TQDataStream &operator<<( TQ_LONG i );
+    TQDataStream &operator<<( TQ_ULONG i );
+#endif
+    TQDataStream &operator<<( float f );
+    TQDataStream &operator<<( double f );
+    TQDataStream &operator<<( const char *str );
+
+    TQDataStream &readBytes( char *&, uint &len );
+    TQDataStream &readRawBytes( char *, uint len );
+
+    TQDataStream &writeBytes( const char *, uint len );
+    TQDataStream &writeRawBytes( const char *, uint len );
+
+private:
+    TQIODevice	*dev;
+    bool	 owndev;
+    int		 byteorder;
+    bool	 printable;
+    bool	 noswap;
+    int		 ver;
+
+private:	// Disabled copy constructor and operator=
+#if defined(TQ_DISABLE_COPY)
+    TQDataStream( const TQDataStream & );
+    TQDataStream &operator=( const TQDataStream & );
+#endif
+};
+
+
+/*****************************************************************************
+  TQDataStream inline functions
+ *****************************************************************************/
+
+inline TQIODevice *TQDataStream::tqdevice() const
+{ return dev; }
+
+inline bool TQDataStream::atEnd() const
+{ return dev ? dev->atEnd() : TRUE; }
+
+inline bool TQDataStream::eof() const
+{ return atEnd(); }
+
+inline int TQDataStream::byteOrder() const
+{ return byteorder; }
+
+inline bool TQDataStream::isPrintableData() const
+{ return printable; }
+
+inline void TQDataStream::setPrintableData( bool p )
+{ printable = p; }
+
+inline int TQDataStream::version() const
+{ return ver; }
+
+inline void TQDataStream::setVersion( int v )
+{ ver = v; }
+
+inline TQDataStream &TQDataStream::operator>>( TQ_UINT8 &i )
+{ return *this >> (TQ_INT8&)i; }
+
+inline TQDataStream &TQDataStream::operator>>( TQ_UINT16 &i )
+{ return *this >> (TQ_INT16&)i; }
+
+inline TQDataStream &TQDataStream::operator>>( TQ_UINT32 &i )
+{ return *this >> (TQ_INT32&)i; }
+
+inline TQDataStream &TQDataStream::operator>>( TQ_UINT64 &i )
+{ return *this >> (TQ_INT64&)i; }
+
+#if !defined(TQ_OS_WIN64)
+inline TQDataStream &TQDataStream::operator>>( TQ_ULONG &i )
+{ return *this >> (TQ_LONG&)i; }
+#endif
+
+inline TQDataStream &TQDataStream::operator<<( TQ_UINT8 i )
+{ return *this << (TQ_INT8)i; }
+
+inline TQDataStream &TQDataStream::operator<<( TQ_UINT16 i )
+{ return *this << (TQ_INT16)i; }
+
+inline TQDataStream &TQDataStream::operator<<( TQ_UINT32 i )
+{ return *this << (TQ_INT32)i; }
+
+inline TQDataStream &TQDataStream::operator<<( TQ_UINT64 i )
+{ return *this << (TQ_INT64)i; }
+
+#if !defined(TQ_OS_WIN64)
+inline TQDataStream &TQDataStream::operator<<( TQ_ULONG i )
+{ return *this << (TQ_LONG)i; }
+#endif
+
+#endif // USE_QT4
+
+#endif // TQT_NO_DATASTREAM
+#endif // TQDATASTREAM_H
diff --git a/tqtinterface/qt4/src/tools/tqdatetime.cpp b/tqtinterface/qt4/src/tools/tqdatetime.cpp
new file mode 100644
index 0000000..4f95dd1
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqdatetime.cpp
@@ -0,0 +1,2606 @@
+/****************************************************************************
+**
+** Implementation of date and time classes
+**
+** Created : 940124
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "tqplatformdefs.h"
+
+#include "tqdatetime.h"
+#include "tqdatastream.h"
+#include "tqregexp.h"
+
+#ifdef USE_QT4
+
+#else // USE_QT4
+
+#include <stdio.h>
+#ifndef TQ_OS_TEMP
+#include <time.h>
+#endif
+
+#if defined(TQ_OS_WIN32)
+#include <windows.h>
+#endif
+
+static const uint FIRST_DAY	= 2361222;	// Julian day for 1752-09-14
+static const int  FIRST_YEAR	= 1752;		// ### wrong for many countries
+static const uint SECS_PER_DAY	= 86400;
+static const uint MSECS_PER_DAY = 86400000;
+static const uint SECS_PER_HOUR = 3600;
+static const uint MSECS_PER_HOUR= 3600000;
+static const uint SECS_PER_MIN	= 60;
+static const uint MSECS_PER_MIN = 60000;
+
+static const short monthDays[] = {
+    0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
+
+static const char * const qt_shortMonthNames[] = {
+	"Jan", "Feb", "Mar", "Apr", "May", "Jun",
+	"Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
+
+#ifndef TQT_NO_DATESTRING
+/*****************************************************************************
+  Some static function used by TQDate, TQTime and TQDateTime
+ *****************************************************************************/
+
+// Replaces tokens by their value. See TQDateTime::toString() for a list of valid tokens
+static TQString getFmtString( const TQString& f, const TQTime* dt = 0, const TQDate* dd = 0, bool am_pm = FALSE )
+{
+    if ( f.isEmpty() )
+	return TQString::null;
+
+    TQString buf = f;
+
+    if ( dt ) {
+	if ( f == "h" ) {
+	    if ( ( am_pm ) && ( dt->hour() > 12 ) )
+		buf = TQString::number( dt->hour() - 12 );
+	    else if ( ( am_pm ) && ( dt->hour() == 0 ) )
+		buf = "12";
+	    else
+		buf = TQString::number( dt->hour() );
+	} else if ( f == "hh" ) {
+	    if ( ( am_pm ) && ( dt->hour() > 12 ) )
+		buf = TQT_TQSTRING(TQString::number( dt->hour() - 12 )).rightJustify( 2, '0', TRUE );
+	    else if ( ( am_pm ) && ( dt->hour() == 0 ) )
+		buf = "12";
+	    else
+		buf = TQT_TQSTRING(TQString::number( dt->hour() )).rightJustify( 2, '0', TRUE );
+	} else if ( f == "m" ) {
+	    buf = TQString::number( dt->minute() );
+	} else if ( f == "mm" ) {
+	    buf = TQT_TQSTRING(TQString::number( dt->minute() )).rightJustify( 2, '0', TRUE );
+	} else if ( f == "s" ) {
+	    buf = TQString::number( dt->second() );
+	} else if ( f == "ss" ) {
+	    buf = TQT_TQSTRING(TQString::number( dt->second() )).rightJustify( 2, '0', TRUE );
+	} else if ( f == "z" ) {
+	    buf = TQString::number( dt->msec() );
+	} else if ( f == "zzz" ) {
+	    buf = TQT_TQSTRING(TQString::number( dt->msec() )).rightJustify( 3, '0', TRUE );
+	} else if ( f == "ap" ) {
+	    buf = dt->hour() < 12 ? "am" : "pm";
+	} else if ( f == "AP" ) {
+	    buf = dt->hour() < 12 ? "AM" : "PM";
+	}
+    }
+
+    if ( dd ) {
+	if ( f == "d" ) {
+	    buf = TQString::number( dd->day() );
+	} else if ( f == "dd" ) {
+	    buf = TQT_TQSTRING(TQString::number( dd->day() )).rightJustify( 2, '0', TRUE );
+	} else if ( f == "M" ) {
+	    buf = TQString::number( dd->month() );
+	} else if ( f == "MM" ) {
+	    buf = TQT_TQSTRING(TQString::number( dd->month() )).rightJustify( 2, '0', TRUE );
+#ifndef TQT_NO_TEXTDATE
+	} else if ( f == "ddd" ) {
+	    buf = dd->shortDayName( dd->dayOfWeek() );
+	} else if ( f == "dddd" ) {
+	    buf = dd->longDayName( dd->dayOfWeek() );
+	} else if ( f == "MMM" ) {
+	    buf = dd->shortMonthName( dd->month() );
+	} else if ( f == "MMMM" ) {
+	    buf = dd->longMonthName( dd->month() );
+#endif
+	} else if ( f == "yy" ) {
+	    buf = TQString::number( dd->year() ).right( 2 );
+	} else if ( f == "yyyy" ) {
+	    buf = TQString::number( dd->year() );
+	}
+    }
+
+    return buf;
+}
+
+// Parses the format string and uses getFmtString to get the values for the tokens. Ret
+static TQString fmtDateTime( const TQString& f, const TQTime* dt = 0, const TQDate* dd = 0 )
+{
+    if ( f.isEmpty() ) {
+	return TQString::null;
+    }
+
+    if ( dt && !dt->isValid() )
+	return TQString::null;
+    if ( dd && !dd->isValid() )
+	return TQString::null;
+
+    bool ap = ( f.tqcontains( "AP" ) || f.tqcontains( "ap" ) );
+
+    TQString buf;
+    TQString frm;
+    TQChar status = '0';
+
+    for ( int i = 0; i < (int)f.length(); ++i ) {
+
+	if ( f[ i ] == status ) {
+	    if ( ( ap ) && ( ( f[ i ] == 'P' ) || ( f[ i ] == 'p' ) ) )
+		status = '0';
+	    frm += f[ i ];
+	} else {
+	    buf += getFmtString( frm, dt, dd, ap );
+	    frm = TQString::null;
+	    if ( ( f[ i ] == 'h' ) || ( f[ i ] == 'm' ) || ( f[ i ] == 's' ) || ( f[ i ] == 'z' ) ) {
+		status = f[ i ];
+		frm += f[ i ];
+	    } else if ( ( f[ i ] == 'd' ) || ( f[ i ] == 'M' ) || ( f[ i ] == 'y' ) ) {
+		status = f[ i ];
+		frm += f[ i ];
+	    } else if ( ( ap ) && ( f[ i ] == 'A' ) ) {
+		status = 'P';
+		frm += f[ i ];
+	    } else  if( ( ap ) && ( f[ i ] == 'a' ) ) {
+		status = 'p';
+		frm += f[ i ];
+	    } else {
+		buf += f[ i ];
+		status = '0';
+	    }
+	}
+    }
+
+    buf += getFmtString( frm, dt, dd, ap );
+
+    return buf;
+}
+#endif // TQT_NO_DATESTRING
+
+/*****************************************************************************
+  TQDate member functions
+ *****************************************************************************/
+
+/*!
+    \class TQDate tqdatetime.h
+    \reentrant
+    \brief The TQDate class provides date functions.
+
+    \ingroup time
+    \mainclass
+
+    A TQDate object tqcontains a calendar date, i.e. year, month, and day
+    numbers, in the modern Western (Gregorian) calendar. It can read
+    the current date from the system clock. It provides functions for
+    comparing dates and for manipulating dates, e.g. by adding a
+    number of days or months or years.
+
+    A TQDate object is typically created either by giving the year,
+    month and day numbers explicitly, or by using the static function
+    tqcurrentDate(), which creates a TQDate object containing the system
+    clock's date. An explicit date can also be set using setYMD(). The
+    fromString() function returns a TQDate given a string and a date
+    format which is used to interpret the date within the string.
+
+    The year(), month(), and day() functions provide access to the
+    year, month, and day numbers. Also, dayOfWeek() and dayOfYear()
+    functions are provided. The same information is provided in
+    textual format by the toString(), shortDayName(), longDayName(),
+    shortMonthName() and longMonthName() functions.
+
+    TQDate provides a full set of operators to compare two TQDate
+    objects where smaller means earlier and larger means later.
+
+    You can increment (or decrement) a date by a given number of days
+    using addDays(). Similarly you can use addMonths() and addYears().
+    The daysTo() function returns the number of days between two
+    dates.
+
+    The daysInMonth() and daysInYear() functions return how many days
+    there are in this date's month and year, respectively. The
+    leapYear() function indicates whether this date is in a leap year.
+
+    Note that TQDate should not be used for date calculations for dates
+    prior to the introduction of the Gregorian calendar. This calendar
+    was adopted by England from the 14<sup><small>th</small></sup>
+    September 1752 (hence this is the earliest valid TQDate), and
+    subsequently by most other Western countries, until 1923.
+
+    The end of time is reached around the year 8000, by which time we
+    expect TQt to be obsolete.
+
+    \sa TQTime TQDateTime TQDateEdit TQDateTimeEdit
+*/
+
+/*!
+    \enum TQt::DateFormat
+
+    \value TextDate (default) TQt format
+    \value ISODate ISO 8601 extended format (YYYY-MM-DD, or with time,
+    YYYY-MM-DDTHH:MM:SS)
+    \value LocalDate locale dependent format
+*/
+
+
+/*!
+    \enum TQt::TimeSpec
+
+    \value LocalTime Locale dependent time (Timezones and Daylight Savings Time)
+    \value UTC Coordinated Universal Time, tqreplaces Greenwich Time
+*/
+
+/*!
+    \fn TQDate::TQDate()
+
+    Constructs a null date. Null dates are invalid.
+
+    \sa isNull(), isValid()
+*/
+
+
+/*!
+    Constructs a date with year \a y, month \a m and day \a d.
+
+    \a y must be in the range 1752..8000, \a m must be in the range
+    1..12, and \a d must be in the range 1..31.
+
+    \warning If \a y is in the range 0..99, it is interpreted as
+    1900..1999.
+
+    \sa isValid()
+*/
+
+TQDate::TQDate( int y, int m, int d )
+{
+    jd = 0;
+    setYMD( y, m, d );
+}
+
+
+/*!
+    \fn bool TQDate::isNull() const
+
+    Returns TRUE if the date is null; otherwise returns FALSE. A null
+    date is invalid.
+
+    \sa isValid()
+*/
+
+
+/*!
+    Returns TRUE if this date is valid; otherwise returns FALSE.
+
+    \sa isNull()
+*/
+
+bool TQDate::isValid() const
+{
+    return jd >= FIRST_DAY;
+}
+
+
+/*!
+    Returns the year (1752..8000) of this date.
+
+    \sa month(), day()
+*/
+
+int TQDate::year() const
+{
+    int y, m, d;
+    julianToGregorian( jd, y, m, d );
+    return y;
+}
+
+/*!
+    Returns the month (January=1..December=12) of this date.
+
+    \sa year(), day()
+*/
+
+int TQDate::month() const
+{
+    int y, m, d;
+    julianToGregorian( jd, y, m, d );
+    return m;
+}
+
+/*!
+    Returns the day of the month (1..31) of this date.
+
+    \sa year(), month(), dayOfWeek()
+*/
+
+int TQDate::day() const
+{
+    int y, m, d;
+    julianToGregorian( jd, y, m, d );
+    return d;
+}
+
+/*!
+    Returns the weekday (Monday=1..Sunday=7) for this date.
+
+    \sa day(), dayOfYear()
+*/
+
+int TQDate::dayOfWeek() const
+{
+    return ( jd % 7 ) + 1;
+}
+
+/*!
+    Returns the day of the year (1..365) for this date.
+
+    \sa day(), dayOfWeek()
+*/
+
+int TQDate::dayOfYear() const
+{
+    return jd - gregorianToJulian(year(), 1, 1) + 1;
+}
+
+/*!
+    Returns the number of days in the month (28..31) for this date.
+
+    \sa day(), daysInYear()
+*/
+
+int TQDate::daysInMonth() const
+{
+    int y, m, d;
+    julianToGregorian( jd, y, m, d );
+    if ( m == 2 && leapYear(y) )
+	return 29;
+    else
+	return monthDays[m];
+}
+
+/*!
+    Returns the number of days in the year (365 or 366) for this date.
+
+    \sa day(), daysInMonth()
+*/
+
+int TQDate::daysInYear() const
+{
+    int y, m, d;
+    julianToGregorian( jd, y, m, d );
+    return leapYear( y ) ? 366 : 365;
+}
+
+/*!
+    Returns the week number (1 to 53), and stores the year in \a
+    *yearNumber unless \a yearNumber is null (the default).
+
+    Returns 0 if the date is invalid.
+
+    In accordance with ISO 8601, weeks start on Monday and the first
+    Thursday of a year is always in week 1 of that year. Most years
+    have 52 weeks, but some have 53.
+
+    \a *yearNumber is not always the same as year(). For example, 1
+    January 2000 has week number 52 in the year 1999, and 31 December
+    2002 has week number 1 in the year 2003.
+
+    \legalese
+
+    Copyright (c) 1989 The Regents of the University of California.
+    All rights reserved.
+
+    Redistribution and use in source and binary forms are permitted
+    provided that the above copyright notice and this paragraph are
+    duplicated in all such forms and that any documentation,
+    advertising materials, and other materials related to such
+    distribution and use acknowledge that the software was developed
+    by the University of California, Berkeley.  The name of the
+    University may not be used to endorse or promote products derived
+    from this software without specific prior written permission.
+    THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+    IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+
+    \sa isValid()
+*/
+
+int TQDate::weekNumber( int *yearNumber ) const
+{
+    if ( !isValid() )
+	return 0;
+
+    int	year = TQDate::year();
+    int	yday = dayOfYear() - 1;
+    int	wday = dayOfWeek();
+    if (wday == 7)
+    	wday = 0;
+    int	w;
+
+    for (;;) {
+	int len;
+	int bot;
+	int top;
+
+	len = leapYear(year) ? 366 : 365;
+	/*
+	** What yday (-3 ... 3) does
+	** the ISO year begin on?
+	*/
+	bot = ((yday + 11 - wday) % 7) - 3;
+	/*
+	** What yday does the NEXT
+	** ISO year begin on?
+	*/
+	top = bot - (len % 7);
+	if (top < -3)
+    	    top += 7;
+	top += len;
+	if (yday >= top) {
+	    ++year;
+    	    w = 1;
+	    break;
+	}
+	if (yday >= bot) {
+	    w = 1 + ((yday - bot) / 7);
+	    break;
+	}
+	--year;
+	yday += leapYear(year) ? 366 : 365;
+    }
+    if (yearNumber != 0)
+    	*yearNumber = year;
+    return w;
+}
+
+/*!
+  \fn TQString TQDate::monthName( int month )
+  \obsolete
+
+  Use shortMonthName() instead.
+*/
+#ifndef TQT_NO_TEXTDATE
+/*!
+    Returns the name of the \a month.
+
+    1 = "Jan", 2 = "Feb", ... 12 = "Dec"
+
+    The month names will be localized according to the system's locale
+    settings.
+
+    \sa toString(), longMonthName(), shortDayName(), longDayName()
+*/
+
+TQString TQDate::shortMonthName( int month )
+{
+#if defined(TQT_CHECK_RANGE)
+    if ( month < 1 || month > 12 ) {
+	qWarning( "TQDate::shortMonthName: Parameter out ouf range" );
+	month = 1;
+    }
+#endif
+#ifndef TQ_WS_WIN
+    char buffer[255];
+    tm tt;
+    memset( &tt, 0, sizeof( tm ) );
+    tt.tm_mon = month - 1;
+    if ( strftime( buffer, sizeof( buffer ), "%b", &tt ) )
+	return TQString::fromLocal8Bit( buffer );
+#else
+    SYSTEMTIME st;
+    memset( &st, 0, sizeof(SYSTEMTIME) );
+    st.wYear = 2000;
+    st.wMonth = month;
+    st.wDay = 1;
+    const wchar_t mmm_t[] = L"MMM"; // workaround for Borland
+    TQT_WA( {
+	TCHAR buf[255];
+	if ( GetDateFormat( LOCALE_USER_DEFAULT, 0, &st, mmm_t, buf, 255 ) )
+	    return TQString::fromUcs2( (ushort*)buf );
+    } , {
+	char buf[255];
+	if ( GetDateFormatA( LOCALE_USER_DEFAULT, 0, &st, "MMM", (char*)&buf, 255 ) )
+	    return TQString::fromLocal8Bit( buf );
+    } );
+#endif
+    return TQString::null;
+}
+
+/*!
+    Returns the long name of the \a month.
+
+    1 = "January", 2 = "February", ... 12 = "December"
+
+    The month names will be localized according to the system's locale
+    settings.
+
+    \sa toString(), shortMonthName(), shortDayName(), longDayName()
+*/
+
+TQString TQDate::longMonthName( int month )
+{
+#if defined(TQT_CHECK_RANGE)
+    if ( month < 1 || month > 12 ) {
+	qWarning( "TQDate::longMonthName: Parameter out ouf range" );
+	month = 1;
+    }
+#endif
+#ifndef TQ_WS_WIN
+    char buffer[255];
+    tm tt;
+    memset( &tt, 0, sizeof( tm ) );
+    tt.tm_mon = month - 1;
+    if ( strftime( buffer, sizeof( buffer ), "%B", &tt ) )
+	return TQString::fromLocal8Bit( buffer );
+#else
+    SYSTEMTIME st;
+    memset( &st, 0, sizeof(SYSTEMTIME) );
+    st.wYear = 2000;
+    st.wMonth = month;
+    st.wDay = 1 ;
+    const wchar_t mmmm_t[] = L"MMMM"; // workaround for Borland
+    TQT_WA( {
+	TCHAR buf[255];
+	if ( GetDateFormat( LOCALE_USER_DEFAULT, 0, &st, mmmm_t, buf, 255 ) )
+	    return TQString::fromUcs2( (ushort*)buf );
+    } , {
+	char buf[255];
+	if ( GetDateFormatA( LOCALE_USER_DEFAULT, 0, &st, "MMMM", (char*)&buf, 255 ) )
+	    return TQString::fromLocal8Bit( buf );
+    } )
+#endif
+
+    return TQString::null;
+}
+
+/*!
+  \fn TQString TQDate::dayName( int weekday )
+  \obsolete
+
+  Use shortDayName() instead.
+*/
+
+/*!
+    Returns the name of the \a weekday.
+
+    1 = "Mon", 2 = "Tue", ... 7 = "Sun"
+
+    The day names will be localized according to the system's locale
+    settings.
+
+    \sa toString(), shortMonthName(), longMonthName(), longDayName()
+*/
+
+TQString TQDate::shortDayName( int weekday )
+{
+#if defined(TQT_CHECK_RANGE)
+    if ( weekday < 1 || weekday > 7 ) {
+	qWarning( "TQDate::shortDayName: Parameter out of range" );
+	weekday = 1;
+    }
+#endif
+#ifndef TQ_WS_WIN
+    char buffer[255];
+    tm tt;
+    memset( &tt, 0, sizeof( tm ) );
+    tt.tm_wday = ( weekday == 7 ) ? 0 : weekday;
+    if ( strftime( buffer, sizeof( buffer ), "%a", &tt ) )
+	return TQString::fromLocal8Bit( buffer );
+#else
+    SYSTEMTIME st;
+    memset( &st, 0, sizeof(SYSTEMTIME) );
+    st.wYear = 2001;
+    st.wMonth = 10;
+    st.wDayOfWeek = ( weekday == 7 ) ? 0 : weekday;
+    st.wDay = 21 + st.wDayOfWeek;
+    const wchar_t ddd_t[] = L"ddd"; // workaround for Borland
+    TQT_WA( {
+	TCHAR buf[255];
+	if ( GetDateFormat( LOCALE_USER_DEFAULT, 0, &st, ddd_t, buf, 255 ) )
+	    return TQString::fromUcs2( (ushort*)buf );
+    } , {
+	char buf[255];
+	if ( GetDateFormatA( LOCALE_USER_DEFAULT, 0, &st, "ddd", (char*)&buf, 255 ) )
+	    return TQString::fromLocal8Bit( buf );
+    } );
+#endif
+
+    return TQString::null;
+}
+
+/*!
+    Returns the long name of the \a weekday.
+
+    1 = "Monday", 2 = "Tuesday", ... 7 = "Sunday"
+
+    The day names will be localized according to the system's locale
+    settings.
+
+    \sa toString(), shortDayName(), shortMonthName(), longMonthName()
+*/
+
+TQString TQDate::longDayName( int weekday )
+{
+#if defined(TQT_CHECK_RANGE)
+    if ( weekday < 1 || weekday > 7 ) {
+	qWarning( "TQDate::longDayName: Parameter out of range" );
+	weekday = 1;
+    }
+#endif
+#ifndef TQ_WS_WIN
+    char buffer[255];
+    tm tt;
+    memset( &tt, 0, sizeof( tm ) );
+    tt.tm_wday = ( weekday == 7 ) ? 0 : weekday;
+    if ( strftime( buffer, sizeof( buffer ), "%A", &tt ) )
+	return TQString::fromLocal8Bit( buffer );
+#else
+    SYSTEMTIME st;
+    memset( &st, 0, sizeof(SYSTEMTIME) );
+    st.wYear = 2001;
+    st.wMonth = 10;
+    st.wDayOfWeek = ( weekday == 7 ) ? 0 : weekday;
+    st.wDay = 21 + st.wDayOfWeek;
+    const wchar_t dddd_t[] = L"dddd"; // workaround for Borland
+    TQT_WA( {
+	TCHAR buf[255];
+	if ( GetDateFormat( LOCALE_USER_DEFAULT, 0, &st, dddd_t, buf, 255 ) )
+	    return TQString::fromUcs2( (ushort*)buf );
+    } , {
+	char buf[255];
+	if ( GetDateFormatA( LOCALE_USER_DEFAULT, 0, &st, "dddd", (char*)&buf, 255 ) )
+	    return TQString::fromLocal8Bit( buf );
+    } );
+#endif
+
+    return TQString::null;
+}
+#endif //TQT_NO_TEXTDATE
+
+#ifndef TQT_NO_DATESTRING
+
+#if !defined(TQT_NO_SPRINTF)
+/*!
+    \overload
+
+    Returns the date as a string. The \a f parameter determines the
+    format of the string.
+
+    If \a f is \c TQt::TextDate, the string format is "Sat May 20 1995"
+    (using the shortDayName() and shortMonthName() functions to
+    generate the string, so the day and month names are locale
+    specific).
+
+    If \a f is \c TQt::ISODate, the string format corresponds to the
+    ISO 8601 specification for representations of dates, which is
+    YYYY-MM-DD where YYYY is the year, MM is the month of the year
+    (between 01 and 12), and DD is the day of the month between 01 and
+    31.
+
+    If \a f is \c TQt::LocalDate, the string format depends on the
+    locale settings of the system.
+
+    If the date is an invalid date, then TQString::null will be returned.
+
+    \sa shortDayName(), shortMonthName()
+*/
+TQString TQDate::toString( TQt::DateFormat f ) const
+{
+    if ( !isValid() )
+	return TQString::null;
+    int y, m, d;
+    julianToGregorian( jd, y, m, d );
+    switch ( f ) {
+    case TQt::LocalDate:
+	{
+#ifndef TQ_WS_WIN
+	    tm tt;
+	    memset( &tt, 0, sizeof( tm ) );
+	    char buf[255];
+	    tt.tm_mday = day();
+	    tt.tm_mon = month() - 1;
+	    tt.tm_year = year() - 1900;
+
+	    static const char * avoidEgcsWarning = "%x";
+	    if ( strftime( buf, sizeof(buf), avoidEgcsWarning, &tt ) )
+		return TQString::fromLocal8Bit( buf );
+#else
+	    SYSTEMTIME st;
+	    memset( &st, 0, sizeof(SYSTEMTIME) );
+	    st.wYear = year();
+	    st.wMonth = month();
+	    st.wDay = day();
+	    TQT_WA( {
+		TCHAR buf[255];
+		if ( GetDateFormat( LOCALE_USER_DEFAULT, 0, &st, 0, buf, 255 ) )
+		    return TQString::fromUcs2( (ushort*)buf );
+	    } , {
+		char buf[255];
+		if ( GetDateFormatA( LOCALE_USER_DEFAULT, 0, &st, 0, (char*)&buf, 255 ) )
+		    return TQString::fromLocal8Bit( buf );
+	    } );
+#endif
+	    return TQString::null;
+	}
+    default:
+#ifndef TQT_NO_TEXTDATE
+    case TQt::TextDate:
+	{
+	    TQString buf = shortDayName( dayOfWeek() );
+	    buf += ' ';
+	    buf += shortMonthName( m );
+	    TQString t;
+	    t.sprintf( " %d %d", d, y );
+	    buf += t;
+	    return buf;
+	}
+#endif
+    case TQt::ISODate:
+	{
+	    TQString month( TQT_TQSTRING(TQString::number( m )).rightJustify( 2, '0' ) );
+	    TQString day( TQT_TQSTRING(TQString::number( d )).rightJustify( 2, '0' ) );
+	    return TQString::number( y ) + "-" + month + "-" + day;
+	}
+    }
+}
+#endif //TQT_NO_SPRINTF
+
+/*!
+    Returns the date as a string. The \a format parameter determines
+    the format of the result string.
+
+    These expressions may be used:
+
+    \table
+    \header \i Expression \i Output
+    \row \i d \i the day as number without a leading zero (1-31)
+    \row \i dd \i the day as number with a leading zero (01-31)
+    \row \i ddd
+	 \i the abbreviated localized day name (e.g. 'Mon'..'Sun').
+	    Uses TQDate::shortDayName().
+    \row \i dddd
+	 \i the long localized day name (e.g. 'Monday'..'Sunday').
+	    Uses TQDate::longDayName().
+    \row \i M \i the month as number without a leading zero (1-12)
+    \row \i MM \i the month as number with a leading zero (01-12)
+    \row \i MMM
+	 \i the abbreviated localized month name (e.g. 'Jan'..'Dec').
+	    Uses TQDate::shortMonthName().
+    \row \i MMMM
+	 \i the long localized month name (e.g. 'January'..'December').
+	    Uses TQDate::longMonthName().
+    \row \i yy \i the year as two digit number (00-99)
+    \row \i yyyy \i the year as four digit number (1752-8000)
+    \endtable
+
+    All other input characters will be ignored.
+
+    Example format strings (assuming that the TQDate is the
+    20<sup><small>th</small></sup> July 1969):
+    \table
+    \header \i Format \i Result
+    \row \i dd.MM.yyyy	  \i11 20.07.1969
+    \row \i ddd MMMM d yy \i11 Sun July 20 69
+    \endtable
+
+    If the date is an invalid date, then TQString::null will be returned.
+
+    \sa TQDateTime::toString() TQTime::toString()
+
+*/
+TQString TQDate::toString( const TQString& format ) const
+{
+    return fmtDateTime( format, 0, this );
+}
+#endif //TQT_NO_DATESTRING
+
+/*!
+    Sets the date's year \a y, month \a m and day \a d.
+
+    \a y must be in the range 1752..8000, \a m must be in the range
+    1..12, and \a d must be in the range 1..31.
+
+    \warning If \a y is in the range 0..99, it is interpreted as
+    1900..1999.
+
+    Returns TRUE if the date is valid; otherwise returns FALSE.
+*/
+
+bool TQDate::setYMD( int y, int m, int d )
+{
+    if ( year() == y && month() == m && day() == d )
+	return isValid();
+    if ( !isValid(y,m,d) ) {
+#if defined(TQT_CHECK_RANGE)
+	 qWarning( "TQDate::setYMD: Invalid date %04d-%02d-%02d", y, m, d );
+#endif
+	 return FALSE;
+    }
+    jd = gregorianToJulian( y, m, d );
+    return TRUE;
+}
+
+/*!
+    Returns a TQDate object containing a date \a ndays later than the
+    date of this object (or earlier if \a ndays is negative).
+
+    \sa addMonths() addYears() daysTo()
+*/
+
+TQDate TQDate::addDays( int ndays ) const
+{
+    TQDate d;
+    d.jd = jd + ndays;
+    return d;
+}
+
+/*!
+    Returns a TQDate object containing a date \a nmonths later than the
+    date of this object (or earlier if \a nmonths is negative).
+
+    \sa addDays() addYears()
+*/
+
+TQDate TQDate::addMonths( int nmonths ) const
+{
+    int y, m, d;
+    julianToGregorian( jd, y, m, d );
+
+    while ( nmonths != 0 ) {
+	if ( nmonths < 0 && nmonths + 12 <= 0 ) {
+	    y--;
+	    nmonths+=12;
+	} else if ( nmonths < 0 ) {
+	    m+= nmonths;
+	    nmonths = 0;
+	    if ( m <= 0 ) {
+		--y;
+		m+=12;
+	    }
+	} else if ( nmonths - 12 >= 0 ) {
+	    y++;
+	    nmonths-=12;
+	} else if ( m == 12 ) {
+	    y++;
+	    m = 0;
+	} else {
+	    m+= nmonths;
+	    nmonths = 0;
+	    if ( m > 12 ) {
+		++y;
+		m -= 12;
+	    }
+	}
+    }
+
+    TQDate tmp(y,m,1);
+
+    if( d > tmp.daysInMonth() )
+	d = tmp.daysInMonth();
+
+    TQDate date(y, m, d);
+    return date;
+
+}
+
+/*!
+    Returns a TQDate object containing a date \a nyears later than the
+    date of this object (or earlier if \a nyears is negative).
+
+    \sa addDays(), addMonths()
+*/
+
+TQDate TQDate::addYears( int nyears ) const
+{
+    int y, m, d;
+    julianToGregorian( jd, y, m, d );
+    y += nyears;
+
+    TQDate tmp(y,m,1);
+
+    if( d > tmp.daysInMonth() )
+	d = tmp.daysInMonth();
+
+    TQDate date(y, m, d);
+    return date;
+}
+
+
+
+/*!
+    Returns the number of days from this date to \a d (which is
+    negative if \a d is earlier than this date).
+
+    Example:
+    \code
+	TQDate d1( 1995, 5, 17 );  // May 17th 1995
+	TQDate d2( 1995, 5, 20 );  // May 20th 1995
+	d1.daysTo( d2 );          // returns 3
+	d2.daysTo( d1 );          // returns -3
+    \endcode
+
+    \sa addDays()
+*/
+
+int TQDate::daysTo( const TQDate &d ) const
+{
+    return d.jd - jd;
+}
+
+
+/*!
+    \fn bool TQDate::operator==( const TQDate &d ) const
+
+    Returns TRUE if this date is equal to \a d; otherwise returns FALSE.
+*/
+
+/*!
+    \fn bool TQDate::operator!=( const TQDate &d ) const
+
+    Returns TRUE if this date is different from \a d; otherwise returns FALSE.
+*/
+
+/*!
+    \fn bool TQDate::operator<( const TQDate &d ) const
+
+    Returns TRUE if this date is earlier than \a d, otherwise returns FALSE.
+*/
+
+/*!
+    \fn bool TQDate::operator<=( const TQDate &d ) const
+
+    Returns TRUE if this date is earlier than or equal to \a d,
+    otherwise returns FALSE.
+*/
+
+/*!
+    \fn bool TQDate::operator>( const TQDate &d ) const
+
+    Returns TRUE if this date is later than \a d, otherwise returns FALSE.
+*/
+
+/*!
+    \fn bool TQDate::operator>=( const TQDate &d ) const
+
+    Returns TRUE if this date is later than or equal to \a d,
+    otherwise returns FALSE.
+*/
+
+/*!
+    \overload
+    Returns the current date, as reported by the system clock.
+
+    \sa TQTime::currentTime(), TQDateTime::tqcurrentDateTime()
+*/
+
+TQDate TQDate::tqcurrentDate()
+{
+    return tqcurrentDate( TQt::LocalTime );
+}
+
+/*!
+  Returns the current date, as reported by the system clock, for the
+  TimeSpec \a ts. The default TimeSpec is LocalTime.
+
+  \sa TQTime::currentTime(), TQDateTime::tqcurrentDateTime(), TQt::TimeSpec
+*/
+TQDate TQDate::tqcurrentDate( TQt::TimeSpec ts )
+{
+    TQDate d;
+#if defined(TQ_OS_WIN32)
+    SYSTEMTIME t;
+    memset( &t, 0, sizeof(SYSTEMTIME) );
+    if ( ts == TQt::LocalTime )
+	GetLocalTime( &t );
+    else
+	GetSystemTime( &t );
+    d.jd = gregorianToJulian( t.wYear, t.wMonth, t.wDay );
+#else
+    // posix compliant system
+    time_t ltime;
+    time( &ltime );
+    tm *t;
+
+#  if defined(TQT_THREAD_SUPPORT) && defined(_POSIX_THREAD_SAFE_FUNCTIONS)
+    // use the reentrant versions of localtime() and gmtime() where available
+    tm res;
+    if ( ts == TQt::LocalTime )
+	t = localtime_r( &ltime, &res );
+    else
+	t = gmtime_r( &ltime, &res );
+#  else
+    if ( ts == TQt::LocalTime )
+	t = localtime( &ltime );
+    else
+	t = gmtime( &ltime );
+#  endif // TQT_THREAD_SUPPORT && _POSIX_THREAD_SAFE_FUNCTIONS
+
+    d.jd = gregorianToJulian( t->tm_year + 1900, t->tm_mon + 1, t->tm_mday );
+#endif
+    return d;
+}
+
+#ifndef TQT_NO_DATESTRING
+/*!
+    Returns the TQDate represented by the string \a s, using the format
+    \a f, or an invalid date if the string cannot be parsed.
+
+    Note for \c TQt::TextDate: It is recommended that you use the
+    English short month names (e.g. "Jan"). Although localized month
+    names can also be used, they depend on the user's locale settings.
+
+    \warning \c TQt::LocalDate cannot be used here.
+*/
+TQDate TQDate::fromString( const TQString& s, TQt::DateFormat f )
+{
+    if ( ( s.isEmpty() ) || ( f == TQt::LocalDate ) ) {
+#if defined(TQT_CHECK_RANGE)
+	qWarning( "TQDate::fromString: Parameter out of range" );
+#endif
+	TQDate d;
+	d.jd = 0;
+	return d;
+    }
+    switch ( f ) {
+    case TQt::ISODate:
+	{
+	    int year( s.mid( 0, 4 ).toInt() );
+	    int month( s.mid( 5, 2 ).toInt() );
+	    int day( s.mid( 8, 2 ).toInt() );
+	    if ( year && month && day )
+		return TQDate( year, month, day );
+	}
+	break;
+    default:
+#ifndef TQT_NO_TEXTDATE
+    case TQt::TextDate:
+	{
+	    /*
+	      This will fail gracefully if the input string doesn't
+	      contain any space.
+	    */
+	    int monthPos = s.tqfind( ' ' ) + 1;
+	    int dayPos = s.tqfind( ' ', monthPos ) + 1;
+
+	    TQString monthName( s.mid(monthPos, dayPos - monthPos - 1) );
+	    int month = -1;
+
+	    // try English names first
+	    for ( int i = 0; i < 12; i++ ) {
+		if ( monthName == qt_shortMonthNames[i] ) {
+		    month = i + 1;
+		    break;
+		}
+	    }
+
+	    // try the localized names
+	    if ( month == -1 ) {
+		for ( int i = 0; i < 12; i++ ) {
+		    if ( monthName == shortMonthName( i + 1 ) ) {
+			month = i + 1;
+			break;
+		    }
+		}
+	    }
+#if defined(TQT_CHECK_RANGE)
+	    if ( month < 1 || month > 12 ) {
+		qWarning( "TQDate::fromString: Parameter out of range" );
+		TQDate d;
+		d.jd = 0;
+		return d;
+	    }
+#endif
+	    int day = TQT_TQSTRING(s.mid( dayPos, 2 )).stripWhiteSpace().toInt();
+	    int year = s.right( 4 ).toInt();
+	    return TQDate( year, month, day );
+	}
+#else
+	break;
+#endif
+    }
+    return TQDate();
+}
+#endif //TQT_NO_DATESTRING
+
+/*!
+    \overload
+
+    Returns TRUE if the specified date (year \a y, month \a m and day
+    \a d) is valid; otherwise returns FALSE.
+
+    Example:
+    \code
+    TQDate::isValid( 2002, 5, 17 );  // TRUE   May 17th 2002 is valid
+    TQDate::isValid( 2002, 2, 30 );  // FALSE  Feb 30th does not exist
+    TQDate::isValid( 2004, 2, 29 );  // TRUE   2004 is a leap year
+    TQDate::isValid( 1202, 6, 6 );   // FALSE  1202 is pre-Gregorian
+    \endcode
+
+    \warning A \a y value in the range 00..99 is interpreted as
+    1900..1999.
+
+    \sa isNull(), setYMD()
+*/
+
+bool TQDate::isValid( int y, int m, int d )
+{
+    if ( y >= 0 && y <= 99 )
+	y += 1900;
+    else if ( y < FIRST_YEAR || (y == FIRST_YEAR && (m < 9 ||
+						    (m == 9 && d < 14))) )
+	return FALSE;
+    return (d > 0 && m > 0 && m <= 12) &&
+	   (d <= monthDays[m] || (d == 29 && m == 2 && leapYear(y)));
+}
+
+/*!
+    Returns TRUE if the specified year \a y is a leap year; otherwise
+    returns FALSE.
+*/
+
+bool TQDate::leapYear( int y )
+{
+    return y % 4 == 0 && y % 100 != 0 || y % 400 == 0;
+}
+
+/*!
+  \internal
+  Converts a Gregorian date to a Julian day.
+  This algorithm is taken from Communications of the ACM, Vol 6, No 8.
+  \sa julianToGregorian()
+*/
+
+uint TQDate::gregorianToJulian( int y, int m, int d )
+{
+    uint c, ya;
+    if ( y <= 99 )
+	y += 1900;
+    if ( m > 2 ) {
+	m -= 3;
+    } else {
+	m += 9;
+	y--;
+    }
+    c = y;					// NOTE: Sym C++ 6.0 bug
+    c /= 100;
+    ya = y - 100*c;
+    return 1721119 + d + (146097*c)/4 + (1461*ya)/4 + (153*m+2)/5;
+}
+
+/*!
+  \internal
+  Converts a Julian day to a Gregorian date.
+  This algorithm is taken from Communications of the ACM, Vol 6, No 8.
+  \sa gregorianToJulian()
+*/
+
+void TQDate::julianToGregorian( uint jd, int &y, int &m, int &d )
+{
+    uint x;
+    uint j = jd - 1721119;
+    y = (j*4 - 1)/146097;
+    j = j*4 - 146097*y - 1;
+    x = j/4;
+    j = (x*4 + 3) / 1461;
+    y = 100*y + j;
+    x = (x*4) + 3 - 1461*j;
+    x = (x + 4)/4;
+    m = (5*x - 3)/153;
+    x = 5*x - 3 - 153*m;
+    d = (x + 5)/5;
+    if ( m < 10 ) {
+	m += 3;
+    } else {
+	m -= 9;
+	y++;
+    }
+}
+
+
+/*****************************************************************************
+  TQTime member functions
+ *****************************************************************************/
+
+/*!
+    \class TQTime tqdatetime.h
+    \reentrant
+
+    \brief The TQTime class provides clock time functions.
+
+    \ingroup time
+    \mainclass
+
+    A TQTime object tqcontains a clock time, i.e. the number of hours,
+    minutes, seconds, and milliseconds since midnight. It can read the
+    current time from the system clock and measure a span of elapsed
+    time. It provides functions for comparing times and for
+    manipulating a time by adding a number of (milli)seconds.
+
+    TQTime uses the 24-hour clock format; it has no concept of AM/PM.
+    It operates in local time; it knows nothing about time zones or
+    daylight savings time.
+
+    A TQTime object is typically created either by giving the number of
+    hours, minutes, seconds, and milliseconds explicitly, or by using
+    the static function currentTime(), which creates a TQTime object
+    that tqcontains the system's clock time. Note that the accuracy
+    depends on the accuracy of the underlying operating system; not
+    all systems provide 1-millisecond accuracy.
+
+    The hour(), minute(), second(), and msec() functions provide
+    access to the number of hours, minutes, seconds, and milliseconds
+    of the time. The same information is provided in textual format by
+    the toString() function.
+
+    TQTime provides a full set of operators to compare two TQTime
+    objects. One time is considered smaller than another if it is
+    earlier than the other.
+
+    The time a given number of seconds or milliseconds later than a
+    given time can be found using the addSecs() or addMSecs()
+    functions. Correspondingly, the number of (milli)seconds between
+    two times can be found using the secsTo() or msecsTo() functions.
+
+    TQTime can be used to measure a span of elapsed time using the
+    start(), restart(), and elapsed() functions.
+
+    \sa TQDate, TQDateTime
+*/
+
+/*!
+    \fn TQTime::TQTime()
+
+    Constructs the time 0 hours, minutes, seconds and milliseconds,
+    i.e. 00:00:00.000 (midnight). This is a valid time.
+
+    \sa isValid()
+*/
+
+/*!
+    Constructs a time with hour \a h, minute \a m, seconds \a s and
+    milliseconds \a ms.
+
+    \a h must be in the range 0..23, \a m and \a s must be in the
+    range 0..59, and \a ms must be in the range 0..999.
+
+    \sa isValid()
+*/
+
+TQTime::TQTime( int h, int m, int s, int ms )
+{
+    setHMS( h, m, s, ms );
+}
+
+
+/*!
+    \fn bool TQTime::isNull() const
+
+    Returns TRUE if the time is equal to 00:00:00.000; otherwise
+    returns FALSE. A null time is valid.
+
+    \sa isValid()
+*/
+
+/*!
+    Returns TRUE if the time is valid; otherwise returns FALSE. The
+    time 23:30:55.746 is valid, whereas 24:12:30 is invalid.
+
+    \sa isNull()
+*/
+
+bool TQTime::isValid() const
+{
+    return ds < MSECS_PER_DAY;
+}
+
+
+/*!
+    Returns the hour part (0..23) of the time.
+*/
+
+int TQTime::hour() const
+{
+    return ds / MSECS_PER_HOUR;
+}
+
+/*!
+    Returns the minute part (0..59) of the time.
+*/
+
+int TQTime::minute() const
+{
+    return (ds % MSECS_PER_HOUR)/MSECS_PER_MIN;
+}
+
+/*!
+    Returns the second part (0..59) of the time.
+*/
+
+int TQTime::second() const
+{
+    return (ds / 1000)%SECS_PER_MIN;
+}
+
+/*!
+    Returns the millisecond part (0..999) of the time.
+*/
+
+int TQTime::msec() const
+{
+    return ds % 1000;
+}
+
+#ifndef TQT_NO_DATESTRING
+#ifndef TQT_NO_SPRINTF
+/*!
+    \overload
+
+    Returns the time as a string. Milliseconds are not included. The
+    \a f parameter determines the format of the string.
+
+    If \a f is \c TQt::TextDate, the string format is HH:MM:SS; e.g. 1
+    second before midnight would be "23:59:59".
+
+    If \a f is \c TQt::ISODate, the string format corresponds to the
+    ISO 8601 extended specification for representations of dates,
+    which is also HH:MM:SS.
+
+    If \a f is TQt::LocalDate, the string format depends on the locale
+    settings of the system.
+
+    If the time is an invalid time, then TQString::null will be returned.
+*/
+
+TQString TQTime::toString( TQt::DateFormat f ) const
+{
+    if ( !isValid() )
+	return TQString::null;
+
+    switch ( f ) {
+    case TQt::LocalDate:
+	{
+#ifndef TQ_WS_WIN
+	    tm tt;
+	    memset( &tt, 0, sizeof( tm ) );
+	    char buf[255];
+	    tt.tm_sec = second();
+	    tt.tm_min = minute();
+	    tt.tm_hour = hour();
+	    if ( strftime( buf, sizeof(buf), "%X", &tt ) )
+		return TQString::fromLocal8Bit( buf );
+#else
+	    SYSTEMTIME st;
+	    memset( &st, 0, sizeof(SYSTEMTIME) );
+	    st.wHour = hour();
+	    st.wMinute = minute();
+	    st.wSecond = second();
+	    st.wMilliseconds = 0;
+	    TQT_WA( {
+		TCHAR buf[255];
+		if ( GetTimeFormat( LOCALE_USER_DEFAULT, 0, &st, 0, buf, 255 ) )
+		    return TQString::fromUcs2( (ushort*)buf );
+	    } , {
+		char buf[255];
+		if ( GetTimeFormatA( LOCALE_USER_DEFAULT, 0, &st, 0, (char*)&buf, 255 ) )
+		    return TQString::fromLocal8Bit( buf );
+	    } );
+#endif
+	    return TQString::null;
+	}
+    default:
+    case TQt::ISODate:
+    case TQt::TextDate:
+	TQString buf;
+	buf.sprintf( "%.2d:%.2d:%.2d", hour(), minute(), second() );
+	return buf;
+    }
+}
+#endif
+
+/*!
+    Returns the time as a string. The \a format parameter determines
+    the format of the result string.
+
+    These expressions may be used:
+
+    \table
+    \header \i Expression \i Output
+    \row \i h
+	 \i the hour without a leading zero (0..23 or 1..12 if AM/PM display)
+    \row \i hh
+	 \i the hour with a leading zero (00..23 or 01..12 if AM/PM display)
+    \row \i m \i the minute without a leading zero (0..59)
+    \row \i mm \i the minute with a leading zero (00..59)
+    \row \i s \i the second whithout a leading zero (0..59)
+    \row \i ss \i the second whith a leading zero (00..59)
+    \row \i z \i the milliseconds without leading zeroes (0..999)
+    \row \i zzz \i the milliseconds with leading zeroes (000..999)
+    \row \i AP
+	 \i use AM/PM display. \e AP will be tqreplaced by either "AM" or "PM".
+    \row \i ap
+	 \i use am/pm display. \e ap will be tqreplaced by either "am" or "pm".
+    \endtable
+
+    All other input characters will be ignored.
+
+    Example format strings (assuming that the TQTime is 14:13:09.042)
+
+    \table
+    \header \i Format \i Result
+    \row \i hh:mm:ss.zzz    \i11 14:13:09.042
+    \row \i h:m:s ap	    \i11 2:13:9 pm
+    \endtable
+
+    If the time is an invalid time, then TQString::null will be returned.
+
+    \sa TQDate::toString() TQDateTime::toString()
+*/
+TQString TQTime::toString( const TQString& format ) const
+{
+    return fmtDateTime( format, this, 0 );
+}
+#endif //TQT_NO_DATESTRING
+/*!
+    Sets the time to hour \a h, minute \a m, seconds \a s and
+    milliseconds \a ms.
+
+    \a h must be in the range 0..23, \a m and \a s must be in the
+    range 0..59, and \a ms must be in the range 0..999. Returns TRUE
+    if the set time is valid; otherwise returns FALSE.
+
+    \sa isValid()
+*/
+
+bool TQTime::setHMS( int h, int m, int s, int ms )
+{
+    if ( !isValid(h,m,s,ms) ) {
+#if defined(TQT_CHECK_RANGE)
+	qWarning( "TQTime::setHMS Invalid time %02d:%02d:%02d.%03d", h, m, s,
+		 ms );
+#endif
+	ds = MSECS_PER_DAY;		// make this invalid
+	return FALSE;
+    }
+    ds = (h*SECS_PER_HOUR + m*SECS_PER_MIN + s)*1000 + ms;
+    return TRUE;
+}
+
+/*!
+    Returns a TQTime object containing a time \a nsecs seconds later
+    than the time of this object (or earlier if \a nsecs is negative).
+
+    Note that the time will wrap if it passes midnight.
+
+    Example:
+    \code
+    TQTime n( 14, 0, 0 );                // n == 14:00:00
+    TQTime t;
+    t = n.addSecs( 70 );                // t == 14:01:10
+    t = n.addSecs( -70 );               // t == 13:58:50
+    t = n.addSecs( 10*60*60 + 5 );      // t == 00:00:05
+    t = n.addSecs( -15*60*60 );         // t == 23:00:00
+    \endcode
+
+    \sa addMSecs(), secsTo(), TQDateTime::addSecs()
+*/
+
+TQTime TQTime::addSecs( int nsecs ) const
+{
+    return addMSecs( nsecs * 1000 );
+}
+
+/*!
+    Returns the number of seconds from this time to \a t (which is
+    negative if \a t is earlier than this time).
+
+    Because TQTime measures time within a day and there are 86400
+    seconds in a day, the result is always between -86400 and 86400.
+
+    \sa addSecs() TQDateTime::secsTo()
+*/
+
+int TQTime::secsTo( const TQTime &t ) const
+{
+    return ((int)t.ds - (int)ds)/1000;
+}
+
+/*!
+    Returns a TQTime object containing a time \a ms milliseconds later
+    than the time of this object (or earlier if \a ms is negative).
+
+    Note that the time will wrap if it passes midnight. See addSecs()
+    for an example.
+
+    \sa addSecs(), msecsTo()
+*/
+
+TQTime TQTime::addMSecs( int ms ) const
+{
+    TQTime t;
+    if ( ms < 0 ) {
+	// % not well-defined for -ve, but / is.
+	int negdays = (MSECS_PER_DAY-ms) / MSECS_PER_DAY;
+	t.ds = ((int)ds + ms + negdays*MSECS_PER_DAY)
+		% MSECS_PER_DAY;
+    } else {
+	t.ds = ((int)ds + ms) % MSECS_PER_DAY;
+    }
+    return t;
+}
+
+/*!
+    Returns the number of milliseconds from this time to \a t (which
+    is negative if \a t is earlier than this time).
+
+    Because TQTime measures time within a day and there are 86400
+    seconds in a day, the result is always between -86400000 and
+    86400000 msec.
+
+    \sa secsTo()
+*/
+
+int TQTime::msecsTo( const TQTime &t ) const
+{
+    return (int)t.ds - (int)ds;
+}
+
+
+/*!
+    \fn bool TQTime::operator==( const TQTime &t ) const
+
+    Returns TRUE if this time is equal to \a t; otherwise returns FALSE.
+*/
+
+/*!
+    \fn bool TQTime::operator!=( const TQTime &t ) const
+
+    Returns TRUE if this time is different from \a t; otherwise returns FALSE.
+*/
+
+/*!
+    \fn bool TQTime::operator<( const TQTime &t ) const
+
+    Returns TRUE if this time is earlier than \a t; otherwise returns FALSE.
+*/
+
+/*!
+    \fn bool TQTime::operator<=( const TQTime &t ) const
+
+    Returns TRUE if this time is earlier than or equal to \a t;
+    otherwise returns FALSE.
+*/
+
+/*!
+    \fn bool TQTime::operator>( const TQTime &t ) const
+
+    Returns TRUE if this time is later than \a t; otherwise returns FALSE.
+*/
+
+/*!
+    \fn bool TQTime::operator>=( const TQTime &t ) const
+
+    Returns TRUE if this time is later than or equal to \a t;
+    otherwise returns FALSE.
+*/
+
+
+
+/*!
+    \overload
+
+    Returns the current time as reported by the system clock.
+
+    Note that the accuracy depends on the accuracy of the underlying
+    operating system; not all systems provide 1-millisecond accuracy.
+*/
+
+TQTime TQTime::currentTime()
+{
+    return currentTime( TQt::LocalTime );
+}
+
+/*!
+  Returns the current time as reported by the system clock, for the
+  TimeSpec \a ts. The default TimeSpec is LocalTime.
+
+  Note that the accuracy depends on the accuracy of the underlying
+  operating system; not all systems provide 1-millisecond accuracy.
+
+  \sa TQt::TimeSpec
+*/
+TQTime TQTime::currentTime( TQt::TimeSpec ts )
+{
+    TQTime t;
+    currentTime( &t, ts );
+    return t;
+}
+
+#ifndef TQT_NO_DATESTRING
+/*!
+    Returns the representation \a s as a TQTime using the format \a f,
+    or an invalid time if this is not possible.
+
+    \warning Note that \c TQt::LocalDate cannot be used here.
+*/
+TQTime TQTime::fromString( const TQString& s, TQt::DateFormat f )
+{
+    if ( ( s.isEmpty() ) || ( f == TQt::LocalDate ) ) {
+#if defined(TQT_CHECK_RANGE)
+	qWarning( "TQTime::fromString: Parameter out of range" );
+#endif
+	TQTime t;
+	t.ds = MSECS_PER_DAY;
+	return t;
+    }
+
+    int hour( s.mid( 0, 2 ).toInt() );
+    int minute( s.mid( 3, 2 ).toInt() );
+    int second( s.mid( 6, 2 ).toInt() );
+    int msec( s.mid( 9, 3 ).toInt() );
+    return TQTime( hour, minute, second, msec );
+}
+#endif
+
+/*!
+  \internal
+  \obsolete
+
+  Fetches the current time and returns TRUE if the time is within one
+  minute after midnight, otherwise FALSE. The return value is used by
+  TQDateTime::tqcurrentDateTime() to ensure that the date there is correct.
+*/
+
+bool TQTime::currentTime( TQTime *ct )
+{
+    return currentTime( ct, TQt::LocalTime );
+}
+
+
+/*!
+  \internal
+
+  Fetches the current time, for the TimeSpec \a ts, and returns TRUE
+  if the time is within one minute after midnight, otherwise FALSE. The
+  return value is used by TQDateTime::tqcurrentDateTime() to ensure that
+  the date there is correct. The default TimeSpec is LocalTime.
+
+  \sa TQt::TimeSpec
+*/
+bool TQTime::currentTime( TQTime *ct, TQt::TimeSpec ts )
+{
+    if ( !ct ) {
+#if defined(TQT_CHECK_NULL)
+	qWarning( "TQTime::currentTime(TQTime *): Null pointer not allowed" );
+#endif
+	return FALSE;
+    }
+
+#if defined(TQ_OS_WIN32)
+    SYSTEMTIME t;
+    if ( ts == TQt::LocalTime ) {
+	GetLocalTime( &t );
+    } else {
+	GetSystemTime( &t );
+    }
+    ct->ds = (uint)( MSECS_PER_HOUR*t.wHour + MSECS_PER_MIN*t.wMinute +
+		     1000*t.wSecond + t.wMilliseconds );
+#elif defined(TQ_OS_UNIX)
+    // posix compliant system
+    struct timeval tv;
+    gettimeofday( &tv, 0 );
+    time_t ltime = tv.tv_sec;
+    tm *t;
+
+#  if defined(TQT_THREAD_SUPPORT) && defined(_POSIX_THREAD_SAFE_FUNCTIONS)
+    // use the reentrant versions of localtime() and gmtime() where available
+    tm res;
+    if ( ts == TQt::LocalTime )
+	t = localtime_r( &ltime, &res );
+    else
+	t = gmtime_r( &ltime, &res );
+#  else
+    if ( ts == TQt::LocalTime )
+	t = localtime( &ltime );
+    else
+	t = gmtime( &ltime );
+#  endif // TQT_THREAD_SUPPORT && _POSIX_THREAD_SAFE_FUNCTIONS
+
+    ct->ds = (uint)( MSECS_PER_HOUR * t->tm_hour + MSECS_PER_MIN * t->tm_min +
+		     1000 * t->tm_sec + tv.tv_usec / 1000 );
+#else
+    time_t ltime; // no millisecond resolution
+    ::time( &ltime );
+    tm *t;
+    if ( ts == TQt::LocalTime )
+	localtime( &ltime );
+    else
+	gmtime( &ltime );
+    ct->ds = (uint) ( MSECS_PER_HOUR * t->tm_hour + MSECS_PER_MIN * t->tm_min +
+		      1000 * t->tm_sec );
+#endif
+    // 00:00.00 to 00:00.59.999 is considered as "midnight or right after"
+    return ct->ds < (uint) MSECS_PER_MIN;
+}
+
+/*!
+    \overload
+
+    Returns TRUE if the specified time is valid; otherwise returns
+    FALSE.
+
+    The time is valid if \a h is in the range 0..23, \a m and \a s are
+    in the range 0..59, and \a ms is in the range 0..999.
+
+    Example:
+    \code
+    TQTime::isValid(21, 10, 30); // returns TRUE
+    TQTime::isValid(22, 5,  62); // returns FALSE
+    \endcode
+*/
+
+bool TQTime::isValid( int h, int m, int s, int ms )
+{
+    return (uint)h < 24 && (uint)m < 60 && (uint)s < 60 && (uint)ms < 1000;
+}
+
+
+/*!
+    Sets this time to the current time. This is practical for timing:
+
+    \code
+    TQTime t;
+    t.start();
+    some_lengthy_task();
+    qDebug( "Time elapsed: %d ms", t.elapsed() );
+    \endcode
+
+    \sa restart(), elapsed(), currentTime()
+*/
+
+void TQTime::start()
+{
+    *this = currentTime();
+}
+
+/*!
+    Sets this time to the current time and returns the number of
+    milliseconds that have elapsed since the last time start() or
+    restart() was called.
+
+    This function is guaranteed to be atomic and is thus very handy
+    for repeated measurements. Call start() to start the first
+    measurement and then restart() for each later measurement.
+
+    Note that the counter wraps to zero 24 hours after the last call
+    to start() or restart().
+
+    \warning If the system's clock setting has been changed since the
+    last time start() or restart() was called, the result is
+    undefined. This can happen when daylight savings time is turned on
+    or off.
+
+    \sa start(), elapsed(), currentTime()
+*/
+
+int TQTime::restart()
+{
+    TQTime t = currentTime();
+    int n = msecsTo( t );
+    if ( n < 0 )				// passed midnight
+	n += 86400*1000;
+    *this = t;
+    return n;
+}
+
+/*!
+    Returns the number of milliseconds that have elapsed since the
+    last time start() or restart() was called.
+
+    Note that the counter wraps to zero 24 hours after the last call
+    to start() or restart.
+
+    Note that the accuracy depends on the accuracy of the underlying
+    operating system; not all systems provide 1-millisecond accuracy.
+
+    \warning If the system's clock setting has been changed since the
+    last time start() or restart() was called, the result is
+    undefined. This can happen when daylight savings time is turned on
+    or off.
+
+    \sa start(), restart()
+*/
+
+int TQTime::elapsed() const
+{
+    int n = msecsTo( currentTime() );
+    if ( n < 0 )				// passed midnight
+	n += 86400*1000;
+    return n;
+}
+
+
+/*****************************************************************************
+  TQDateTime member functions
+ *****************************************************************************/
+
+/*!
+    \class TQDateTime tqdatetime.h
+    \reentrant
+    \brief The TQDateTime class provides date and time functions.
+
+    \ingroup time
+    \mainclass
+
+    A TQDateTime object tqcontains a calendar date and a clock time (a
+    "datetime"). It is a combination of the TQDate and TQTime classes.
+    It can read the current datetime from the system clock. It
+    provides functions for comparing datetimes and for manipulating a
+    datetime by adding a number of seconds, days, months or years.
+
+    A TQDateTime object is typically created either by giving a date
+    and time explicitly in the constructor, or by using the static
+    function tqcurrentDateTime(), which returns a TQDateTime object set
+    to the system clock's time. The date and time can be changed with
+    setDate() and setTime(). A datetime can also be set using the
+    setTime_t() function, which takes a POSIX-standard "number of
+    seconds since 00:00:00 on January 1, 1970" value. The fromString()
+    function returns a TQDateTime given a string and a date format
+    which is used to interpret the date within the string.
+
+    The date() and time() functions provide access to the date and
+    time parts of the datetime. The same information is provided in
+    textual format by the toString() function.
+
+    TQDateTime provides a full set of operators to compare two
+    TQDateTime objects where smaller means earlier and larger means
+    later.
+
+    You can increment (or decrement) a datetime by a given number of
+    seconds using addSecs() or days using addDays(). Similarly you can
+    use addMonths() and addYears(). The daysTo() function returns the
+    number of days between two datetimes, and secsTo() returns the
+    number of seconds between two datetimes.
+
+    The range of a datetime object is constrained to the ranges of the
+    TQDate and TQTime objects which it embodies.
+
+    \sa TQDate TQTime TQDateTimeEdit
+*/
+
+
+/*!
+    \fn TQDateTime::TQDateTime()
+
+    Constructs a null datetime (i.e. null date and null time). A null
+    datetime is invalid, since the date is invalid.
+
+    \sa isValid()
+*/
+
+
+/*!
+    Constructs a datetime with date \a date and null (but valid) time
+    (00:00:00.000).
+*/
+
+TQDateTime::TQDateTime( const TQDate &date )
+    : d(date)
+{
+}
+
+/*!
+    Constructs a datetime with date \a date and time \a time.
+*/
+
+TQDateTime::TQDateTime( const TQDate &date, const TQTime &time )
+    : d(date), t(time)
+{
+}
+
+
+/*!
+    \fn bool TQDateTime::isNull() const
+
+    Returns TRUE if both the date and the time are null; otherwise
+    returns FALSE. A null datetime is invalid.
+
+    \sa TQDate::isNull(), TQTime::isNull()
+*/
+
+/*!
+    \fn bool TQDateTime::isValid() const
+
+    Returns TRUE if both the date and the time are valid; otherwise
+    returns FALSE.
+
+    \sa TQDate::isValid(), TQTime::isValid()
+*/
+
+/*!
+    \fn TQDate TQDateTime::date() const
+
+    Returns the date part of the datetime.
+
+    \sa setDate(), time()
+*/
+
+/*!
+    \fn TQTime TQDateTime::time() const
+
+    Returns the time part of the datetime.
+
+    \sa setTime(), date()
+*/
+
+/*!
+    \fn void TQDateTime::setDate( const TQDate &date )
+
+    Sets the date part of this datetime to \a date.
+
+    \sa date(), setTime()
+*/
+
+/*!
+    \fn void TQDateTime::setTime( const TQTime &time )
+
+    Sets the time part of this datetime to \a time.
+
+    \sa time(), setDate()
+*/
+
+
+/*!
+    Returns the datetime as the number of seconds that have passed
+    since 1970-01-01T00:00:00, Coordinated Universal Time (UTC).
+
+    On systems that do not support timezones, this function will
+    behave as if local time were UTC.
+
+    \sa setTime_t()
+*/
+
+uint TQDateTime::toTime_t() const
+{
+    tm brokenDown;
+    brokenDown.tm_sec = t.second();
+    brokenDown.tm_min = t.minute();
+    brokenDown.tm_hour = t.hour();
+    brokenDown.tm_mday = d.day();
+    brokenDown.tm_mon = d.month() - 1;
+    brokenDown.tm_year = d.year() - 1900;
+    brokenDown.tm_isdst = -1;
+    int secsSince1Jan1970UTC = (int) mktime( &brokenDown );
+    if ( secsSince1Jan1970UTC < -1 )
+	secsSince1Jan1970UTC = -1;
+    return (uint) secsSince1Jan1970UTC;
+}
+
+/*!
+    \overload
+
+    Convenience function that sets the date and time to local time
+    based on the given UTC time.
+*/
+
+void TQDateTime::setTime_t( uint secsSince1Jan1970UTC )
+{
+    setTime_t( secsSince1Jan1970UTC, TQt::LocalTime );
+}
+
+/*!
+    Sets the date and time to \a ts time (\c TQt::LocalTime or \c
+    TQt::UTC) given the number of seconds that have passed since
+    1970-01-01T00:00:00, Coordinated Universal Time (UTC). On systems
+    that do not support timezones this function will behave as if
+    local time were UTC.
+
+    On Windows, only a subset of \a secsSince1Jan1970UTC values are
+    supported, as Windows starts counting from 1980.
+
+    \sa toTime_t()
+*/
+void TQDateTime::setTime_t( uint secsSince1Jan1970UTC, TQt::TimeSpec ts )
+{
+    time_t tmp = (time_t) secsSince1Jan1970UTC;
+    tm *brokenDown = 0;
+
+#if defined(TQ_OS_UNIX) && defined(TQT_THREAD_SUPPORT) && defined(_POSIX_THREAD_SAFE_FUNCTIONS)
+    // posix compliant system
+    // use the reentrant versions of localtime() and gmtime() where available
+    tm res;
+    if ( ts == TQt::LocalTime )
+	brokenDown = localtime_r( &tmp, &res );
+    if ( !brokenDown ) {
+	brokenDown = gmtime_r( &tmp, &res );
+	if ( !brokenDown ) {
+	    d.jd = TQDate::gregorianToJulian( 1970, 1, 1 );
+	    t.ds = 0;
+	    return;
+	}
+    }
+#else
+    if ( ts == TQt::LocalTime )
+	brokenDown = localtime( &tmp );
+    if ( !brokenDown ) {
+	brokenDown = gmtime( &tmp );
+	if ( !brokenDown ) {
+	    d.jd = TQDate::gregorianToJulian( 1970, 1, 1 );
+	    t.ds = 0;
+	    return;
+	}
+    }
+#endif
+
+    d.jd = TQDate::gregorianToJulian( brokenDown->tm_year + 1900,
+				     brokenDown->tm_mon + 1,
+				     brokenDown->tm_mday );
+    t.ds = MSECS_PER_HOUR * brokenDown->tm_hour +
+	   MSECS_PER_MIN * brokenDown->tm_min +
+	   1000 * brokenDown->tm_sec;
+}
+#ifndef TQT_NO_DATESTRING
+#ifndef TQT_NO_SPRINTF
+/*!
+    \overload
+
+    Returns the datetime as a string. The \a f parameter determines
+    the format of the string.
+
+    If \a f is \c TQt::TextDate, the string format is "Wed May 20
+    03:40:13 1998" (using TQDate::shortDayName(), TQDate::shortMonthName(),
+    and TQTime::toString() to generate the string, so the day and month
+    names will have localized names).
+
+    If \a f is \c TQt::ISODate, the string format corresponds to the
+    ISO 8601 extended specification for representations of dates and
+    times, which is YYYY-MM-DDTHH:MM:SS.
+
+    If \a f is \c TQt::LocalDate, the string format depends on the
+    locale settings of the system.
+
+    If the format \a f is invalid or the datetime is invalid, toString()
+    returns a null string.
+
+    \sa TQDate::toString() TQTime::toString()
+*/
+
+TQString TQDateTime::toString( TQt::DateFormat f ) const
+{
+    if ( !isValid() )
+	return TQString::null;
+
+    if ( f == TQt::ISODate ) {
+	return d.toString( TQt::ISODate ) + "T" + t.toString( TQt::ISODate );
+    }
+#ifndef TQT_NO_TEXTDATE
+    else if ( f == TQt::TextDate ) {
+#ifndef TQ_WS_WIN
+	TQString buf = d.shortDayName( d.dayOfWeek() );
+	buf += ' ';
+	buf += d.shortMonthName( d.month() );
+	buf += ' ';
+	buf += TQString().setNum( d.day() );
+	buf += ' ';
+#else
+	TQString buf;
+	TQString winstr;
+	TQT_WA( {
+	    TCHAR out[255];
+	    GetLocaleInfo( LOCALE_USER_DEFAULT, LOCALE_ILDATE, out, 255 );
+	    winstr = TQString::fromUcs2( (ushort*)out );
+	} , {
+	    char out[255];
+	    GetLocaleInfoA( LOCALE_USER_DEFAULT, LOCALE_ILDATE, (char*)&out, 255 );
+	    winstr = TQString::fromLocal8Bit( out );
+	} );
+	switch ( winstr.toInt() ) {
+	case 1:
+	    buf = d.shortDayName( d.dayOfWeek() ) + " " + TQString().setNum( d.day() ) + ". " + d.shortMonthName( d.month() ) + " ";
+	    break;
+	default:
+	    buf = d.shortDayName( d.dayOfWeek() ) + " " + d.shortMonthName( d.month() ) + " " + TQString().setNum( d.day() ) + " ";
+	    break;
+	}
+#endif
+	buf += t.toString();
+	buf += ' ';
+	buf += TQString().setNum( d.year() );
+	return buf;
+    }
+#endif
+    else if ( f == TQt::LocalDate ) {
+	return d.toString( TQt::LocalDate ) + " " + t.toString( TQt::LocalDate );
+    }
+    return TQString::null;
+}
+#endif
+
+/*!
+    Returns the datetime as a string. The \a format parameter
+    determines the format of the result string.
+
+    These expressions may be used for the date:
+
+    \table
+    \header \i Expression \i Output
+    \row \i d \i the day as number without a leading zero (1-31)
+    \row \i dd \i the day as number with a leading zero (01-31)
+    \row \i ddd
+	    \i the abbreviated localized day name (e.g. 'Mon'..'Sun').
+	    Uses TQDate::shortDayName().
+    \row \i dddd
+	    \i the long localized day name (e.g. 'Monday'..'Sunday').
+	    Uses TQDate::longDayName().
+    \row \i M \i the month as number without a leading zero (1-12)
+    \row \i MM \i the month as number with a leading zero (01-12)
+    \row \i MMM
+	    \i the abbreviated localized month name (e.g. 'Jan'..'Dec').
+	    Uses TQDate::shortMonthName().
+    \row \i MMMM
+	    \i the long localized month name (e.g. 'January'..'December').
+	    Uses TQDate::longMonthName().
+    \row \i yy \i the year as two digit number (00-99)
+    \row \i yyyy \i the year as four digit number (1752-8000)
+    \endtable
+
+    These expressions may be used for the time:
+
+    \table
+    \header \i Expression \i Output
+    \row \i h
+	    \i the hour without a leading zero (0..23 or 1..12 if AM/PM display)
+    \row \i hh
+	    \i the hour with a leading zero (00..23 or 01..12 if AM/PM display)
+    \row \i m \i the minute without a leading zero (0..59)
+    \row \i mm \i the minute with a leading zero (00..59)
+    \row \i s \i the second whithout a leading zero (0..59)
+    \row \i ss \i the second whith a leading zero (00..59)
+    \row \i z \i the milliseconds without leading zeroes (0..999)
+    \row \i zzz \i the milliseconds with leading zeroes (000..999)
+    \row \i AP
+	    \i use AM/PM display. \e AP will be tqreplaced by either "AM" or "PM".
+    \row \i ap
+	    \i use am/pm display. \e ap will be tqreplaced by either "am" or "pm".
+    \endtable
+
+    All other input characters will be ignored.
+
+    Example format strings (assumed that the TQDateTime is
+    21<small><sup>st</sup></small> May 2001 14:13:09)
+
+    \table
+    \header \i Format \i Result
+    \row \i dd.MM.yyyy	    \i11 21.05.2001
+    \row \i ddd MMMM d yy   \i11 Tue May 21 01
+    \row \i hh:mm:ss.zzz    \i11 14:13:09.042
+    \row \i h:m:s ap	    \i11 2:13:9 pm
+    \endtable
+
+    If the datetime is an invalid datetime, then TQString::null will be returned.
+
+    \sa TQDate::toString() TQTime::toString()
+*/
+TQString TQDateTime::toString( const TQString& format ) const
+{
+    return fmtDateTime( format, &t, &d );
+}
+#endif //TQT_NO_DATESTRING
+
+/*!
+    Returns a TQDateTime object containing a datetime \a ndays days
+    later than the datetime of this object (or earlier if \a ndays is
+    negative).
+
+    \sa daysTo(), addMonths(), addYears(), addSecs()
+*/
+
+TQDateTime TQDateTime::addDays( int ndays ) const
+{
+    return TQDateTime( d.addDays(ndays), t );
+}
+
+/*!
+    Returns a TQDateTime object containing a datetime \a nmonths months
+    later than the datetime of this object (or earlier if \a nmonths
+    is negative).
+
+    \sa daysTo(), addDays(), addYears(), addSecs()
+*/
+
+TQDateTime TQDateTime::addMonths( int nmonths ) const
+{
+    return TQDateTime( d.addMonths(nmonths), t );
+}
+
+/*!
+    Returns a TQDateTime object containing a datetime \a nyears years
+    later than the datetime of this object (or earlier if \a nyears is
+    negative).
+
+    \sa daysTo(), addDays(), addMonths(), addSecs()
+*/
+
+TQDateTime TQDateTime::addYears( int nyears ) const
+{
+    return TQDateTime( d.addYears(nyears), t );
+}
+
+/*!
+    Returns a TQDateTime object containing a datetime \a nsecs seconds
+    later than the datetime of this object (or earlier if \a nsecs is
+    negative).
+
+    \sa secsTo(), addDays(), addMonths(), addYears()
+*/
+
+TQDateTime TQDateTime::addSecs( int nsecs ) const
+{
+    uint dd = d.jd;
+    int  tt = t.ds;
+    int  sign = 1;
+    if ( nsecs < 0 ) {
+	nsecs = -nsecs;
+	sign = -1;
+    }
+    if ( nsecs >= (int)SECS_PER_DAY ) {
+	dd += sign*(nsecs/SECS_PER_DAY);
+	nsecs %= SECS_PER_DAY;
+    }
+    tt += sign*nsecs*1000;
+    if ( tt < 0 ) {
+	tt = MSECS_PER_DAY - tt - 1;
+	dd -= tt / MSECS_PER_DAY;
+	tt = tt % MSECS_PER_DAY;
+	tt = MSECS_PER_DAY - tt - 1;
+    } else if ( tt >= (int)MSECS_PER_DAY ) {
+	dd += ( tt / MSECS_PER_DAY );
+	tt = tt % MSECS_PER_DAY;
+    }
+    TQDateTime ret;
+    ret.t.ds = tt;
+    ret.d.jd = dd;
+    return ret;
+}
+
+/*!
+    Returns the number of days from this datetime to \a dt (which is
+    negative if \a dt is earlier than this datetime).
+
+    \sa addDays(), secsTo()
+*/
+
+int TQDateTime::daysTo( const TQDateTime &dt ) const
+{
+    return d.daysTo( dt.d );
+}
+
+/*!
+    Returns the number of seconds from this datetime to \a dt (which
+    is negative if \a dt is earlier than this datetime).
+
+    Example:
+    \code
+    TQDateTime dt = TQDateTime::tqcurrentDateTime();
+    TQDateTime xmas( TQDate(dt.date().year(),12,24), TQTime(17,00) );
+    qDebug( "There are %d seconds to Christmas", dt.secsTo(xmas) );
+    \endcode
+
+    \sa addSecs(), daysTo(), TQTime::secsTo()
+*/
+
+int TQDateTime::secsTo( const TQDateTime &dt ) const
+{
+    return t.secsTo(dt.t) + d.daysTo(dt.d)*SECS_PER_DAY;
+}
+
+
+/*!
+    Returns TRUE if this datetime is equal to \a dt; otherwise returns FALSE.
+
+    \sa operator!=()
+*/
+
+bool TQDateTime::operator==( const TQDateTime &dt ) const
+{
+    return  t == dt.t && d == dt.d;
+}
+
+/*!
+    Returns TRUE if this datetime is different from \a dt; otherwise
+    returns FALSE.
+
+    \sa operator==()
+*/
+
+bool TQDateTime::operator!=( const TQDateTime &dt ) const
+{
+    return  t != dt.t || d != dt.d;
+}
+
+/*!
+    Returns TRUE if this datetime is earlier than \a dt; otherwise
+    returns FALSE.
+*/
+
+bool TQDateTime::operator<( const TQDateTime &dt ) const
+{
+    if ( d < dt.d )
+	return TRUE;
+    return d == dt.d ? t < dt.t : FALSE;
+}
+
+/*!
+    Returns TRUE if this datetime is earlier than or equal to \a dt;
+    otherwise returns FALSE.
+*/
+
+bool TQDateTime::operator<=( const TQDateTime &dt ) const
+{
+    if ( d < dt.d )
+	return TRUE;
+    return d == dt.d ? t <= dt.t : FALSE;
+}
+
+/*!
+    Returns TRUE if this datetime is later than \a dt; otherwise
+    returns FALSE.
+*/
+
+bool TQDateTime::operator>( const TQDateTime &dt ) const
+{
+    if ( d > dt.d )
+	return TRUE;
+    return d == dt.d ? t > dt.t : FALSE;
+}
+
+/*!
+    Returns TRUE if this datetime is later than or equal to \a dt;
+    otherwise returns FALSE.
+*/
+
+bool TQDateTime::operator>=( const TQDateTime &dt ) const
+{
+    if ( d > dt.d )
+	return TRUE;
+    return d == dt.d ? t >= dt.t : FALSE;
+}
+
+/*!
+    \overload
+
+    Returns the current datetime, as reported by the system clock.
+
+    \sa TQDate::tqcurrentDate(), TQTime::currentTime()
+*/
+
+TQDateTime TQDateTime::tqcurrentDateTime()
+{
+    return tqcurrentDateTime( TQt::LocalTime );
+}
+
+/*!
+  Returns the current datetime, as reported by the system clock, for the
+  TimeSpec \a ts. The default TimeSpec is LocalTime.
+
+  \sa TQDate::tqcurrentDate(), TQTime::currentTime(), TQt::TimeSpec
+*/
+
+TQDateTime TQDateTime::tqcurrentDateTime( TQt::TimeSpec ts )
+{
+    TQDateTime dt;
+    TQTime t;
+    dt.setDate( TQDate::tqcurrentDate(ts) );
+    if ( TQTime::currentTime(&t, ts) )         // midnight or right after?
+	dt.setDate( TQDate::tqcurrentDate(ts) ); // fetch date again
+    dt.setTime( t );
+    return dt;
+}
+
+#ifndef TQT_NO_DATESTRING
+/*!
+    Returns the TQDateTime represented by the string \a s, using the
+    format \a f, or an invalid datetime if this is not possible.
+
+    Note for \c TQt::TextDate: It is recommended that you use the
+    English short month names (e.g. "Jan"). Although localized month
+    names can also be used, they depend on the user's locale settings.
+
+    \warning Note that \c TQt::LocalDate cannot be used here.
+*/
+TQDateTime TQDateTime::fromString( const TQString& s, TQt::DateFormat f )
+{
+    if ( ( s.isEmpty() ) || ( f == TQt::LocalDate ) ) {
+#if defined(TQT_CHECK_RANGE)
+	qWarning( "TQDateTime::fromString: Parameter out of range" );
+#endif
+	TQDateTime dt;
+	dt.d.jd = 0;
+	return dt;
+    }
+    if ( f == TQt::ISODate ) {
+	return TQDateTime( TQDate::fromString( s.mid(0,10), TQt::ISODate ),
+			  TQTime::fromString( s.mid(11), TQt::ISODate ) );
+    }
+#if !defined(TQT_NO_REGEXP) && !defined(TQT_NO_TEXTDATE)
+    else if ( f == TQt::TextDate ) {
+        const int firstSpace = s.tqfind(' ');
+	TQString monthName( s.mid( firstSpace + 1, 3 ) );
+	int month = -1;
+	// Assume that English monthnames are the default
+	for ( int i = 0; i < 12; ++i ) {
+	    if ( monthName == qt_shortMonthNames[i] ) {
+		month = i + 1;
+		break;
+	    }
+	}
+	// If English names can't be found, search the localized ones
+	if ( month == -1 ) {
+	    for ( int i = 1; i <= 12; ++i ) {
+		if ( monthName == TQDate::shortMonthName( i ) ) {
+		    month = i;
+		    break;
+		}
+	    }
+	}
+#if defined(TQT_CHECK_RANGE)
+	if ( month < 1 || month > 12 ) {
+	    qWarning( "TQDateTime::fromString: Parameter out of range" );
+	    TQDateTime dt;
+	    dt.d.jd = 0;
+	    return dt;
+	}
+#endif
+	int day = TQT_TQSTRING(s.mid( firstSpace + 5, 2 )).simplifyWhiteSpace().toInt();
+	int year = s.right( 4 ).toInt();
+	TQDate date( year, month, day );
+	TQTime time;
+	int hour, minute, second;
+	int pivot = s.tqfind( TQRegExp(TQString::tqfromLatin1("[0-9][0-9]:[0-9][0-9]:[0-9][0-9]")) );
+	if ( pivot != -1 ) {
+	    hour = s.mid( pivot, 2 ).toInt();
+	    minute = s.mid( pivot+3, 2 ).toInt();
+	    second = s.mid( pivot+6, 2 ).toInt();
+	    time.setHMS( hour, minute, second );
+	}
+	return TQDateTime( date, time );
+    }
+#endif //TQT_NO_REGEXP
+    return TQDateTime();
+}
+#endif //TQT_NO_DATESTRING
+
+
+/*****************************************************************************
+  Date/time stream functions
+ *****************************************************************************/
+
+#ifndef TQT_NO_DATASTREAM
+/*!
+    \relates TQDate
+
+    Writes the date, \a d, to the data stream, \a s.
+
+    \sa \link datastreamformat.html Format of the TQDataStream operators \endlink
+*/
+
+TQDataStream &operator<<( TQDataStream &s, const TQDate &d )
+{
+    return s << (TQ_UINT32)(d.jd);
+}
+
+/*!
+    \relates TQDate
+
+    Reads a date from the stream \a s into \a d.
+
+    \sa \link datastreamformat.html Format of the TQDataStream operators \endlink
+*/
+
+TQDataStream &operator>>( TQDataStream &s, TQDate &d )
+{
+    TQ_UINT32 jd;
+    s >> jd;
+    d.jd = jd;
+    return s;
+}
+
+/*!
+    \relates TQTime
+
+    Writes time \a t to the stream \a s.
+
+    \sa \link datastreamformat.html Format of the TQDataStream operators \endlink
+*/
+
+TQDataStream &operator<<( TQDataStream &s, const TQTime &t )
+{
+    return s << (TQ_UINT32)(t.ds);
+}
+
+/*!
+    \relates TQTime
+
+    Reads a time from the stream \a s into \a t.
+
+    \sa \link datastreamformat.html Format of the TQDataStream operators \endlink
+*/
+
+TQDataStream &operator>>( TQDataStream &s, TQTime &t )
+{
+    TQ_UINT32 ds;
+    s >> ds;
+    t.ds = ds;
+    return s;
+}
+
+/*!
+    \relates TQDateTime
+
+    Writes the datetime \a dt to the stream \a s.
+
+    \sa \link datastreamformat.html Format of the TQDataStream operators \endlink
+*/
+
+TQDataStream &operator<<( TQDataStream &s, const TQDateTime &dt )
+{
+    return s << dt.d << dt.t;
+}
+
+/*!
+    \relates TQDateTime
+
+    Reads a datetime from the stream \a s into \a dt.
+
+    \sa \link datastreamformat.html Format of the TQDataStream operators \endlink
+*/
+
+TQDataStream &operator>>( TQDataStream &s, TQDateTime &dt )
+{
+    s >> dt.d >> dt.t;
+    return s;
+}
+#endif //TQT_NO_DATASTREAM
+
+#endif // USE_QT4
\ No newline at end of file
diff --git a/tqtinterface/qt4/src/tools/tqdatetime.h b/tqtinterface/qt4/src/tools/tqdatetime.h
new file mode 100644
index 0000000..aaf0727
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqdatetime.h
@@ -0,0 +1,374 @@
+/*************************************************************************
+**
+** Definition of date and time classes
+**
+** Created : 940124
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQDATETIME_H
+#define TQDATETIME_H
+
+#include "tqtglobaldefines.h"
+
+#ifndef TQT_H
+#include "tqstring.h"
+#include "tqnamespace.h"
+#endif // TQT_H
+
+#ifdef USE_QT4
+
+#include <Qt/qdatetime.h>
+
+#endif // USE_QT4
+
+
+#ifdef USE_QT4
+
+class TQ_EXPORT TQDate : public QDate
+{
+public:
+	TQDate() : QDate() {}
+	TQDate( QDate date ) : QDate(date) {}
+	TQDate( int y, int m, int d ) : QDate( y, m, d ) {}
+
+	inline static TQString monthName(int month) { return shortMonthName(month); }
+	inline static TQString dayName(int weekday) { return shortDayName(weekday); }
+	inline static bool leapYear(int year) { return isLeapYear(year); }
+
+	static inline TQDate currentDate() { return TQT_TQDATE_OBJECT(QDate::currentDate()); }
+	static inline TQDate tqcurrentDate() { return currentDate(); }
+	static inline TQDate fromString( const TQString& s, Qt::DateFormat f = Qt::TextDate ) { return TQT_TQDATE_OBJECT(QDate::fromString(s, f)); }
+	static TQDate currentDate(Qt::TimeSpec spec);
+	static inline TQDate tqcurrentDate(Qt::TimeSpec spec) { return currentDate(spec); }
+
+	inline TQDate addDays( int days ) const { return TQT_TQDATE_OBJECT(addDays(days)); }
+	inline TQDate addMonths( int months ) const { return TQT_TQDATE_OBJECT(addMonths(months)); }
+	inline TQDate addYears( int years ) const { return TQT_TQDATE_OBJECT(addYears(years)); }
+
+	// Interoperability
+	inline static TQDate convertFromQDate( QDate q ) {
+		return (*static_cast<TQDate*>(&q));
+	}
+	inline static TQDate& convertFromQDate( QDate& q ) {
+		return (*static_cast<TQDate*>(&q));
+	}
+};
+
+class TQ_EXPORT TQTime : public QTime
+{
+public:
+	TQTime() : QTime() {}
+	TQTime( QTime time ) : QTime(time) {}
+	TQTime( int h, int m, int s=0, int ms=0 ) : QTime ( h, m, s, ms ) {}
+
+	inline static TQTime currentTime() { return TQT_TQTIME_OBJECT(QTime::currentTime()); }
+	inline static TQTime tqcurrentTime() { return currentTime(); }
+	inline static TQTime fromString( const TQString& s, Qt::DateFormat f = Qt::TextDate ) { return TQT_TQTIME_OBJECT(QTime::fromString(s, f)); }
+	static TQTime currentTime(Qt::TimeSpec spec);
+	inline static TQTime tqcurrentTime(Qt::TimeSpec spec) { return currentTime(spec); }
+
+	// Interoperability
+	inline static TQTime convertFromQTime( QTime q ) {
+		return (*static_cast<TQTime*>(&q));
+	}
+	inline static TQTime& convertFromQTime( QTime& q ) {
+		return (*static_cast<TQTime*>(&q));
+	}
+};
+
+class TQ_EXPORT TQDateTime : public QDateTime
+{
+public:
+	TQDateTime() : QDateTime() {}
+	TQDateTime( const QDateTime &dt ) : QDateTime ( dt ) {}
+	TQDateTime( const QDate &date ) : QDateTime ( date ) {}
+	TQDateTime( const QDate &date, const QTime &time ) : QDateTime( date, time ) {}
+
+	void setTime_t(uint secsSince1Jan1970UTC) { QDateTime::setTime_t(secsSince1Jan1970UTC); }
+	static inline TQDateTime tqcurrentDateTime() { return TQT_TQDATETIME_OBJECT(QDateTime::currentDateTime()); }
+	inline void setTime_t(uint secsSince1Jan1970UTC, Qt::TimeSpec spec) {
+		setTime_t(secsSince1Jan1970UTC);
+		if (spec == Qt::UTC)
+			*this = TQT_TQDATETIME_OBJECT(toUTC());
+	}
+	static inline TQDateTime tqcurrentDateTime(Qt::TimeSpec spec) {
+		if (spec == Qt::LocalTime)
+			return tqcurrentDateTime();
+		else
+			return TQT_TQDATETIME_OBJECT(currentDateTime().toUTC());
+	}
+
+	static inline TQDateTime fromString( const QString s, Qt::DateFormat f = Qt::TextDate ) { return TQT_TQDATETIME_OBJECT(QDateTime::fromString(s, f)); }
+
+	inline TQString toString(Qt::DateFormat f = Qt::TextDate) const { return QDateTime::toString(f); }
+	inline TQString toString(const QString &format) const { return QDateTime::toString(format); }
+
+	TQDate date() const { return TQT_TQDATE_OBJECT(QDateTime::date()); }
+	TQTime time() const { return TQT_TQTIME_OBJECT(QDateTime::time()); }
+
+	// Interoperability
+	inline static TQDateTime convertFromQDateTime( QDateTime q ) {
+		return (*static_cast<TQDateTime*>(&q));
+	}
+	inline static TQDateTime& convertFromQDateTime( QDateTime& q ) {
+		return (*static_cast<TQDateTime*>(&q));
+	}
+};
+
+inline TQDate TQDate::currentDate(Qt::TimeSpec spec)
+{
+    if (spec == Qt::LocalTime)
+        return TQT_TQDATE_OBJECT(currentDate());
+    else
+        return TQT_TQDATE_OBJECT(QDateTime::currentDateTime().toUTC().date());
+}
+
+inline TQTime TQTime::currentTime(Qt::TimeSpec spec)
+{
+    if (spec == Qt::LocalTime)
+        return TQT_TQTIME_OBJECT(currentTime());
+    else
+        return TQT_TQTIME_OBJECT(QDateTime::currentDateTime().toUTC().time());
+}
+
+#else // USE_QT4
+
+/*****************************************************************************
+  TQDate class
+ *****************************************************************************/
+
+class TQ_EXPORT TQDate
+{
+public:
+    TQDate() { jd = 0; }
+    TQDate( int y, int m, int d );
+
+    bool isNull() const { return jd == 0; }
+    bool isValid() const;
+
+    int year() const;
+    int month() const;
+    int day() const;
+    int dayOfWeek() const;
+    int dayOfYear() const;
+    int daysInMonth() const;
+    int daysInYear() const;
+    int weekNumber( int *yearNum = 0 ) const;
+
+#ifndef TQT_NO_TEXTDATE
+#ifndef TQT_NO_COMPAT
+    static TQString monthName( int month ) { return shortMonthName( month ); }
+    static TQString dayName( int weekday ) { return shortDayName( weekday ); }
+#endif
+    static TQString shortMonthName( int month );
+    static TQString shortDayName( int weekday );
+    static TQString longMonthName( int month );
+    static TQString longDayName( int weekday );
+#endif //TQT_NO_TEXTDATE
+#ifndef TQT_NO_TEXTSTRING
+#if !defined(TQT_NO_SPRINTF)
+    TQString toString( TQt::DateFormat f = TQt::TextDate ) const;
+#endif
+    TQString toString( const TQString& format ) const;
+#endif
+    bool   setYMD( int y, int m, int d );
+
+    TQDate  addDays( int days )		const;
+    TQDate  addMonths( int months )      const;
+    TQDate  addYears( int years )        const;
+    int	   daysTo( const TQDate & )	const;
+
+    bool   operator==( const TQDate &d ) const { return jd == d.jd; }
+    bool   operator!=( const TQDate &d ) const { return jd != d.jd; }
+    bool   operator<( const TQDate &d )	const { return jd < d.jd; }
+    bool   operator<=( const TQDate &d ) const { return jd <= d.jd; }
+    bool   operator>( const TQDate &d )	const { return jd > d.jd; }
+    bool   operator>=( const TQDate &d ) const { return jd >= d.jd; }
+
+    static TQDate currentDate();
+    static TQDate currentDate( TQt::TimeSpec );
+#ifndef TQT_NO_DATESTRING
+    static TQDate fromString( const TQString& s, TQt::DateFormat f = TQt::TextDate );
+#endif
+    static bool	 isValid( int y, int m, int d );
+    static bool	 leapYear( int year );
+
+    static uint	 gregorianToJulian( int y, int m, int d );
+    static void	 julianToGregorian( uint jd, int &y, int &m, int &d );
+private:
+    uint	 jd;
+    friend class TQDateTime;
+#ifndef TQT_NO_DATASTREAM
+    friend TQ_EXPORT TQDataStream &operator<<( TQDataStream &, const TQDate & );
+    friend TQ_EXPORT TQDataStream &operator>>( TQDataStream &, TQDate & );
+#endif
+};
+
+
+/*****************************************************************************
+  TQTime class
+ *****************************************************************************/
+
+class TQ_EXPORT TQTime
+{
+public:
+    TQTime() { ds=0; }				// set null time
+    TQTime( int h, int m, int s=0, int ms=0 );	// set time
+
+    bool   isNull()	 const { return ds == 0; }
+    bool   isValid()	 const;			// valid time
+
+    int	   hour()	 const;			// 0..23
+    int	   minute()	 const;			// 0..59
+    int	   second()	 const;			// 0..59
+    int	   msec()	 const;			// 0..999
+#ifndef TQT_NO_DATESTRING
+#ifndef TQT_NO_SPRINTF
+    TQString toString( TQt::DateFormat f = TQt::TextDate )	 const;
+#endif
+    TQString toString( const TQString& format ) const;
+#endif
+    bool   setHMS( int h, int m, int s, int ms=0 );
+
+    TQTime  addSecs( int secs )		const;
+    int	   secsTo( const TQTime & )	const;
+    TQTime  addMSecs( int ms )		const;
+    int	   msecsTo( const TQTime & )	const;
+
+    bool   operator==( const TQTime &d ) const { return ds == d.ds; }
+    bool   operator!=( const TQTime &d ) const { return ds != d.ds; }
+    bool   operator<( const TQTime &d )	const { return ds < d.ds; }
+    bool   operator<=( const TQTime &d ) const { return ds <= d.ds; }
+    bool   operator>( const TQTime &d )	const { return ds > d.ds; }
+    bool   operator>=( const TQTime &d ) const { return ds >= d.ds; }
+
+    static TQTime currentTime();
+    static TQTime currentTime( TQt::TimeSpec );
+#ifndef TQT_NO_DATESTRING
+    static TQTime fromString( const TQString& s, TQt::DateFormat f = TQt::TextDate );
+#endif
+    static bool	 isValid( int h, int m, int s, int ms=0 );
+
+    void   start();
+    int	   restart();
+    int	   elapsed() const;
+
+private:
+    static bool currentTime( TQTime * );
+    static bool currentTime( TQTime *, TQt::TimeSpec );
+
+    uint   ds;
+    friend class TQDateTime;
+#ifndef TQT_NO_DATASTREAM
+    friend TQ_EXPORT TQDataStream &operator<<( TQDataStream &, const TQTime & );
+    friend TQ_EXPORT TQDataStream &operator>>( TQDataStream &, TQTime & );
+#endif
+};
+
+
+/*****************************************************************************
+  TQDateTime class
+ *****************************************************************************/
+
+class TQ_EXPORT TQDateTime
+{
+public:
+    TQDateTime() {}				// set null date and null time
+    TQDateTime( const TQDate & );
+    TQDateTime( const TQDate &, const TQTime & );
+
+    bool   isNull()	const		{ return d.isNull() && t.isNull(); }
+    bool   isValid()	const		{ return d.isValid() && t.isValid(); }
+
+    TQDate  date()	const		{ return d; }
+    TQTime  time()	const		{ return t; }
+    uint   toTime_t()	const;
+    void   setDate( const TQDate &date ) { d = date; }
+    void   setTime( const TQTime &time ) { t = time; }
+    void   setTime_t( uint secsSince1Jan1970UTC );
+    void   setTime_t( uint secsSince1Jan1970UTC, TQt::TimeSpec );
+#ifndef TQT_NO_DATESTRING
+#ifndef TQT_NO_SPRINTF
+    TQString toString( TQt::DateFormat f = TQt::TextDate )	const;
+#endif
+    TQString toString( const TQString& format ) const;
+#endif
+    TQDateTime addDays( int days )	const;
+    TQDateTime addMonths( int months )   const;
+    TQDateTime addYears( int years )     const;
+    TQDateTime addSecs( int secs )	const;
+    int	   daysTo( const TQDateTime & )	const;
+    int	   secsTo( const TQDateTime & )	const;
+
+    bool   operator==( const TQDateTime &dt ) const;
+    bool   operator!=( const TQDateTime &dt ) const;
+    bool   operator<( const TQDateTime &dt )  const;
+    bool   operator<=( const TQDateTime &dt ) const;
+    bool   operator>( const TQDateTime &dt )  const;
+    bool   operator>=( const TQDateTime &dt ) const;
+
+    static TQDateTime currentDateTime();
+    static TQDateTime currentDateTime( TQt::TimeSpec );
+#ifndef TQT_NO_DATESTRING
+    static TQDateTime fromString( const TQString& s, TQt::DateFormat f = TQt::TextDate );
+#endif
+private:
+    TQDate  d;
+    TQTime  t;
+#ifndef TQT_NO_DATASTREAM
+    friend TQ_EXPORT TQDataStream &operator<<( TQDataStream &, const TQDateTime &);
+    friend TQ_EXPORT TQDataStream &operator>>( TQDataStream &, TQDateTime & );
+#endif
+};
+
+
+/*****************************************************************************
+  Date and time stream functions
+ *****************************************************************************/
+
+#ifndef TQT_NO_DATASTREAM
+TQ_EXPORT TQDataStream &operator<<( TQDataStream &, const TQDate & );
+TQ_EXPORT TQDataStream &operator>>( TQDataStream &, TQDate & );
+TQ_EXPORT TQDataStream &operator<<( TQDataStream &, const TQTime & );
+TQ_EXPORT TQDataStream &operator>>( TQDataStream &, TQTime & );
+TQ_EXPORT TQDataStream &operator<<( TQDataStream &, const TQDateTime & );
+TQ_EXPORT TQDataStream &operator>>( TQDataStream &, TQDateTime & );
+#endif // TQT_NO_DATASTREAM
+
+#endif // USE_QT4
+
+#endif // TQDATETIME_H
+
diff --git a/tqtinterface/qt4/src/tools/tqdeepcopy.cpp b/tqtinterface/qt4/src/tools/tqdeepcopy.cpp
new file mode 100644
index 0000000..4a5095e
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqdeepcopy.cpp
@@ -0,0 +1,168 @@
+/****************************************************************************
+**
+** Implementation of TQDeepCopy class
+**
+** Created : 20020613
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the kernel module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "tqdeepcopy.h"
+
+/*!
+    \class TQDeepCopy tqdeepcopy.h
+    \brief The TQDeepCopy class is a template class which ensures that
+    implicitly shared and explicitly shared classes reference unique
+    data.
+
+    \reentrant
+
+    \ingroup tools
+    \ingroup shared
+
+    Normally, shared copies reference the same data to optimize memory
+    use and for maximum speed. In the example below, \c s1, \c s2, \c
+    s3, \c s4 and \c s5 share data.
+
+    \code
+    // all 5 strings share the same data
+    TQString s1 = "abcd";
+    TQString s2 = s1;
+    TQString s3 = s2;
+    TQString s4 = s3;
+    TQString s5 = s2;
+    \endcode
+
+    TQDeepCopy can be used several ways to ensure that an object
+    references unique, unshared data. In the example below, \c s1, \c
+    s2 and \c s5 share data, while neither \c s3 nor \c s4 share data.
+    \code
+    // s1, s2 and s5 share the same data, neither s3 nor s4 are shared
+    TQString s1 = "abcd";
+    TQString s2 = s1;
+    TQDeepCopy<TQString> s3 = s2;  // s3 is a deep copy of s2
+    TQString s4 = s3;             // s4 is a deep copy of s3
+    TQString s5 = s2;
+    \endcode
+
+    In the example below, \c s1, \c s2 and \c s5 share data, and \c s3
+    and \c s4 share data.
+    \code
+    // s1, s2 and s5 share the same data, s3 and s4 share the same data
+    TQString s1 = "abcd";
+    TQString s2 = s1;
+    TQString s3 = TQDeepCopy<TQString>( s2 );  // s3 is a deep copy of s2
+    TQString s4 = s3;                        // s4 is a shallow copy of s3
+    TQString s5 = s2;
+    \endcode
+
+    TQDeepCopy can also provide safety in multithreaded applications
+    that use shared classes. In the example below, the variable \c
+    global_string is used safely since the data contained in \c
+    global_string is always a deep copy. This ensures that all threads
+    get a unique copy of the data, and that any assignments to \c
+    global_string will result in a deep copy.
+
+    \code
+    TQDeepCopy<TQString> global_string;  // global string data
+    TQMutex global_mutex;               // mutex to protext global_string
+
+    ...
+
+    void setGlobalString( const TQString &str )
+    {
+	global_mutex.lock();
+	global_string = str;           // global_string is a deep copy of str
+	global_mutex.unlock();
+    }
+
+    ...
+
+    void MyThread::run()
+    {
+	global_mutex.lock();
+	TQString str = global_string;          // str is a deep copy of global_string
+	global_mutex.unlock();
+
+	// process the string data
+	...
+
+	// update global_string
+	setGlobalString( str );
+    }
+    \endcode
+
+    \warning It is the application developer's responsibility to
+    protect the object shared across multiple threads.
+
+    The examples above use TQString, which is an implicitly shared
+    class. The behavior of TQDeepCopy is the same when using explicitly
+    shared classes like TQByteArray.
+
+    Currently, TQDeepCopy works with the following classes:
+    \list
+    \i TQMemArray (including subclasses like TQByteArray and TQCString)
+    \i TQMap
+    \i TQString
+    \i TQValueList (including subclasses like TQStringList and TQValueStack)
+    \i TQValueVector
+    \endlist
+
+    \sa \link threads.html Thread Support in TQt \endlink
+*/
+
+/*!
+    \fn TQDeepCopy::TQDeepCopy()
+
+    Constructs an empty instance of type \e T.
+*/
+
+/*!
+    \fn TQDeepCopy::TQDeepCopy( const T &t )
+
+    Constructs a deep copy of \a t.
+*/
+
+/*!
+    \fn TQDeepCopy<T>& TQDeepCopy::operator=( const T &t )
+
+    Assigns a deep copy of \a t.
+*/
+
+/*!
+    \fn TQDeepCopy::operator T ()
+
+    Returns a deep copy of the encapsulated data.
+*/
+
diff --git a/tqtinterface/qt4/src/tools/tqdeepcopy.h b/tqtinterface/qt4/src/tools/tqdeepcopy.h
new file mode 100644
index 0000000..900f9c0
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqdeepcopy.h
@@ -0,0 +1,80 @@
+/****************************************************************************
+**
+** Definition of TQDeepCopy class
+**
+** Created : 20020613
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the kernel module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQDEEPCOPY_H
+#define TQDEEPCOPY_H
+
+#ifndef TQT_H
+#  include "tqglobal.h"
+#endif // TQT_H
+
+template <class T>
+class TQDeepCopy
+{
+public:
+    inline TQDeepCopy()
+    {
+    }
+
+    inline TQDeepCopy( const T &t )
+	: deepcopy( t )
+    {
+	deepcopy.detach();
+    }
+
+    inline TQDeepCopy<T> &operator=( const T &t )
+    {
+	deepcopy = t;
+	deepcopy.detach();
+	return *this;
+    }
+
+    inline operator T ()
+    {
+	T tmp = deepcopy;
+	tmp.detach();
+	return tmp;
+    }
+
+private:
+    T deepcopy;
+};
+
+#endif // TQDEEPCOPY_H
diff --git a/tqtinterface/qt4/src/tools/tqdict.h b/tqtinterface/qt4/src/tools/tqdict.h
new file mode 100644
index 0000000..1dc8a48
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqdict.h
@@ -0,0 +1,123 @@
+/****************************************************************************
+**
+** Definition of TQDict template class
+**
+** Created : 920821
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQDICT_H
+#define TQDICT_H
+
+#ifndef TQT_H
+#include "tqgdict.h"
+#endif // TQT_H
+
+template<class type>
+class TQDict
+#ifdef TQ_TQDOC
+	: public TQPtrCollection
+#else
+	: public TQGDict
+#endif
+{
+public:
+    TQDict( int size = 17, bool caseSensitive = TRUE )
+	: TQGDict( size, StringKey, caseSensitive, FALSE ) { }
+    TQDict( const TQDict<type> &d ) : TQGDict( d ) { }
+    ~TQDict()				{ clear(); }
+    TQDict<type> &operator=(const TQDict<type> &d)
+			{ return (TQDict<type>&)TQGDict::operator=(d); }
+    uint  count()   const		{ return TQGDict::count(); }
+    uint  size()    const		{ return TQGDict::size(); }
+    bool  isEmpty() const		{ return TQGDict::count() == 0; }
+
+    void  insert( const TQString &k, const type *d )
+					{ TQGDict::look_string(k,(Item)d,1); }
+    void  tqreplace( const TQString &k, const type *d )
+					{ TQGDict::look_string(k,(Item)d,2); }
+    bool  remove( const TQString &k )	{ return TQGDict::remove_string(k); }
+    type *take( const TQString &k )	{ return (type *)TQGDict::take_string(k); }
+    type *tqfind( const TQString &k ) const
+		{ return (type *)((TQGDict*)this)->TQGDict::look_string(k,0,0); }
+    type *operator[]( const TQString &k ) const
+		{ return (type *)((TQGDict*)this)->TQGDict::look_string(k,0,0); }
+
+    void  clear()			{ TQGDict::clear(); }
+    void  resize( uint n )		{ TQGDict::resize(n); }
+    void  statistics() const		{ TQGDict::statistics(); }
+
+#ifdef TQ_TQDOC
+protected:
+    virtual TQDataStream& read( TQDataStream &, TQPtrCollection::Item & );
+    virtual TQDataStream& write( TQDataStream &, TQPtrCollection::Item ) const;
+#endif
+
+private:
+	void  deleteItem( Item d );
+};
+
+#if !defined(TQ_BROKEN_TEMPLATE_SPECIALIZATION)
+template<> inline void TQDict<void>::deleteItem( Item )
+{
+}
+#endif
+
+template<class type> inline void TQDict<type>::deleteItem( TQPtrCollection::Item d )
+{
+    if ( del_item ) delete (type *)d;
+}
+
+template<class type>
+class TQDictIterator : public TQGDictIterator
+{
+public:
+    TQDictIterator(const TQDict<type> &d) : TQGDictIterator((TQGDict &)d) { }
+    ~TQDictIterator()	      {}
+    uint  count()   const     { return dict->count(); }
+    bool  isEmpty() const     { return dict->count() == 0; }
+    type *toFirst()	      { return (type *)TQGDictIterator::toFirst(); }
+    operator type *() const   { return (type *)TQGDictIterator::get(); }
+    type *operator*()         { return (type *)TQGDictIterator::get(); }
+    type   *current() const   { return (type *)TQGDictIterator::get(); }
+    TQString currentKey() const{ return TQGDictIterator::getKeyString(); }
+    type *operator()()	      { return (type *)TQGDictIterator::operator()(); }
+    type *operator++()	      { return (type *)TQGDictIterator::operator++(); }
+    type *operator+=(uint j)  { return (type *)TQGDictIterator::operator+=(j); }
+};
+
+#define TQ_DEFINED_TQDICT
+#include "tqwinexport.h"
+#endif // TQDICT_H
diff --git a/tqtinterface/qt4/src/tools/tqdir.cpp b/tqtinterface/qt4/src/tools/tqdir.cpp
new file mode 100644
index 0000000..796162d
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqdir.cpp
@@ -0,0 +1,1390 @@
+/****************************************************************************
+**
+** Implementation of TQDir class
+**
+** Created : 950427
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "tqplatformdefs.h"
+#include "tqdir.h"
+
+#ifndef TQT_NO_DIR
+#include <private/tqdir_p.h>
+#include "tqfileinfo.h"
+#include "tqregexp.h"
+#include "tqstringlist.h"
+#include "tqdeepcopy.h"
+#include <limits.h>
+
+#if defined(TQ_FS_FAT) && !defined(TQ_OS_UNIX)
+const bool CaseSensitiveFS = FALSE;
+#else
+const bool CaseSensitiveFS = TRUE;
+#endif
+
+
+/*!
+    \class TQDir
+    \reentrant
+    \brief The TQDir class provides access to directory structures and their contents in a platform-independent way.
+
+    \ingroup io
+    \mainclass
+
+    A TQDir is used to manipulate path names, access information
+    regarding paths and files, and manipulate the underlying file
+    system.
+
+    A TQDir can point to a file using either a relative or an absolute
+    path. Absolute paths begin with the directory separator "/"
+    (optionally preceded by a drive specification under Windows). If
+    you always use "/" as a directory separator, TQt will translate
+    your paths to conform to the underlying operating system. Relative
+    file names begin with a directory name or a file name and specify
+    a path relative to the current directory.
+
+    The "current" path refers to the application's working directory.
+    A TQDir's own path is set and retrieved with setPath() and path().
+
+    An example of an absolute path is the string "/tmp/quartz", a
+    relative path might look like "src/fatlib". You can use the
+    function isRelative() to check if a TQDir is using a relative or an
+    absolute file path. Call convertToAbs() to convert a relative TQDir
+    to an absolute one. For a simplified path use cleanDirPath(). To
+    obtain a path which has no symbolic links or redundant ".."
+    elements use canonicalPath(). The path can be set with setPath(),
+    and changed with cd() and cdUp().
+
+    TQDir provides several static functions, for example, setCurrent()
+    to set the application's working directory and currentDirPath() to
+    retrieve the application's working directory. Access to some
+    common paths is provided with the static functions, current(),
+    home() and root() which return TQDir objects or currentDirPath(),
+    homeDirPath() and rootDirPath() which return the path as a string.
+    If you want to know about your application's path use
+    \l{TQApplication::applicationDirPath()}.
+
+    The number of entries in a directory is returned by count().
+    Obtain a string list of the names of all the files and directories
+    in a directory with entryList(). If you prefer a list of TQFileInfo
+    pointers use entryInfoList(). Both these functions can apply a
+    name filter, an attributes filter (e.g. read-only, files not
+    directories, etc.), and a sort order. The filters and sort may be
+    set with calls to setNameFilter(), setFilter() and setSorting().
+    They may also be specified in the entryList() and
+    entryInfoList()'s arguments.
+
+    Create a new directory with mkdir(), rename a directory with
+    rename() and remove an existing directory with rmdir(). Remove a
+    file with remove(). You can interrogate a directory with exists(),
+    isReadable() and isRoot().
+
+    To get a path with a filename use filePath(), and to get a
+    directory name use dirName(); neither of these functions checks
+    for the existence of the file or directory.
+
+    The list of root directories is provided by drives(); on Unix
+    systems this returns a list containing one root directory, "/"; on
+    Windows the list will usually contain "C:/", and possibly "D:/",
+    etc.
+
+    It is easiest to work with "/" separators in TQt code. If you need
+    to present a path to the user or need a path in a form suitable
+    for a function in the underlying operating system use
+    convertSeparators().
+
+    Examples:
+
+    See if a directory exists.
+    \code
+    TQDir d( "example" );			// "./example"
+    if ( !d.exists() )
+	qWarning( "Cannot find the example directory" );
+    \endcode
+
+    Traversing directories and reading a file.
+    \code
+    TQDir d = TQDir::root();			// "/"
+    if ( !d.cd("tmp") ) {			// "/tmp"
+	qWarning( "Cannot find the \"/tmp\" directory" );
+    } else {
+	TQFile f( d.filePath("ex1.txt") );	// "/tmp/ex1.txt"
+	if ( !f.open(IO_ReadWrite) )
+	    qWarning( "Cannot create the file %s", f.name() );
+    }
+    \endcode
+
+    A program that lists all the files in the current directory
+    (excluding symbolic links), sorted by size, smallest first:
+    \code
+    #include <stdio.h>
+    #include <tqdir.h>
+
+    int main( int argc, char **argv )
+    {
+	TQDir d;
+	d.setFilter( TQDir::Files | TQDir::Hidden | TQDir::NoSymLinks );
+	d.setSorting( TQDir::Size | TQDir::Reversed );
+
+	const TQFileInfoList *list = d.entryInfoList();
+	TQFileInfoListIterator it( *list );
+	TQFileInfo *fi;
+
+	printf( "     Bytes Filename\n" );
+	while ( (fi = it.current()) != 0 ) {
+	    printf( "%10li %s\n", fi->size(), fi->fileName().latin1() );
+	    ++it;
+	}
+	return 0;
+    }
+    \endcode
+
+    \sa TQApplication::applicationDirPath()
+*/
+
+/*!
+    Constructs a TQDir pointing to the current directory (".").
+
+    \sa currentDirPath()
+*/
+
+TQDir::TQDir()
+{
+    dPath = TQString::tqfromLatin1(".");
+    init();
+}
+
+/*!
+    Constructs a TQDir with path \a path, that filters its entries by
+    name using \a nameFilter and by attributes using \a filterSpec. It
+    also sorts the names using \a sortSpec.
+
+    The default \a nameFilter is an empty string, which excludes
+    nothing; the default \a filterSpec is \c All, which also means
+    exclude nothing. The default \a sortSpec is \c Name|IgnoreCase,
+    i.e. sort by name case-insensitively.
+
+    Example that lists all the files in "/tmp":
+    \code
+    TQDir d( "/tmp" );
+    for ( int i = 0; i < d.count(); i++ )
+	printf( "%s\n", d[i] );
+    \endcode
+
+    If \a path is "" or TQString::null, TQDir uses "." (the current
+    directory). If \a nameFilter is "" or TQString::null, TQDir uses the
+    name filter "*" (all files).
+
+    Note that \a path need not exist.
+
+    \sa exists(), setPath(), setNameFilter(), setFilter(), setSorting()
+*/
+
+TQDir::TQDir( const TQString &path, const TQString &nameFilter,
+	    int sortSpec, int filterSpec )
+{
+    init();
+    dPath = cleanDirPath( path );
+    if ( dPath.isEmpty() )
+	dPath = TQString::tqfromLatin1(".");
+    nameFilt = nameFilter;
+    if ( nameFilt.isEmpty() )
+	nameFilt = TQString::tqfromLatin1("*");
+    filtS = (FilterSpec)filterSpec;
+    sortS = (SortSpec)sortSpec;
+}
+
+/*!
+    Constructs a TQDir that is a copy of the directory \a d.
+
+    \sa operator=()
+*/
+
+TQDir::TQDir( const TQDir &d )
+{
+    dPath = d.dPath;
+    fList = 0;
+    fiList = 0;
+    nameFilt = d.nameFilt;
+    dirty = TRUE;
+    allDirs = d.allDirs;
+    filtS = d.filtS;
+    sortS = d.sortS;
+}
+
+/*!
+    Refreshes the directory information.
+*/
+void TQDir::refresh() const
+{
+    TQDir* that = (TQDir*) this;
+    that->dirty = TRUE;
+}
+
+void TQDir::init()
+{
+    fList = 0;
+    fiList = 0;
+    nameFilt = TQString::tqfromLatin1("*");
+    dirty = TRUE;
+    allDirs = FALSE;
+    filtS = All;
+    sortS = SortSpec(Name | IgnoreCase);
+}
+
+/*!
+    Destroys the TQDir frees up its resources.
+*/
+
+TQDir::~TQDir()
+{
+    delete fList;
+    delete fiList;
+}
+
+
+/*!
+    Sets the path of the directory to \a path. The path is cleaned of
+    redundant ".", ".." and of multiple separators. No check is made
+    to ensure that a directory with this path exists.
+
+    The path can be either absolute or relative. Absolute paths begin
+    with the directory separator "/" (optionally preceded by a drive
+    specification under Windows). Relative file names begin with a
+    directory name or a file name and specify a path relative to the
+    current directory. An example of an absolute path is the string
+    "/tmp/quartz", a relative path might look like "src/fatlib".
+
+    \sa path(), absPath(), exists(), cleanDirPath(), dirName(),
+      absFilePath(), isRelative(), convertToAbs()
+*/
+
+void TQDir::setPath( const TQString &path )
+{
+    dPath = cleanDirPath( path );
+    if ( dPath.isEmpty() )
+	dPath = TQString::tqfromLatin1(".");
+    dirty = TRUE;
+}
+
+/*!
+    \fn  TQString TQDir::path() const
+
+    Returns the path, this may contain symbolic links, but never
+    tqcontains redundant ".", ".." or multiple separators.
+
+    The returned path can be either absolute or relative (see
+    setPath()).
+
+    \sa setPath(), absPath(), exists(), cleanDirPath(), dirName(),
+    absFilePath(), convertSeparators()
+*/
+
+/*!
+    Returns the absolute path (a path that starts with "/" or with a
+    drive specification), which may contain symbolic links, but never
+    tqcontains redundant ".", ".." or multiple separators.
+
+    \sa setPath(), canonicalPath(), exists(),  cleanDirPath(),
+    dirName(), absFilePath()
+*/
+
+TQString TQDir::absPath() const
+{
+    if ( TQDir::isRelativePath(dPath) ) {
+	TQString tmp = currentDirPath();
+	if ( tmp.right(1) != TQString::tqfromLatin1("/") )
+	    tmp += '/';
+	tmp += dPath;
+	return cleanDirPath( tmp );
+    } else {
+	return cleanDirPath( dPath );
+    }
+}
+
+/*!
+    Returns the name of the directory; this is \e not the same as the
+    path, e.g. a directory with the name "mail", might have the path
+    "/var/spool/mail". If the directory has no name (e.g. it is the
+    root directory) TQString::null is returned.
+
+    No check is made to ensure that a directory with this name
+    actually exists.
+
+    \sa path(), absPath(), absFilePath(), exists(), TQString::isNull()
+*/
+
+TQString TQDir::dirName() const
+{
+    int pos = dPath.tqfindRev( '/' );
+    if ( pos == -1  )
+	return dPath;
+    return dPath.right( dPath.length() - pos - 1 );
+}
+
+/*!
+    Returns the path name of a file in the directory. Does \e not
+    check if the file actually exists in the directory. If the TQDir is
+    relative the returned path name will also be relative. Redundant
+    multiple separators or "." and ".." directories in \a fileName
+    will not be removed (see cleanDirPath()).
+
+    If \a acceptAbsPath is TRUE a \a fileName starting with a
+    separator "/" will be returned without change. If \a acceptAbsPath
+    is FALSE an absolute path will be prepended to the fileName and
+    the resultant string returned.
+
+    \sa absFilePath(), isRelative(), canonicalPath()
+*/
+
+TQString TQDir::filePath( const TQString &fileName,
+			bool acceptAbsPath ) const
+{
+    if ( acceptAbsPath && !isRelativePath(fileName) )
+	return TQString(fileName);
+
+    TQString tmp = dPath;
+    if ( tmp.isEmpty() || (tmp[(int)tmp.length()-1] != '/' && !!fileName &&
+			   fileName[0] != '/') )
+	tmp += '/';
+    tmp += fileName;
+    return tmp;
+}
+
+/*!
+    Returns the absolute path name of a file in the directory. Does \e
+    not check if the file actually exists in the directory. Redundant
+    multiple separators or "." and ".." directories in \a fileName
+    will not be removed (see cleanDirPath()).
+
+    If \a acceptAbsPath is TRUE a \a fileName starting with a
+    separator "/" will be returned without change. If \a acceptAbsPath
+    is FALSE an absolute path will be prepended to the fileName and
+    the resultant string returned.
+
+    \sa filePath()
+*/
+
+TQString TQDir::absFilePath( const TQString &fileName,
+			   bool acceptAbsPath ) const
+{
+    if ( acceptAbsPath && !isRelativePath( fileName ) )
+	return fileName;
+
+    TQString tmp = absPath();
+#ifdef TQ_OS_WIN32
+    if ( fileName[0].isLetter() && fileName[1] == ':' ) {
+	int drv = fileName.upper()[0].latin1() - 'A' + 1;
+	if ( _getdrive() != drv ) {
+	    TQT_WA( {
+		TCHAR buf[PATH_MAX];
+		::_wgetdcwd( drv, buf, PATH_MAX );
+		tmp.setUnicodeCodes( (ushort*)buf, (uint)::wcslen(buf) );
+	    }, {
+		char buf[PATH_MAX];
+		::_getdcwd( drv, buf, PATH_MAX );
+		tmp = buf;
+	    } );
+	    if ( !tmp.endsWith("\\") )
+		tmp += "\\";
+	    tmp += fileName.right( fileName.length() - 2 );
+	    int x;
+	    for ( x = 0; x < (int) tmp.length(); x++ ) {
+		if ( tmp[x] == '\\' )
+		    tmp[x] = '/';
+	    }
+	}
+    } else
+#endif
+    {
+	if ( tmp.isEmpty() || (tmp[(int)tmp.length()-1] != '/' && !!fileName &&
+			       fileName[0] != '/') )
+	    tmp += '/';
+	tmp += fileName;
+    }
+    return tmp;
+}
+
+
+/*!
+    Returns \a pathName with the '/' separators converted to
+    separators that are appropriate for the underlying operating
+    system.
+
+    On Windows, convertSeparators("c:/winnt/system32") returns
+    "c:\winnt\system32".
+
+    The returned string may be the same as the argument on some
+    operating systems, for example on Unix.
+*/
+
+TQString TQDir::convertSeparators( const TQString &pathName )
+{
+    TQString n( pathName );
+#if defined(TQ_FS_FAT) || defined(TQ_OS_OS2EMX)
+    for ( int i=0; i<(int)n.length(); i++ ) {
+	if ( n[i] == '/' )
+	    n[i] = '\\';
+    }
+#elif defined(TQ_OS_MAC9)
+	while(n.length() && n[0] == '/' ) n = n.right(n.length()-1);
+    for ( int i=0; i<(int)n.length(); i++ ) {
+	if ( n[i] == '/' )
+	    n[i] = ':';
+    }
+    if(n.tqcontains(':') && n.left(1) != ':')
+	n.prepend(':');
+#endif
+    return n;
+}
+
+
+/*!
+    Changes the TQDir's directory to \a dirName.
+
+    If \a acceptAbsPath is TRUE a path starting with separator "/"
+    will cause the function to change to the absolute directory. If \a
+    acceptAbsPath is FALSE any number of separators at the beginning
+    of \a dirName will be removed and the function will descend into
+    \a dirName.
+
+    Returns TRUE if the new directory exists and is readable;
+    otherwise returns FALSE. Note that the logical cd() operation is
+    not performed if the new directory does not exist.
+
+    Calling cd( ".." ) is equivalent to calling cdUp().
+
+    \sa cdUp(), isReadable(), exists(), path()
+*/
+
+bool TQDir::cd( const TQString &dirName, bool acceptAbsPath )
+{
+    if ( dirName.isEmpty() || dirName == TQString::tqfromLatin1(".") )
+	return TRUE;
+    TQString old = dPath;
+    if ( acceptAbsPath && !isRelativePath(dirName) ) {
+	dPath = cleanDirPath( dirName );
+    } else {
+	if ( isRoot() ) {
+	    if ( dirName == ".." ) {
+		dPath = old;
+		return FALSE;
+	    }
+	} else {
+	    dPath += '/';
+	}
+
+	dPath += dirName;
+	if ( dirName.tqfind('/') >= 0
+		|| old == TQString::tqfromLatin1(".")
+		|| dirName == TQString::tqfromLatin1("..") ) {
+	    dPath = cleanDirPath( dPath );
+
+	    /*
+	      If dPath starts with .., we convert it to absolute to
+	      avoid infinite looping on
+
+		  TQDir dir( "." );
+		  while ( dir.cdUp() )
+		      ;
+	    */
+	    if ( dPath[0] == TQChar('.') && dPath[1] == TQChar('.') &&
+		 (dPath.length() == 2 || dPath[2] == TQChar('/')) )
+		convertToAbs();
+	}
+    }
+    if ( !exists() ) {
+	dPath = old;			// regret
+	return FALSE;
+    }
+    dirty = TRUE;
+    return TRUE;
+}
+
+/*!
+    Changes directory by moving one directory up from the TQDir's
+    current directory.
+
+    Returns TRUE if the new directory exists and is readable;
+    otherwise returns FALSE. Note that the logical cdUp() operation is
+    not performed if the new directory does not exist.
+
+    \sa cd(), isReadable(), exists(), path()
+*/
+
+bool TQDir::cdUp()
+{
+    return cd( TQString::tqfromLatin1("..") );
+}
+
+/*!
+    \fn TQString TQDir::nameFilter() const
+
+    Returns the string set by setNameFilter()
+*/
+
+/*!
+    Sets the name filter used by entryList() and entryInfoList() to \a
+    nameFilter.
+
+    The \a nameFilter is a wildcard (globbing) filter that understands
+    "*" and "?" wildcards. (See \link tqregexp.html#wildcard-matching
+    TQRegExp wildcard matching\endlink.) You may specify several filter
+    entries all separated by a single space " " or by a semi-colon
+    ";".
+
+    For example, if you want entryList() and entryInfoList() to list
+    all files ending with either ".cpp" or ".h", you would use either
+    dir.setNameFilter("*.cpp *.h") or dir.setNameFilter("*.cpp;*.h").
+
+    \sa nameFilter(), setFilter()
+*/
+
+void TQDir::setNameFilter( const TQString &nameFilter )
+{
+    nameFilt = nameFilter;
+    if ( nameFilt.isEmpty() )
+	nameFilt = TQString::tqfromLatin1("*");
+    dirty = TRUE;
+}
+
+/*!
+    \fn TQDir::FilterSpec TQDir::filter() const
+
+    Returns the value set by setFilter()
+*/
+
+/*!
+    \enum TQDir::FilterSpec
+
+    This enum describes the filtering options available to TQDir, e.g.
+    for entryList() and entryInfoList(). The filter value is specified
+    by OR-ing together values from the following list:
+
+    \value Dirs  List directories only.
+    \value Files  List files only.
+    \value  Drives  List disk drives (ignored under Unix).
+    \value  NoSymLinks  Do not list symbolic links (ignored by operating
+    systems that don't support symbolic links).
+    \value All List directories, files, drives and symlinks (this does not list
+    broken symlinks unless you specify System).
+    \value TypeMask A tqmask for the the Dirs, Files, Drives and
+    NoSymLinks flags.
+    \value  Readable  List files for which the application has read access.
+    \value  Writable  List files for which the application has write access.
+    \value  Executable  List files for which the application has execute
+    access. Executables needs to be combined with Dirs or Files.
+    \value  RWEMask A tqmask for the Readable, Writable and Executable flags.
+    \value  Modified  Only list files that have been modified (ignored
+    under Unix).
+    \value  Hidden  List hidden files (on Unix, files starting with a .).
+    \value  System  List system files (on Unix, FIFOs, sockets and
+    tqdevice files)
+    \value AccessMask A tqmask for the Readable, Writable, Executable
+    Modified, Hidden and System flags
+    \value DefaultFilter Internal flag.
+
+    If you do not set any of \c Readable, \c Writable or \c
+    Executable, TQDir will set all three of them. This makes the
+    default easy to write and at the same time useful.
+
+    Examples: \c Readable|Writable means list all files for which the
+    application has read access, write access or both. \c Dirs|Drives
+    means list drives, directories, all files that the application can
+    read, write or execute, and also symlinks to such
+    files/directories.
+*/
+
+
+/*!
+    Sets the filter used by entryList() and entryInfoList() to \a
+    filterSpec. The filter is used to specify the kind of files that
+    should be returned by entryList() and entryInfoList(). See
+    \l{TQDir::FilterSpec}.
+
+    \sa filter(), setNameFilter()
+*/
+
+void TQDir::setFilter( int filterSpec )
+{
+    if ( filtS == (FilterSpec) filterSpec )
+	return;
+    filtS = (FilterSpec) filterSpec;
+    dirty = TRUE;
+}
+
+/*!
+    \fn TQDir::SortSpec TQDir::sorting() const
+
+    Returns the value set by setSorting()
+
+    \sa setSorting() SortSpec
+*/
+
+/*!
+    \enum TQDir::SortSpec
+
+    This enum describes the sort options available to TQDir, e.g. for
+    entryList() and entryInfoList(). The sort value is specified by
+    OR-ing together values from the following list:
+
+    \value Name  Sort by name.
+    \value Time  Sort by time (modification time).
+    \value Size  Sort by file size.
+    \value Unsorted  Do not sort.
+    \value SortByMask A tqmask for Name, Time and Size.
+
+    \value DirsFirst  Put the directories first, then the files.
+    \value Reversed  Reverse the sort order.
+    \value IgnoreCase  Sort case-insensitively.
+    \value LocaleAware  Sort names using locale aware compares
+    \value DefaultSort Internal flag.
+
+    You can only specify one of the first four.
+
+    If you specify both \c DirsFirst and \c Reversed, directories are
+    still put first, but in reverse order; the files will be listed
+    after the directories, again in reverse order.
+*/
+
+// ### Unsorted+DirsFirst ? Unsorted+Reversed?
+
+/*!
+    Sets the sort order used by entryList() and entryInfoList().
+
+    The \a sortSpec is specified by OR-ing values from the enum
+    \l{TQDir::SortSpec}.
+
+    \sa sorting() SortSpec
+*/
+
+void TQDir::setSorting( int sortSpec )
+{
+    if ( sortS == (SortSpec) sortSpec )
+	return;
+    sortS = (SortSpec) sortSpec;
+    dirty = TRUE;
+}
+
+/*!
+    \fn bool TQDir::matchAllDirs() const
+
+    Returns the value set by setMatchAllDirs()
+
+    \sa setMatchAllDirs()
+*/
+
+/*!
+    If \a enable is TRUE then all directories are included (e.g. in
+    entryList()), and the nameFilter() is only applied to the files.
+    If \a enable is FALSE then the nameFilter() is applied to both
+    directories and files.
+
+    \sa matchAllDirs()
+*/
+
+void TQDir::setMatchAllDirs( bool enable )
+{
+    if ( (bool)allDirs == enable )
+	return;
+    allDirs = enable;
+    dirty = TRUE;
+}
+
+
+/*!
+    Returns the total number of directories and files that were found.
+
+    Equivalent to entryList().count().
+
+    \sa operator[](), entryList()
+*/
+
+uint TQDir::count() const
+{
+    return (uint)entryList().count();
+}
+
+/*!
+    Returns the file name at position \a index in the list of file
+    names. Equivalent to entryList().at(index).
+
+    Returns a TQString::null if the \a index is out of range or if the
+    entryList() function failed.
+
+    \sa count(), entryList()
+*/
+
+TQString TQDir::operator[]( int index ) const
+{
+    entryList();
+    return fList && index >= 0 && index < (int)fList->count() ?
+	(*fList)[index] : TQString::null;
+}
+
+
+/*!
+    \obsolete
+  This function is included to easy porting from TQt 1.x to TQt 2.0,
+  it is the same as entryList(), but encodes the filenames as 8-bit
+  strings using TQFile::encodedName().
+
+  It is more efficient to use entryList().
+*/
+TQStrList TQDir::encodedEntryList( int filterSpec, int sortSpec ) const
+{
+    TQStrList r;
+    TQStringList l = entryList(filterSpec,sortSpec);
+    for ( TQStringList::Iterator it = l.begin(); it != l.end(); ++it ) {
+	r.append( TQFile::encodeName(*it) );
+    }
+    return r;
+}
+
+/*!
+    \obsolete
+    \overload
+  This function is included to easy porting from TQt 1.x to TQt 2.0,
+  it is the same as entryList(), but encodes the filenames as 8-bit
+  strings using TQFile::encodedName().
+
+  It is more efficient to use entryList().
+*/
+TQStrList TQDir::encodedEntryList( const TQString &nameFilter,
+			   int filterSpec,
+			   int sortSpec ) const
+{
+    TQStrList r;
+    TQStringList l = entryList(nameFilter,filterSpec,sortSpec);
+    for ( TQStringList::Iterator it = l.begin(); it != l.end(); ++it ) {
+	r.append( TQFile::encodeName(*it) );
+    }
+    return r;
+}
+
+
+
+/*!
+    \overload
+
+    Returns a list of the names of all the files and directories in
+    the directory, ordered in accordance with setSorting() and
+    filtered in accordance with setFilter() and setNameFilter().
+
+    The filter and sorting specifications can be overridden using the
+    \a filterSpec and \a sortSpec arguments.
+
+    Returns an empty list if the directory is unreadable or does not
+    exist.
+
+    \sa entryInfoList(), setNameFilter(), setSorting(), setFilter()
+*/
+
+TQStringList TQDir::entryList( int filterSpec, int sortSpec ) const
+{
+    if ( !dirty && filterSpec == (int)DefaultFilter &&
+		   sortSpec   == (int)DefaultSort )
+	return *fList;
+    return entryList( nameFilt, filterSpec, sortSpec );
+}
+
+/*!
+    Returns a list of the names of all the files and directories in
+    the directory, ordered in accordance with setSorting() and
+    filtered in accordance with setFilter() and setNameFilter().
+
+    The filter and sorting specifications can be overridden using the
+    \a nameFilter, \a filterSpec and \a sortSpec arguments.
+
+    Returns an empty list if the directory is unreadable or does not
+    exist.
+
+    \sa entryInfoList(), setNameFilter(), setSorting(), setFilter()
+*/
+
+TQStringList TQDir::entryList( const TQString &nameFilter,
+				 int filterSpec, int sortSpec ) const
+{
+    if ( filterSpec == (int)DefaultFilter )
+	filterSpec = filtS;
+    if ( sortSpec == (int)DefaultSort )
+	sortSpec = sortS;
+    TQDir *that = (TQDir*)this;			// mutable function
+    if ( that->readDirEntries(nameFilter, filterSpec, sortSpec) ) {
+	if ( that->fList )
+	    return *that->fList;
+    }
+    return TQStringList();
+}
+
+/*!
+    \overload
+
+    Returns a list of TQFileInfo objects for all the files and
+    directories in the directory, ordered in accordance with
+    setSorting() and filtered in accordance with setFilter() and
+    setNameFilter().
+
+    The filter and sorting specifications can be overridden using the
+    \a filterSpec and \a sortSpec arguments.
+
+    Returns 0 if the directory is unreadable or does not exist.
+
+    The returned pointer is a const pointer to a TQFileInfoList. The
+    list is owned by the TQDir object and will be reused on the next
+    call to entryInfoList() for the same TQDir instance. If you want to
+    keep the entries of the list after a subsequent call to this
+    function you must copy them.
+
+    Note: TQFileInfoList is really a TQPtrList<TQFileInfo>.
+
+    \sa entryList(), setNameFilter(), setSorting(), setFilter()
+*/
+
+const TQFileInfoList *TQDir::entryInfoList( int filterSpec, int sortSpec ) const
+{
+    if ( !dirty && filterSpec == (int)DefaultFilter &&
+		   sortSpec   == (int)DefaultSort )
+	return fiList;
+    return entryInfoList( nameFilt, filterSpec, sortSpec );
+}
+
+/*!
+    Returns a list of TQFileInfo objects for all the files and
+    directories in the directory, ordered in accordance with
+    setSorting() and filtered in accordance with setFilter() and
+    setNameFilter().
+
+    The filter and sorting specifications can be overridden using the
+    \a nameFilter, \a filterSpec and \a sortSpec arguments.
+
+    Returns 0 if the directory is unreadable or does not exist.
+
+    The returned pointer is a const pointer to a TQFileInfoList. The
+    list is owned by the TQDir object and will be reused on the next
+    call to entryInfoList() for the same TQDir instance. If you want to
+    keep the entries of the list after a subsequent call to this
+    function you must copy them.
+
+    Note: TQFileInfoList is really a TQPtrList<TQFileInfo>.
+
+    \sa entryList(), setNameFilter(), setSorting(), setFilter()
+*/
+
+const TQFileInfoList *TQDir::entryInfoList( const TQString &nameFilter,
+					  int filterSpec, int sortSpec ) const
+{
+    if ( filterSpec == (int)DefaultFilter )
+	filterSpec = filtS;
+    if ( sortSpec == (int)DefaultSort )
+	sortSpec = sortS;
+    TQDir *that = (TQDir*)this;			// mutable function
+    if ( that->readDirEntries(nameFilter, filterSpec, sortSpec) )
+	return that->fiList;
+    else
+	return 0;
+}
+
+/*!
+    \overload
+
+    Returns TRUE if the \e directory exists; otherwise returns FALSE.
+    (If a file with the same name is found this function will return
+    FALSE).
+
+    \sa TQFileInfo::exists(), TQFile::exists()
+*/
+
+bool TQDir::exists() const
+{
+    TQFileInfo fi( dPath );
+    return fi.exists() && fi.isDir();
+}
+
+/*!
+    Returns TRUE if the directory path is relative to the current
+    directory and returns FALSE if the path is absolute (e.g. under
+    UNIX a path is relative if it does not start with a "/").
+
+    \sa convertToAbs()
+*/
+
+bool TQDir::isRelative() const
+{
+    return isRelativePath( dPath );
+}
+
+/*!
+    Converts the directory path to an absolute path. If it is already
+    absolute nothing is done.
+
+    \sa isRelative()
+*/
+
+void TQDir::convertToAbs()
+{
+    dPath = absPath();
+}
+
+/*!
+    Makes a copy of TQDir \a d and assigns it to this TQDir.
+*/
+
+TQDir &TQDir::operator=( const TQDir &d )
+{
+    dPath    = d.dPath;
+    delete fList;
+    fList    = 0;
+    delete fiList;
+    fiList   = 0;
+    nameFilt = d.nameFilt;
+    dirty    = TRUE;
+    allDirs  = d.allDirs;
+    filtS    = d.filtS;
+    sortS    = d.sortS;
+    return *this;
+}
+
+/*!
+    \overload
+
+    Sets the directory path to be the given \a path.
+*/
+
+TQDir &TQDir::operator=( const TQString &path )
+{
+    dPath = cleanDirPath( path );
+    dirty = TRUE;
+    return *this;
+}
+
+
+/*!
+    \fn bool TQDir::operator!=( const TQDir &d ) const
+
+    Returns TRUE if directory \a d and this directory have different
+    paths or different sort or filter settings; otherwise returns
+    FALSE.
+
+    Example:
+    \code
+    // The current directory is "/usr/local"
+    TQDir d1( "/usr/local/bin" );
+    TQDir d2( "bin" );
+    if ( d1 != d2 )
+	qDebug( "They differ" );
+    \endcode
+*/
+
+/*!
+    Returns TRUE if directory \a d and this directory have the same
+    path and their sort and filter settings are the same; otherwise
+    returns FALSE.
+
+    Example:
+    \code
+    // The current directory is "/usr/local"
+    TQDir d1( "/usr/local/bin" );
+    TQDir d2( "bin" );
+    d2.convertToAbs();
+    if ( d1 == d2 )
+	qDebug( "They're the same" );
+    \endcode
+*/
+
+bool TQDir::operator==( const TQDir &d ) const
+{
+    return dPath    == d.dPath &&
+	   nameFilt == d.nameFilt &&
+	   allDirs  == d.allDirs &&
+	   filtS    == d.filtS &&
+	   sortS    == d.sortS;
+}
+
+
+/*!
+    Removes the file, \a fileName.
+
+    If \a acceptAbsPath is TRUE a path starting with separator "/"
+    will remove the file with the absolute path. If \a acceptAbsPath
+    is FALSE any number of separators at the beginning of \a fileName
+    will be removed and the resultant file name will be removed.
+
+    Returns TRUE if the file is removed successfully; otherwise
+    returns FALSE.
+*/
+
+bool TQDir::remove( const TQString &fileName, bool acceptAbsPath )
+{
+    if ( fileName.isEmpty() ) {
+#if defined(TQT_CHECK_NULL)
+	qWarning( "TQDir::remove: Empty or null file name" );
+#endif
+	return FALSE;
+    }
+    TQString p = filePath( fileName, acceptAbsPath );
+    return TQFile::remove( p );
+}
+
+/*!
+    Checks for the existence of the file \a name.
+
+    If \a acceptAbsPath is TRUE a path starting with separator "/"
+    will check the file with the absolute path. If \a acceptAbsPath is
+    FALSE any number of separators at the beginning of \a name will be
+    removed and the resultant file name will be checked.
+
+    Returns TRUE if the file exists; otherwise returns FALSE.
+
+    \sa TQFileInfo::exists(), TQFile::exists()
+*/
+
+bool TQDir::exists( const TQString &name, bool acceptAbsPath ) //### const in 4.0
+{
+    if ( name.isEmpty() ) {
+#if defined(TQT_CHECK_NULL)
+	qWarning( "TQDir::exists: Empty or null file name" );
+#endif
+	return FALSE;
+    }
+    TQString tmp = filePath( name, acceptAbsPath );
+    return TQFile::exists( tmp );
+}
+
+/*!
+    Returns the native directory separator; "/" under UNIX (including
+    Mac OS X) and "\" under Windows.
+
+    You do not need to use this function to build file paths. If you
+    always use "/", TQt will translate your paths to conform to the
+    underlying operating system.
+*/
+
+char TQDir::separator()
+{
+#if defined(TQ_OS_UNIX)
+    return '/';
+#elif defined (TQ_FS_FAT) || defined(TQ_WS_WIN)
+    return '\\';
+#elif defined (TQ_OS_MAC)
+    return ':';
+#else
+    return '/';
+#endif
+}
+
+/*!
+    Returns the application's current directory.
+
+    Use path() to access a TQDir object's path.
+
+    \sa currentDirPath(), TQDir::TQDir()
+*/
+
+TQDir TQDir::current()
+{
+    return TQDir( currentDirPath() );
+}
+
+/*!
+    Returns the home directory.
+
+    Under Windows the \c HOME environment variable is used. If this
+    does not exist the \c USERPROFILE environment variable is used. If
+    that does not exist the path is formed by concatenating the \c
+    HOMEDRIVE and \c HOMEPATH environment variables. If they don't
+    exist the rootDirPath() is used (this uses the \c SystemDrive
+    environment variable). If none of these exist "C:\" is used.
+
+    Under non-Windows operating systems the \c HOME environment
+    variable is used if it exists, otherwise rootDirPath() is used.
+
+    \sa homeDirPath()
+*/
+
+TQDir TQDir::home()
+{
+    return TQDir( homeDirPath() );
+}
+
+/*!
+    Returns the root directory.
+
+    \sa rootDirPath() drives()
+*/
+
+TQDir TQDir::root()
+{
+    return TQDir( rootDirPath() );
+}
+
+/*!
+    \fn TQString TQDir::homeDirPath()
+
+    Returns the absolute path of the user's home directory.
+
+    \sa home()
+*/
+
+TQValueList<TQRegExp> qt_makeFilterList( const TQString &filter )
+{
+    TQValueList<TQRegExp> regExps;
+    if ( filter.isEmpty() )
+	return regExps;
+
+    TQChar sep( ';' );
+    int i = filter.tqfind( sep, 0 );
+    if ( i == -1 && filter.tqfind( ' ', 0 ) != -1 )
+	sep = TQChar( ' ' );
+
+    TQStringList list = TQStringList::split( sep, filter );
+    TQStringList::Iterator it = list.begin();
+    while ( it != list.end() ) {
+	regExps << TQRegExp( (*it).stripWhiteSpace(), CaseSensitiveFS, TRUE );
+	++it;
+    }
+    return regExps;
+}
+
+bool qt_matchFilterList( const TQValueList<TQRegExp>& filters,
+			 const TQString &fileName )
+{
+    TQValueList<TQRegExp>::ConstIterator rit = filters.begin();
+    while ( rit != filters.end() ) {
+	if ( (*rit).exactMatch(fileName) )
+	    return TRUE;
+	++rit;
+    }
+    return FALSE;
+}
+
+
+/*!
+    \overload
+
+    Returns TRUE if the \a fileName matches any of the wildcard (glob)
+    patterns in the list of \a filters; otherwise returns FALSE.
+
+    (See \link tqregexp.html#wildcard-matching TQRegExp wildcard
+    matching.\endlink)
+    \sa TQRegExp::match()
+*/
+
+bool TQDir::match( const TQStringList &filters, const TQString &fileName )
+{
+    TQStringList::ConstIterator sit = filters.begin();
+    while ( sit != filters.end() ) {
+	TQRegExp rx( *sit, CaseSensitiveFS, TRUE );
+	if ( rx.exactMatch(fileName) )
+	    return TRUE;
+	++sit;
+    }
+    return FALSE;
+}
+
+/*!
+    Returns TRUE if the \a fileName matches the wildcard (glob)
+    pattern \a filter; otherwise returns FALSE. The \a filter may
+    contain multiple patterns separated by spaces or semicolons.
+
+    (See \link tqregexp.html#wildcard-matching TQRegExp wildcard
+    matching.\endlink)
+    \sa TQRegExp::match()
+*/
+
+bool TQDir::match( const TQString &filter, const TQString &fileName )
+{
+    return qt_matchFilterList( qt_makeFilterList(filter), fileName );
+}
+
+
+/*!
+    Removes all multiple directory separators "/" and resolves any
+    "."s or ".."s found in the path, \a filePath.
+
+    Symbolic links are kept. This function does not return the
+    canonical path, but rather the simplest version of the input.
+    For example, "./local" becomes "local", "local/../bin" becomes
+    "bin" and "/local/usr/../bin" becomes "/local/bin".
+
+    \sa absPath() canonicalPath()
+*/
+
+TQString TQDir::cleanDirPath( const TQString &filePath )
+{
+    TQString name = filePath;
+    TQString newPath;
+
+    if ( name.isEmpty() )
+	return name;
+
+    slashify( name );
+
+    bool addedSeparator = isRelativePath( name );
+    if ( addedSeparator )
+	name.insert( 0, '/' );
+
+    int ePos, pos, upLevel;
+
+    pos = ePos = name.length();
+    upLevel = 0;
+    int len;
+
+    while ( pos && (pos = name.tqfindRev('/', pos - 1)) != -1 ) {
+	len = ePos - pos - 1;
+	if ( len == 2 && name.at(pos + 1) == '.'
+		      && name.at(pos + 2) == '.' ) {
+	    upLevel++;
+	} else {
+	    if ( len != 0 && (len != 1 || name.at(pos + 1) != '.') ) {
+		if ( !upLevel )
+		    newPath = TQString::tqfromLatin1("/")
+			+ name.mid(pos + 1, len) + newPath;
+		else
+		    upLevel--;
+	    }
+	}
+	ePos = pos;
+    }
+    if ( addedSeparator ) {
+	while ( upLevel-- )
+	    newPath.insert( 0, TQString::tqfromLatin1("/..") );
+	if ( !newPath.isEmpty() )
+	    newPath.remove( (uint)0, (uint)1 );
+	else
+	    newPath = TQString::tqfromLatin1(".");
+    } else {
+	if ( newPath.isEmpty() )
+	    newPath = TQString::tqfromLatin1("/");
+#if defined(TQ_FS_FAT) || defined(TQ_OS_OS2EMX)
+	if ( name[0] == '/' ) {
+	    if ( name[1] == '/' )		// "\\machine\x\ ..."
+		newPath.insert( 0, '/' );
+	} else {
+	    newPath = name.left(2) + newPath;
+	}
+#endif
+    }
+    return newPath;
+}
+
+int qt_cmp_si_sortSpec;
+
+#if defined(TQ_C_CALLBACKS)
+extern "C" {
+#endif
+
+#ifdef TQ_OS_TEMP
+int __cdecl qt_cmp_si( const void *n1, const void *n2 )
+#else
+int qt_cmp_si( const void *n1, const void *n2 )
+#endif
+{
+    if ( !n1 || !n2 )
+	return 0;
+
+    TQDirSortItem* f1 = (TQDirSortItem*)n1;
+    TQDirSortItem* f2 = (TQDirSortItem*)n2;
+
+    if ( qt_cmp_si_sortSpec & TQDir::DirsFirst )
+	if ( f1->item->isDir() != f2->item->isDir() )
+	    return f1->item->isDir() ? -1 : 1;
+
+    int r = 0;
+    int sortBy = qt_cmp_si_sortSpec & TQDir::SortByMask;
+
+    switch ( sortBy ) {
+      case TQDir::Time:
+	r = f1->item->lastModified().secsTo(f2->item->lastModified());
+	break;
+      case TQDir::Size:
+	r = f2->item->size() - f1->item->size();
+	break;
+      default:
+	;
+    }
+
+    if ( r == 0 && sortBy != TQDir::Unsorted ) {
+	// Still not sorted - sort by name
+	bool ic = qt_cmp_si_sortSpec & TQDir::IgnoreCase;
+
+	if ( f1->filename_cache.isNull() )
+	    f1->filename_cache = ic ? f1->item->fileName().lower()
+				    : f1->item->fileName();
+	if ( f2->filename_cache.isNull() )
+	    f2->filename_cache = ic ? f2->item->fileName().lower()
+				    : f2->item->fileName();
+
+	r = qt_cmp_si_sortSpec & TQDir::LocaleAware
+            ? f1->filename_cache.localeAwareCompare(f2->filename_cache)
+            : f1->filename_cache.compare(f2->filename_cache);
+    }
+
+    if ( r == 0 ) {
+	// Enforce an order - the order the items appear in the array
+	r = (char*)n1 - (char*)n2;
+    }
+
+    if ( qt_cmp_si_sortSpec & TQDir::Reversed )
+	return -r;
+    else
+	return r;
+}
+
+#if defined(TQ_C_CALLBACKS)
+}
+#endif
+
+/*! \internal
+    Detaches all internal data.
+*/
+void TQDir::detach()
+{
+    // deepcopy
+    dPath = TQDeepCopy<TQString>(dPath);
+    nameFilt = TQDeepCopy<TQString>(nameFilt);
+
+    if ( fList )
+	*fList = TQDeepCopy<TQStringList>( *fList );
+
+    if ( fiList ) {
+	TQFileInfoList *newlist = new TQFileInfoList( *fiList );
+	delete fiList;
+	fiList = newlist;
+    }
+}
+
+#endif // TQT_NO_DIR
diff --git a/tqtinterface/qt4/src/tools/tqdir.h b/tqtinterface/qt4/src/tools/tqdir.h
new file mode 100644
index 0000000..864a37e
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqdir.h
@@ -0,0 +1,250 @@
+/****************************************************************************
+**
+** Definition of TQDir class
+**
+** Created : 950427
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQDIR_H
+#define TQDIR_H
+
+#ifndef TQT_H
+#include "tqglobal.h"
+#include "tqstrlist.h"
+#include "tqfileinfo.h"
+#endif // TQT_H
+
+
+#ifndef TQT_NO_DIR
+typedef TQPtrList<TQFileInfo> TQFileInfoList;
+typedef TQPtrListIterator<TQFileInfo> TQFileInfoListIterator;
+class TQStringList;
+template <class T> class TQDeepCopy;
+
+
+class TQ_EXPORT TQDir
+{
+public:
+    enum FilterSpec { Dirs	    = 0x001,
+		      Files	    = 0x002,
+		      Drives	    = 0x004,
+		      NoSymLinks    = 0x008,
+		      All	    = 0x007,
+		      TypeMask	    = 0x00F,
+
+		      Readable	    = 0x010,
+		      Writable	    = 0x020,
+		      Executable    = 0x040,
+		      RWEMask	    = 0x070,
+
+		      Modified	    = 0x080,
+		      Hidden	    = 0x100,
+		      System	    = 0x200,
+		      AccessMask    = 0x3F0,
+
+		      DefaultFilter = -1 };
+
+    enum SortSpec   { Name	    = 0x00,
+		      Time	    = 0x01,
+		      Size	    = 0x02,
+		      Unsorted	    = 0x03,
+		      SortByMask    = 0x03,
+
+		      DirsFirst	    = 0x04,
+		      Reversed	    = 0x08,
+		      IgnoreCase    = 0x10,
+                      LocaleAware   = 0x20, 
+		      DefaultSort   = -1 };
+
+    TQDir();
+    TQDir( const TQString &path, const TQString &nameFilter = TQString::null,
+	  int sortSpec = Name | IgnoreCase, int filterSpec = All );
+    TQDir( const TQDir & );
+
+    virtual ~TQDir();
+
+    TQDir       &operator=( const TQDir & );
+    TQDir       &operator=( const TQString &path );
+
+    virtual void setPath( const TQString &path );
+    virtual TQString path()		const;
+    virtual TQString absPath()	const;
+    virtual TQString canonicalPath()	const;
+
+    virtual TQString dirName() const;
+    virtual TQString filePath( const TQString &fileName,
+			      bool acceptAbsPath = TRUE ) const;
+    virtual TQString absFilePath( const TQString &fileName,
+				 bool acceptAbsPath = TRUE ) const;
+
+    static TQString convertSeparators( const TQString &pathName );
+
+    virtual bool cd( const TQString &dirName, bool acceptAbsPath = TRUE );
+    virtual bool cdUp();
+
+    TQString	nameFilter() const;
+    virtual void setNameFilter( const TQString &nameFilter );
+    FilterSpec filter() const;
+    virtual void setFilter( int filterSpec );
+    SortSpec sorting() const;
+    virtual void setSorting( int sortSpec );
+
+    bool	matchAllDirs() const;
+    virtual void setMatchAllDirs( bool );
+
+    uint count() const;
+    TQString	operator[]( int ) const;
+
+    virtual TQStrList encodedEntryList( int filterSpec = DefaultFilter,
+				       int sortSpec   = DefaultSort  ) const;
+    virtual TQStrList encodedEntryList( const TQString &nameFilter,
+				       int filterSpec = DefaultFilter,
+				       int sortSpec   = DefaultSort   ) const;
+    virtual TQStringList entryList( int filterSpec = DefaultFilter,
+				   int sortSpec   = DefaultSort  ) const;
+    virtual TQStringList entryList( const TQString &nameFilter,
+				   int filterSpec = DefaultFilter,
+				   int sortSpec   = DefaultSort   ) const;
+
+    virtual const TQFileInfoList *entryInfoList( int filterSpec = DefaultFilter,
+						int sortSpec = DefaultSort ) const;
+    virtual const TQFileInfoList *entryInfoList( const TQString &nameFilter,
+						int filterSpec = DefaultFilter,
+						int sortSpec = DefaultSort ) const;
+
+    static const TQFileInfoList *drives();
+
+    virtual bool mkdir( const TQString &dirName,
+			bool acceptAbsPath = TRUE ) const;
+    virtual bool rmdir( const TQString &dirName,
+			bool acceptAbsPath = TRUE ) const;
+
+    virtual bool isReadable() const;
+    virtual bool exists()   const;
+    virtual bool isRoot()   const;
+
+    virtual bool isRelative() const;
+    virtual void convertToAbs();
+
+    virtual bool operator==( const TQDir & ) const;
+    virtual bool operator!=( const TQDir & ) const;
+
+    virtual bool remove( const TQString &fileName,
+			 bool acceptAbsPath = TRUE );
+    virtual bool rename( const TQString &name, const TQString &newName,
+			 bool acceptAbsPaths = TRUE  );
+    virtual bool exists( const TQString &name,
+			 bool acceptAbsPath = TRUE );
+
+    static char separator();
+
+    static bool setCurrent( const TQString &path );
+    static TQDir current();
+    static TQDir home();
+    static TQDir root();
+    static TQString currentDirPath();
+    static TQString homeDirPath();
+    static TQString rootDirPath();
+
+    static bool match( const TQStringList &filters, const TQString &fileName );
+    static bool match( const TQString &filter, const TQString &fileName );
+    static TQString cleanDirPath( const TQString &dirPath );
+    static bool isRelativePath( const TQString &path );
+    void refresh() const;
+
+private:
+#ifdef TQ_OS_MAC
+    typedef struct FSSpec FSSpec;
+    static FSSpec *make_spec(const TQString &);
+#endif
+    void init();
+    virtual bool readDirEntries( const TQString &nameFilter,
+				 int FilterSpec, int SortSpec  );
+
+    static void slashify( TQString & );
+
+    TQString	dPath;
+    TQStringList   *fList;
+    TQFileInfoList *fiList;
+    TQString	nameFilt;
+    FilterSpec	filtS;
+    SortSpec	sortS;
+    uint	dirty	: 1;
+    uint	allDirs : 1;
+
+    void detach();
+    friend class TQDeepCopy< TQDir >;
+};
+
+
+inline TQString TQDir::path() const
+{
+    return dPath;
+}
+
+inline TQString TQDir::nameFilter() const
+{
+    return nameFilt;
+}
+
+inline TQDir::FilterSpec TQDir::filter() const
+{
+    return filtS;
+}
+
+inline TQDir::SortSpec TQDir::sorting() const
+{
+    return sortS;
+}
+
+inline bool TQDir::matchAllDirs() const
+{
+    return allDirs;
+}
+
+inline bool TQDir::operator!=( const TQDir &d ) const
+{
+    return !(*this == d);
+}
+
+
+struct TQDirSortItem {
+    TQString filename_cache;
+    TQFileInfo* item;
+};
+
+#endif // TQT_NO_DIR
+#endif // TQDIR_H
diff --git a/tqtinterface/qt4/src/tools/tqdir_p.h b/tqtinterface/qt4/src/tools/tqdir_p.h
new file mode 100644
index 0000000..802771a
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqdir_p.h
@@ -0,0 +1,82 @@
+/****************************************************************************
+**
+** Definition of some private TQDir functions.
+**
+** Created : 001106
+**
+** Copyright (C) 2005-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQDIR_P_H
+#define TQDIR_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the TQt API.  It exists for the convenience
+// of qdir.cpp and qdir_*.cpp.
+// This header file may change from version to version without notice,
+// or even be removed.
+//
+// We mean it.
+//
+//
+
+#ifndef TQT_H
+#include "tqregexp.h"
+#include "tqvaluelist.h"
+#endif // TQT_H
+
+extern TQValueList<TQRegExp> qt_makeFilterList( const TQString & );
+extern bool qt_matchFilterList( const TQValueList<TQRegExp> &, const TQString & );
+
+extern int qt_cmp_si_sortSpec;
+
+#if defined(TQ_C_CALLBACKS)
+extern "C" {
+#endif
+
+#ifdef TQ_OS_TEMP
+extern int __cdecl qt_cmp_si( const void *, const void * );
+#else
+extern int qt_cmp_si( const void *, const void * );
+#endif
+
+#if defined(TQ_C_CALLBACKS)
+}
+#endif
+
+
+#endif // TQDIR_P_H
diff --git a/tqtinterface/qt4/src/tools/tqdir_unix.cpp b/tqtinterface/qt4/src/tools/tqdir_unix.cpp
new file mode 100644
index 0000000..5d69993
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqdir_unix.cpp
@@ -0,0 +1,302 @@
+/****************************************************************************
+**
+** Implementation of TQDir class
+**
+** Created : 950628
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "tqplatformdefs.h"
+#include "tqdir.h"
+
+#ifndef TQT_NO_DIR
+
+#include "tqdir_p.h"
+#include "tqfileinfo.h"
+#include "tqregexp.h"
+#include "tqstringlist.h"
+
+#ifdef TQT_THREAD_SUPPORT
+#  include <private/tqmutexpool_p.h>
+#endif // TQT_THREAD_SUPPORT
+
+#include <stdlib.h>
+#include <limits.h>
+#include <errno.h>
+
+
+void TQDir::slashify( TQString& )
+{
+}
+
+TQString TQDir::homeDirPath()
+{
+    TQString d;
+    d = TQFile::decodeName(getenv("HOME"));
+    slashify( d );
+    if ( d.isNull() )
+	d = rootDirPath();
+    return d;
+}
+
+TQString TQDir::canonicalPath() const
+{
+    TQString r;
+    char cur[PATH_MAX+1];
+    if ( ::getcwd( cur, PATH_MAX ) ) {
+	char tmp[PATH_MAX+1];
+	// need the cast for old solaris versions of realpath that doesn't take
+	// a const char*.
+	if( ::realpath( (char*)TQFile::encodeName( dPath ).data(), tmp ) )
+	    r = TQFile::decodeName( tmp );
+	slashify( r );
+
+    	// always make sure we go back to the current dir
+	::chdir( cur );
+    }
+    return r;
+}
+
+bool TQDir::mkdir( const TQString &dirName, bool acceptAbsPath ) const
+{
+#if defined(TQ_OS_MACX)  // Mac X doesn't support trailing /'s
+    TQString name = dirName;
+    if (dirName[dirName.length() - 1] == "/")
+	name = dirName.left( dirName.length() - 1 );
+    int status =
+	::mkdir( TQFile::encodeName(filePath(name,acceptAbsPath)), 0777 );
+#else
+    int status =
+	::mkdir( TQFile::encodeName(filePath(dirName,acceptAbsPath)), 0777 );
+#endif
+    return status == 0;
+}
+
+bool TQDir::rmdir( const TQString &dirName, bool acceptAbsPath ) const
+{
+    return ::rmdir( TQFile::encodeName(filePath(dirName,acceptAbsPath)) ) == 0;
+}
+
+bool TQDir::isReadable() const
+{
+    return ::access( TQFile::encodeName(dPath), R_OK | X_OK ) == 0;
+}
+
+bool TQDir::isRoot() const
+{
+    return dPath == TQString::tqfromLatin1("/");
+}
+
+bool TQDir::rename( const TQString &name, const TQString &newName,
+		   bool acceptAbsPaths	)
+{
+    if ( name.isEmpty() || newName.isEmpty() ) {
+#if defined(TQT_CHECK_NULL)
+	qWarning( "TQDir::rename: Empty or null file name(s)" );
+#endif
+	return FALSE;
+    }
+    TQString fn1 = filePath( name, acceptAbsPaths );
+    TQString fn2 = filePath( newName, acceptAbsPaths );
+    return ::rename( TQFile::encodeName(fn1),
+		     TQFile::encodeName(fn2) ) == 0;
+}
+
+bool TQDir::setCurrent( const TQString &path )
+{
+    int r;
+    r = ::chdir( TQFile::encodeName(path) );
+    return r >= 0;
+}
+
+TQString TQDir::currentDirPath()
+{
+    TQString result;
+
+    struct stat st;
+    if ( ::stat( ".", &st ) == 0 ) {
+	char currentName[PATH_MAX+1];
+	if ( ::getcwd( currentName, PATH_MAX ) )
+	    result = TQFile::decodeName(currentName);
+#if defined(TQT_DEBUG)
+	if ( result.isNull() )
+	    qWarning( "TQDir::currentDirPath: getcwd() failed" );
+#endif
+    } else {
+#if defined(TQT_DEBUG)
+	qWarning( "TQDir::currentDirPath: stat(\".\") failed" );
+#endif
+    }
+    slashify( result );
+    return result;
+}
+
+TQString TQDir::rootDirPath()
+{
+    TQString d = TQString::tqfromLatin1( "/" );
+    return d;
+}
+
+bool TQDir::isRelativePath( const TQString &path )
+{
+    int len = path.length();
+    if ( len == 0 )
+	return TRUE;
+    return path[0] != '/';
+}
+
+bool TQDir::readDirEntries( const TQString &nameFilter,
+			   int filterSpec, int sortSpec )
+{
+    int i;
+    if ( !fList ) {
+	fList  = new TQStringList;
+	TQ_CHECK_PTR( fList );
+	fiList = new TQFileInfoList;
+	TQ_CHECK_PTR( fiList );
+	fiList->setAutoDelete( TRUE );
+    } else {
+	fList->clear();
+	fiList->clear();
+    }
+
+    TQValueList<TQRegExp> filters = qt_makeFilterList( nameFilter );
+
+    bool doDirs	    = (filterSpec & Dirs)	!= 0;
+    bool doFiles    = (filterSpec & Files)	!= 0;
+    bool noSymLinks = (filterSpec & NoSymLinks) != 0;
+    bool doReadable = (filterSpec & Readable)	!= 0;
+    bool doWritable = (filterSpec & Writable)	!= 0;
+    bool doExecable = (filterSpec & Executable) != 0;
+    bool doHidden   = (filterSpec & Hidden)	!= 0;
+    bool doSystem   = (filterSpec & System)     != 0;
+
+    TQFileInfo fi;
+    DIR	     *dir;
+    dirent   *file;
+
+    dir = opendir( TQFile::encodeName(dPath) );
+    if ( !dir )
+	return FALSE; // cannot read the directory
+
+#if defined(TQT_THREAD_SUPPORT) && defined(_POSIX_THREAD_SAFE_FUNCTIONS) && !defined(TQ_OS_CYGWIN)
+    union {
+	struct dirent mt_file;
+	char b[sizeof(struct dirent) + MAXNAMLEN + 1];
+    } u;
+    while ( readdir_r(dir, &u.mt_file, &file ) == 0 && file )
+#else
+    while ( (file = readdir(dir)) )
+#endif // TQT_THREAD_SUPPORT && _POSIX_THREAD_SAFE_FUNCTIONS
+    {
+	TQString fn = TQFile::decodeName(file->d_name);
+	fi.setFile( *this, fn );
+	if ( !qt_matchFilterList(filters, fn) && !(allDirs && fi.isDir()) )
+	     continue;
+	if  ( (doDirs && fi.isDir()) || (doFiles && fi.isFile()) ||
+	      (doSystem && (!fi.isFile() && !fi.isDir())) ) {
+	    if ( noSymLinks && fi.isSymLink() )
+	        continue;
+	    if ( (filterSpec & RWEMask) != 0 )
+	        if ( (doReadable && !fi.isReadable()) ||
+	             (doWritable && !fi.isWritable()) ||
+	             (doExecable && !fi.isExecutable()) )
+	            continue;
+	    if ( !doHidden && fn[0] == '.' &&
+	         fn != TQString::tqfromLatin1(".")
+	         && fn != TQString::tqfromLatin1("..") )
+	        continue;
+	    fiList->append( new TQFileInfo( fi ) );
+	}
+    }
+    if ( closedir(dir) != 0 ) {
+#if defined(TQT_CHECK_NULL)
+	qWarning( "TQDir::readDirEntries: Cannot close the directory: %s",
+		  dPath.local8Bit().data() );
+#endif
+    }
+
+    // Sort...
+    if(fiList->count()) {
+	TQDirSortItem* si= new TQDirSortItem[fiList->count()];
+	TQFileInfo* itm;
+	i=0;
+	for (itm = fiList->first(); itm; itm = fiList->next())
+	    si[i++].item = itm;
+	qt_cmp_si_sortSpec = sortSpec;
+	qsort( si, i, sizeof(si[0]), qt_cmp_si );
+	// put them back in the list
+	fiList->setAutoDelete( FALSE );
+	fiList->clear();
+	int j;
+	for ( j=0; j<i; j++ ) {
+	    fiList->append( si[j].item );
+	    fList->append( si[j].item->fileName() );
+	}
+	delete [] si;
+	fiList->setAutoDelete( TRUE );
+    }
+
+    if ( filterSpec == (FilterSpec)filtS && sortSpec == (SortSpec)sortS &&
+	 nameFilter == nameFilt )
+	dirty = FALSE;
+    else
+	dirty = TRUE;
+    return TRUE;
+}
+
+const TQFileInfoList * TQDir::drives()
+{
+    // at most one instance of TQFileInfoList is leaked, and this variable
+    // points to that list
+    static TQFileInfoList * knownMemoryLeak = 0;
+
+    if ( !knownMemoryLeak ) {
+
+#ifdef TQT_THREAD_SUPPORT
+	TQMutexLocker locker( tqt_global_mutexpool ?
+			     tqt_global_mutexpool->get( &knownMemoryLeak ) : 0 );
+#endif // TQT_THREAD_SUPPORT
+
+	if ( !knownMemoryLeak ) {
+	    knownMemoryLeak = new TQFileInfoList;
+	    // non-win32 versions both use just one root directory
+	    knownMemoryLeak->append( new TQFileInfo( rootDirPath() ) );
+	}
+    }
+
+    return knownMemoryLeak;
+}
+#endif //TQT_NO_DIR
diff --git a/tqtinterface/qt4/src/tools/tqfeatures.h b/tqtinterface/qt4/src/tools/tqfeatures.h
new file mode 100644
index 0000000..f06fe39
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqfeatures.h
@@ -0,0 +1,984 @@
+// All feature and their dependencies
+//
+// This list is generated from $TQTDIR/src/tools/qfeatures.txt
+//
+// Asynchronous I/O
+//#define TQT_NO_ASYNC_IO
+
+// Bezier curves
+//#define TQT_NO_BEZIER
+
+// Buttons
+//#define TQT_NO_BUTTON
+
+// Named colors
+//#define TQT_NO_COLORNAMES
+
+// Cursors
+//#define TQT_NO_CURSOR
+
+// TQDataStream
+//#define TQT_NO_DATASTREAM
+
+// TQDate/TQTime/TQDateTime toString() and fromString()
+//#define TQT_NO_DATESTRING
+
+// Dialogs
+//#define TQT_NO_DIALOG
+
+// TQDirectPainter
+//#define TQT_NO_DIRECTPAINTER
+
+// Special widget effects (fading, scrolling)
+//#define TQT_NO_EFFECTS
+
+// Freetype font engine
+//#define TQT_NO_FREETYPE
+
+// Dither TQImage to 1-bit image
+//#define TQT_NO_IMAGE_DITHER_TO_1
+
+// TQImage::createHeuristicMask()
+//#define TQT_NO_IMAGE_HEURISTIC_MASK
+
+// TQImage mirroring
+//#define TQT_NO_IMAGE_MIRROR
+
+// Smooth TQImage scaling
+//#define TQT_NO_IMAGE_SMOOTHSCALE
+
+// TrueColor TQImage
+//#define TQT_NO_IMAGE_TRUECOLOR
+
+// Automatic widget tqlayout
+//#define TQT_NO_LAYOUT
+
+// Networking
+//#define TQT_NO_NETWORK
+
+// Palettes
+//#define TQT_NO_PALETTE
+
+// Alpha-blended cursor
+//#define TQT_NO_TQWS_ALPHA_CURSOR
+
+// 1-bit monochrome
+//#define TQT_NO_TQWS_DEPTH_1
+
+// 15 or 16-bit color
+//#define TQT_NO_TQWS_DEPTH_16
+
+// 24-bit color
+//#define TQT_NO_TQWS_DEPTH_24
+
+// 32-bit color
+//#define TQT_NO_TQWS_DEPTH_32
+
+// 4-bit grayscale
+//#define TQT_NO_TQWS_DEPTH_4
+
+// 8-bit color
+//#define TQT_NO_TQWS_DEPTH_8
+
+// 8-bit grayscale
+//#define TQT_NO_TQWS_DEPTH_8GRAYSCALE
+
+// Favour code size over graphics speed
+//#define TQT_NO_TQWS_GFX_SPEED
+
+// Console keyboard
+//#define TQT_NO_TQWS_KEYBOARD
+
+// Linux framebuffer
+//#define TQT_NO_TQWS_LINUXFB
+
+// Mach64 acceleration
+//#define TQT_NO_TQWS_MACH64
+
+// Window Manager
+//#define TQT_NO_TQWS_MANAGER
+
+// Matrox MGA acceleration
+//#define TQT_NO_TQWS_MATROX
+
+// Autodetecting mouse driver
+//#define TQT_NO_TQWS_MOUSE_AUTO
+
+// Non-autodetecting mouse driver
+//#define TQT_NO_TQWS_MOUSE_MANUAL
+
+// TQt/Embedded window system properties.
+//#define TQT_NO_TQWS_PROPERTIES
+
+// Repeater display
+//#define TQT_NO_TQWS_REPEATER
+
+// Saving of fonts
+//#define TQT_NO_TQWS_SAVEFONTS
+
+// Shadow frame buffer
+//#define TQT_NO_TQWS_SHADOWFB
+
+// Virtual frame buffer
+//#define TQT_NO_TQWS_VFB
+
+// 4-bit VGA
+//#define TQT_NO_TQWS_VGA_16
+
+// Voodoo3 acceleration
+//#define TQT_NO_TQWS_VOODOO3
+
+// Range-control widgets
+//#define TQT_NO_RANGECONTROL
+
+// Regular expression capture
+//#define TQT_NO_REGEXP
+
+// TQSignalMapper
+//#define TQT_NO_SIGNALMAPPER
+
+// Playing sounds
+//#define TQT_NO_SOUND
+
+// Standard template library compatiblity
+//#define TQT_NO_STL
+
+// TQStringList
+//#define TQT_NO_STRINGLIST
+
+// Character set conversions
+//#define TQT_NO_TEXTCODEC
+
+// TQTextStream
+//#define TQT_NO_TEXTSTREAM
+
+// Unicode property tables
+//#define TQT_NO_UNICODETABLES
+
+// Input validators
+//#define TQT_NO_VALIDATOR
+
+// TQVariant
+//#define TQT_NO_VARIANT
+
+// Wheel-mouse events
+//#define TQT_NO_WHEELEVENT
+
+// TQWMatrix
+//#define TQT_NO_WMATRIX
+
+// Non-Unicode text conversions
+#if !defined(TQT_NO_CODECS) && (defined(TQT_NO_TEXTCODEC))
+#define TQT_NO_CODECS
+#endif
+
+// TQCop IPC
+#if !defined(TQT_NO_COP) && (defined(TQT_NO_DATASTREAM))
+#define TQT_NO_COP
+#endif
+
+// TQFontDatabase
+#if !defined(TQT_NO_FONTDATABASE) && (defined(TQT_NO_STRINGLIST))
+#define TQT_NO_FONTDATABASE
+#endif
+
+// Image formats
+#if !defined(TQT_NO_IMAGEIO) && (defined(TQT_NO_REGEXP))
+#define TQT_NO_IMAGEIO
+#endif
+
+// 16-bit TQImage
+#if !defined(TQT_NO_IMAGE_16_BIT) && (defined(TQT_NO_IMAGE_TRUECOLOR))
+#define TQT_NO_IMAGE_16_BIT
+#endif
+
+// Image file text strings
+#if !defined(TQT_NO_IMAGE_TEXT) && (defined(TQT_NO_STRINGLIST))
+#define TQT_NO_IMAGE_TEXT
+#endif
+
+// Shared library wrapper
+#if !defined(TQT_NO_LIBRARY) && (defined(TQT_NO_REGEXP))
+#define TQT_NO_LIBRARY
+#endif
+
+// Pixmap transformations
+#if !defined(TQT_NO_PIXMAP_TRANSFORMATION) && (defined(TQT_NO_WMATRIX))
+#define TQT_NO_PIXMAP_TRANSFORMATION
+#endif
+
+// Convert UUID to/from string
+#if !defined(TQT_NO_TQUUID_STRING) && (defined(TQT_NO_STRINGLIST))
+#define TQT_NO_TQUUID_STRING
+#endif
+
+// The "BeOS" style
+#if !defined(TQT_NO_TQWS_BEOS_WM_STYLE) && (defined(TQT_NO_TQWS_MANAGER))
+#define TQT_NO_TQWS_BEOS_WM_STYLE
+#endif
+
+// Visible cursor
+#if !defined(TQT_NO_TQWS_CURSOR) && (defined(TQT_NO_CURSOR))
+#define TQT_NO_TQWS_CURSOR
+#endif
+
+// 32-bit color, BGR order
+#if !defined(TQT_NO_TQWS_DEPTH_32_BGR) && (defined(TQT_NO_TQWS_DEPTH_32))
+#define TQT_NO_TQWS_DEPTH_32_BGR
+#endif
+
+// The "Hydro" style
+#if !defined(TQT_NO_TQWS_HYDRO_WM_STYLE) && (defined(TQT_NO_TQWS_MANAGER))
+#define TQT_NO_TQWS_HYDRO_WM_STYLE
+#endif
+
+// Keyboard for SHARP Zaurus SL5xxx tqdevices
+#if !defined(TQT_NO_TQWS_KBD_SHARP) && (defined(TQT_NO_TQWS_KEYBOARD))
+#define TQT_NO_TQWS_KBD_SHARP
+#endif
+
+// The "KDE2" style
+#if !defined(TQT_NO_TQWS_KDE2_WM_STYLE) && (defined(TQT_NO_TQWS_MANAGER))
+#define TQT_NO_TQWS_KDE2_WM_STYLE
+#endif
+
+// The "KDE" style
+#if !defined(TQT_NO_TQWS_KDE_WM_STYLE) && (defined(TQT_NO_TQWS_MANAGER))
+#define TQT_NO_TQWS_KDE_WM_STYLE
+#endif
+
+// Multi-process architecture
+#if !defined(TQT_NO_TQWS_MULTIPROCESS) && (defined(TQT_NO_NETWORK))
+#define TQT_NO_TQWS_MULTIPROCESS
+#endif
+
+// Transformed frame buffer
+#if !defined(TQT_NO_TQWS_TRANSFORMED) && (defined(TQT_NO_TQWS_LINUXFB))
+#define TQT_NO_TQWS_TRANSFORMED
+#endif
+
+// Remote frame buffer (VNC)
+#if !defined(TQT_NO_TQWS_VNC) && (defined(TQT_NO_NETWORK))
+#define TQT_NO_TQWS_VNC
+#endif
+
+// The "Windows" style
+#if !defined(TQT_NO_TQWS_WINDOWS_WM_STYLE) && (defined(TQT_NO_TQWS_MANAGER))
+#define TQT_NO_TQWS_WINDOWS_WM_STYLE
+#endif
+
+// Regular expression anchors
+#if !defined(TQT_NO_REGEXP_ANCHOR_ALT) && (defined(TQT_NO_REGEXP))
+#define TQT_NO_REGEXP_ANCHOR_ALT
+#endif
+
+// Regular expression back-reference
+#if !defined(TQT_NO_REGEXP_BACKREF) && (defined(TQT_NO_REGEXP))
+#define TQT_NO_REGEXP_BACKREF
+#endif
+
+// Regular expression character-class
+#if !defined(TQT_NO_REGEXP_CCLASS) && (defined(TQT_NO_REGEXP))
+#define TQT_NO_REGEXP_CCLASS
+#endif
+
+// Regular expression escape
+#if !defined(TQT_NO_REGEXP_ESCAPE) && (defined(TQT_NO_REGEXP))
+#define TQT_NO_REGEXP_ESCAPE
+#endif
+
+// Regular expression interval
+#if !defined(TQT_NO_REGEXP_INTERVAL) && (defined(TQT_NO_REGEXP))
+#define TQT_NO_REGEXP_INTERVAL
+#endif
+
+// Regular expression lookahead
+#if !defined(TQT_NO_REGEXP_LOOKAHEAD) && (defined(TQT_NO_REGEXP))
+#define TQT_NO_REGEXP_LOOKAHEAD
+#endif
+
+// Regular expression optimization
+#if !defined(TQT_NO_REGEXP_OPTIM) && (defined(TQT_NO_REGEXP))
+#define TQT_NO_REGEXP_OPTIM
+#endif
+
+// Regular expression wildcard
+#if !defined(TQT_NO_REGEXP_WILDCARD) && (defined(TQT_NO_REGEXP))
+#define TQT_NO_REGEXP_WILDCARD
+#endif
+
+// Semi-modal dialogs
+#if !defined(TQT_NO_SEMIMODAL) && (defined(TQT_NO_DIALOG))
+#define TQT_NO_SEMIMODAL
+#endif
+
+// Session management
+#if !defined(TQT_NO_SESSIONMANAGER) && (defined(TQT_NO_STRINGLIST))
+#define TQT_NO_SESSIONMANAGER
+#endif
+
+// TQString::sprintf()
+#if !defined(TQT_NO_SPRINTF) && (defined(TQT_NO_REGEXP))
+#define TQT_NO_SPRINTF
+#endif
+
+// Scaling and rotation
+#if !defined(TQT_NO_TRANSFORMATIONS) && (defined(TQT_NO_WMATRIX))
+#define TQT_NO_TRANSFORMATIONS
+#endif
+
+// Translations via TQObject::tr()
+#if !defined(TQT_NO_TRANSLATION) && (defined(TQT_NO_DATASTREAM))
+#define TQT_NO_TRANSLATION
+#endif
+
+// Window icon and caption
+#if !defined(TQT_NO_WIDGET_TOPEXTRA) && (defined(TQT_NO_IMAGE_HEURISTIC_MASK))
+#define TQT_NO_WIDGET_TOPEXTRA
+#endif
+
+// Keyboard accelerators and shortcuts
+#if !defined(TQT_NO_ACCEL) && (defined(TQT_NO_SPRINTF))
+#define TQT_NO_ACCEL
+#endif
+
+// Asynchronous image I/O
+#if !defined(TQT_NO_ASYNC_IMAGE_IO) && (defined(TQT_NO_IMAGEIO))
+#define TQT_NO_ASYNC_IMAGE_IO
+#endif
+
+// BDF font files
+#if !defined(TQT_NO_BDF) && (defined(TQT_NO_TEXTSTREAM) || defined(TQT_NO_STRINGLIST))
+#define TQT_NO_BDF
+#endif
+
+// TQDir
+#if !defined(TQT_NO_DIR) && (defined(TQT_NO_STRINGLIST) || defined(TQT_NO_REGEXP))
+#define TQT_NO_DIR
+#endif
+
+// JPEG image I/O
+#if !defined(TQT_NO_IMAGEIO_JPEG) && (defined(TQT_NO_IMAGEIO))
+#define TQT_NO_IMAGEIO_JPEG
+#endif
+
+// MNG image I/O
+#if !defined(TQT_NO_IMAGEIO_MNG) && (defined(TQT_NO_IMAGEIO))
+#define TQT_NO_IMAGEIO_MNG
+#endif
+
+// PNG image I/O
+#if !defined(TQT_NO_IMAGEIO_PNG) && (defined(TQT_NO_IMAGEIO))
+#define TQT_NO_IMAGEIO_PNG
+#endif
+
+// PPM image I/O
+#if !defined(TQT_NO_IMAGEIO_PPM) && (defined(TQT_NO_IMAGEIO))
+#define TQT_NO_IMAGEIO_PPM
+#endif
+
+// XBM image I/O
+#if !defined(TQT_NO_IMAGEIO_XBM) && (defined(TQT_NO_IMAGEIO))
+#define TQT_NO_IMAGEIO_XBM
+#endif
+
+// Image transformations
+#if !defined(TQT_NO_IMAGE_TRANSFORMATION) && (defined(TQT_NO_PIXMAP_TRANSFORMATION))
+#define TQT_NO_IMAGE_TRANSFORMATION
+#endif
+
+// External process invocation.
+#if !defined(TQT_NO_PROCESS) && (defined(TQT_NO_STRINGLIST) || defined(TQT_NO_REGEXP))
+#define TQT_NO_PROCESS
+#endif
+
+// Regular expression capture
+#if !defined(TQT_NO_REGEXP_CAPTURE) && (defined(TQT_NO_REGEXP) || defined(TQT_NO_STRINGLIST))
+#define TQT_NO_REGEXP_CAPTURE
+#endif
+
+// Splash screen widget
+#if !defined(TQT_NO_SPLASHSCREEN) && (defined(TQT_NO_IMAGEIO))
+#define TQT_NO_SPLASHSCREEN
+#endif
+
+// Template classes in TQVariant
+#if !defined(TQT_NO_TEMPLATE_VARIANT) && (defined(TQT_NO_VARIANT) || defined(TQT_NO_STRINGLIST))
+#define TQT_NO_TEMPLATE_VARIANT
+#endif
+
+// Month and day names in dates
+#if !defined(TQT_NO_TEXTDATE) && (defined(TQT_NO_STRINGLIST) || defined(TQT_NO_DATESTRING))
+#define TQT_NO_TEXTDATE
+#endif
+
+// Drawing utility functions
+#if !defined(TQT_NO_DRAWUTIL) && (defined(TQT_NO_SPRINTF) || defined(TQT_NO_PALETTE))
+#define TQT_NO_DRAWUTIL
+#endif
+
+// BMP image I/O
+#if !defined(TQT_NO_IMAGEIO_BMP) && (defined(TQT_NO_IMAGEIO) || defined(TQT_NO_DATASTREAM))
+#define TQT_NO_IMAGEIO_BMP
+#endif
+
+// TQPicture
+#if !defined(TQT_NO_PICTURE) && (defined(TQT_NO_DATASTREAM) || defined(TQT_NO_IMAGEIO))
+#define TQT_NO_PICTURE
+#endif
+
+// Translations via TQObject::trUtf8()
+#if !defined(TQT_NO_TRANSLATION_UTF8) && (defined(TQT_NO_TRANSLATION) || defined(TQT_NO_TEXTCODEC))
+#define TQT_NO_TRANSLATION_UTF8
+#endif
+
+// URL parser
+#if !defined(TQT_NO_URL) && (defined(TQT_NO_DIR))
+#define TQT_NO_URL
+#endif
+
+// Animated images
+#if !defined(TQT_NO_MOVIE) && (defined(TQT_NO_ASYNC_IO) || defined(TQT_NO_ASYNC_IMAGE_IO))
+#define TQT_NO_MOVIE
+#endif
+
+// TQStyle
+#if !defined(TQT_NO_STYLE) && (defined(TQT_NO_DRAWUTIL))
+#define TQT_NO_STYLE
+#endif
+
+// DNS
+#if !defined(TQT_NO_DNS) && (defined(TQT_NO_NETWORK) || defined(TQT_NO_STRINGLIST) || defined(TQT_NO_TEXTSTREAM) || defined(TQT_NO_SPRINTF))
+#define TQT_NO_DNS
+#endif
+
+// Framed widgets
+#if !defined(TQT_NO_FRAME) && (defined(TQT_NO_STYLE))
+#define TQT_NO_FRAME
+#endif
+
+// TQIconSet
+#if !defined(TQT_NO_ICONSET) && (defined(TQT_NO_IMAGEIO) || defined(TQT_NO_IMAGE_SMOOTHSCALE) || defined(TQT_NO_PALETTE) || defined(TQT_NO_IMAGE_HEURISTIC_MASK))
+#define TQT_NO_ICONSET
+#endif
+
+// XPM image I/O
+#if !defined(TQT_NO_IMAGEIO_XPM) && (defined(TQT_NO_IMAGEIO) || defined(TQT_NO_SPRINTF) || defined(TQT_NO_TEXTSTREAM))
+#define TQT_NO_IMAGEIO_XPM
+#endif
+
+// Network file access
+#if !defined(TQT_NO_NETWORKPROTOCOL) && (defined(TQT_NO_TEXTCODEC) || defined(TQT_NO_URL))
+#define TQT_NO_NETWORKPROTOCOL
+#endif
+
+// TQSizeGrip
+#if !defined(TQT_NO_SIZEGRIP) && (defined(TQT_NO_STYLE))
+#define TQT_NO_SIZEGRIP
+#endif
+
+// Motif style
+#if !defined(TQT_NO_STYLE_MOTIF) && (defined(TQT_NO_STYLE))
+#define TQT_NO_STYLE_MOTIF
+#endif
+
+// Windows style
+#if !defined(TQT_NO_STYLE_WINDOWS) && (defined(TQT_NO_STYLE))
+#define TQT_NO_STYLE_WINDOWS
+#endif
+
+// Internal titlebar widget
+#if !defined(TQT_NO_TITLEBAR) && (defined(TQT_NO_STYLE))
+#define TQT_NO_TITLEBAR
+#endif
+
+// XML
+#if !defined(TQT_NO_XML) && (defined(TQT_NO_TEXTSTREAM) || defined(TQT_NO_TEXTCODEC) || defined(TQT_NO_REGEXP_CAPTURE))
+#define TQT_NO_XML
+#endif
+
+// Check-boxes
+#if !defined(TQT_NO_CHECKBOX) && (defined(TQT_NO_BUTTON) || defined(TQT_NO_STYLE))
+#define TQT_NO_CHECKBOX
+#endif
+
+// Dials
+#if !defined(TQT_NO_DIAL) && (defined(TQT_NO_RANGECONTROL) || defined(TQT_NO_STYLE))
+#define TQT_NO_DIAL
+#endif
+
+// TQLabel
+#if !defined(TQT_NO_LABEL) && (defined(TQT_NO_FRAME))
+#define TQT_NO_LABEL
+#endif
+
+// TQLCDNumber
+#if !defined(TQT_NO_LCDNUMBER) && (defined(TQT_NO_FRAME))
+#define TQT_NO_LCDNUMBER
+#endif
+
+// Single-line edits
+#if !defined(TQT_NO_LINEEDIT) && (defined(TQT_NO_FRAME))
+#define TQT_NO_LINEEDIT
+#endif
+
+// MIME
+#if !defined(TQT_NO_MIME) && (defined(TQT_NO_DIR) || defined(TQT_NO_IMAGEIO) || defined(TQT_NO_TEXTCODEC))
+#define TQT_NO_MIME
+#endif
+
+// Progress bars
+#if !defined(TQT_NO_PROGRESSBAR) && (defined(TQT_NO_FRAME))
+#define TQT_NO_PROGRESSBAR
+#endif
+
+// Push-buttons
+#if !defined(TQT_NO_PUSHBUTTON) && (defined(TQT_NO_BUTTON) || defined(TQT_NO_STYLE))
+#define TQT_NO_PUSHBUTTON
+#endif
+
+// Radio-buttons
+#if !defined(TQT_NO_RADIOBUTTON) && (defined(TQT_NO_BUTTON) || defined(TQT_NO_STYLE))
+#define TQT_NO_RADIOBUTTON
+#endif
+
+// Internal resize handler
+#if !defined(TQT_NO_RESIZEHANDLER) && (defined(TQT_NO_FRAME))
+#define TQT_NO_RESIZEHANDLER
+#endif
+
+// Scroll bars
+#if !defined(TQT_NO_SCROLLBAR) && (defined(TQT_NO_RANGECONTROL) || defined(TQT_NO_STYLE))
+#define TQT_NO_SCROLLBAR
+#endif
+
+// Sliders
+#if !defined(TQT_NO_SLIDER) && (defined(TQT_NO_RANGECONTROL) || defined(TQT_NO_STYLE))
+#define TQT_NO_SLIDER
+#endif
+
+// Spinbox control widget
+#if !defined(TQT_NO_SPINWIDGET) && (defined(TQT_NO_FRAME))
+#define TQT_NO_SPINWIDGET
+#endif
+
+// tqStatus bars
+#if !defined(TQT_NO_STATUSBAR) && (defined(TQT_NO_LAYOUT) || defined(TQT_NO_STYLE))
+#define TQT_NO_STATUSBAR
+#endif
+
+// Compact Windows style
+#if !defined(TQT_NO_STYLE_COMPACT) && (defined(TQT_NO_STYLE_WINDOWS))
+#define TQT_NO_STYLE_COMPACT
+#endif
+
+// Interlace-friendly style
+#if !defined(TQT_NO_STYLE_INTERLACE) && (defined(TQT_NO_STYLE_MOTIF))
+#define TQT_NO_STYLE_INTERLACE
+#endif
+
+// Platinum style
+#if !defined(TQT_NO_STYLE_PLATINUM) && (defined(TQT_NO_STYLE_WINDOWS))
+#define TQT_NO_STYLE_PLATINUM
+#endif
+
+// Widget stacks
+#if !defined(TQT_NO_WIDGETSTACK) && (defined(TQT_NO_FRAME))
+#define TQT_NO_WIDGETSTACK
+#endif
+
+// Grid tqlayout widgets
+#if !defined(TQT_NO_GRID) && (defined(TQT_NO_LAYOUT) || defined(TQT_NO_FRAME))
+#define TQT_NO_GRID
+#endif
+
+// Group boxes
+#if !defined(TQT_NO_GROUPBOX) && (defined(TQT_NO_FRAME) || defined(TQT_NO_LAYOUT))
+#define TQT_NO_GROUPBOX
+#endif
+
+// Horizontal box tqlayout widgets
+#if !defined(TQT_NO_HBOX) && (defined(TQT_NO_LAYOUT) || defined(TQT_NO_FRAME))
+#define TQT_NO_HBOX
+#endif
+
+// Menu-oriented widgets
+#if !defined(TQT_NO_MENUDATA) && (defined(TQT_NO_ICONSET) || defined(TQT_NO_VARIANT))
+#define TQT_NO_MENUDATA
+#endif
+
+// Persistent application settings
+#if !defined(TQT_NO_SETTINGS) && (defined(TQT_NO_DIR) || defined(TQT_NO_TEXTSTREAM) || defined(TQT_NO_REGEXP_CAPTURE))
+#define TQT_NO_SETTINGS
+#endif
+
+// Splitters
+#if !defined(TQT_NO_SPLITTER) && (defined(TQT_NO_FRAME) || defined(TQT_NO_LAYOUT))
+#define TQT_NO_SPLITTER
+#endif
+
+// Table-like widgets
+#if !defined(TQT_NO_TABLEVIEW) && (defined(TQT_NO_SCROLLBAR))
+#define TQT_NO_TABLEVIEW
+#endif
+
+// Tool tips
+#if !defined(TQT_NO_TOOLTIP) && (defined(TQT_NO_LABEL))
+#define TQT_NO_TOOLTIP
+#endif
+
+// Cut and paste
+#if !defined(TQT_NO_CLIPBOARD) && (defined(TQT_NO_TQWS_PROPERTIES) || defined(TQT_NO_MIME))
+#define TQT_NO_CLIPBOARD
+#endif
+
+// Horizontal group boxes
+#if !defined(TQT_NO_HGROUPBOX) && (defined(TQT_NO_GROUPBOX))
+#define TQT_NO_HGROUPBOX
+#endif
+
+// Properties
+#if !defined(TQT_NO_PROPERTIES) && (defined(TQT_NO_VARIANT) || defined(TQT_NO_STRINGLIST) || defined(TQT_NO_ICONSET))
+#define TQT_NO_PROPERTIES
+#endif
+
+// RichText (HTML) display
+#if !defined(TQT_NO_RICHTEXT) && (defined(TQT_NO_STYLE) || defined(TQT_NO_LAYOUT) || defined(TQT_NO_STRINGLIST) || defined(TQT_NO_TEXTSTREAM))
+#define TQT_NO_RICHTEXT
+#endif
+
+// SQL classes
+#if !defined(TQT_NO_SQL) && (defined(TQT_NO_STRINGLIST) || defined(TQT_NO_REGEXP_CAPTURE) || defined(TQT_NO_VARIANT) || defined(TQT_NO_SPRINTF) || defined(TQT_NO_DATESTRING))
+#define TQT_NO_SQL
+#endif
+
+// CDE style
+#if !defined(TQT_NO_STYLE_CDE) && (defined(TQT_NO_STYLE_MOTIF) || defined(TQT_NO_TRANSFORMATIONS))
+#define TQT_NO_STYLE_CDE
+#endif
+
+// Vertical box tqlayout widgets
+#if !defined(TQT_NO_VBOX) && (defined(TQT_NO_HBOX))
+#define TQT_NO_VBOX
+#endif
+
+// Button groups
+#if !defined(TQT_NO_BUTTONGROUP) && (defined(TQT_NO_GROUPBOX) || defined(TQT_NO_BUTTON))
+#define TQT_NO_BUTTONGROUP
+#endif
+
+// Complex scripts (eg. BiDi)
+#if !defined(TQT_NO_COMPLEXTEXT) && (defined(TQT_NO_RICHTEXT))
+#define TQT_NO_COMPLEXTEXT
+#endif
+
+// Cut and paste non-text
+#if !defined(TQT_NO_MIMECLIPBOARD) && (defined(TQT_NO_CLIPBOARD))
+#define TQT_NO_MIMECLIPBOARD
+#endif
+
+// Printing
+#if !defined(TQT_NO_PRINTER) && (defined(TQT_NO_TEXTSTREAM) || defined(TQT_NO_SPRINTF) || defined(TQT_NO_FONTDATABASE) || defined(TQT_NO_DATESTRING) || defined(TQT_NO_REGEXP_CAPTURE))
+#define TQT_NO_PRINTER
+#endif
+
+// Aqua style
+#if !defined(TQT_NO_STYLE_ATQUA) && (defined(TQT_NO_STYLE_WINDOWS) || defined(TQT_NO_IMAGE_TRANSFORMATION))
+#define TQT_NO_STYLE_ATQUA
+#endif
+
+// Vertical group boxes
+#if !defined(TQT_NO_VGROUPBOX) && (defined(TQT_NO_HGROUPBOX))
+#define TQT_NO_VGROUPBOX
+#endif
+
+// Horizontal button groups
+#if !defined(TQT_NO_HBUTTONGROUP) && (defined(TQT_NO_BUTTONGROUP))
+#define TQT_NO_HBUTTONGROUP
+#endif
+
+// Server to play sound
+#if !defined(TQT_NO_TQWS_SOUNDSERVER) && (defined(TQT_NO_SOUND) || defined(TQT_NO_DIR) || defined(TQT_NO_DNS))
+#define TQT_NO_TQWS_SOUNDSERVER
+#endif
+
+// TQHeader
+#if !defined(TQT_NO_HEADER) && (defined(TQT_NO_STYLE) || defined(TQT_NO_ICONSET))
+#define TQT_NO_HEADER
+#endif
+
+// Vertical button groups
+#if !defined(TQT_NO_VBUTTONGROUP) && (defined(TQT_NO_HBUTTONGROUP))
+#define TQT_NO_VBUTTONGROUP
+#endif
+
+// Hebrew Codec
+#if !defined(TQT_NO_CODEC_HEBREW) && (defined(TQT_NO_CODECS) || defined(TQT_NO_COMPLEXTEXT))
+#define TQT_NO_CODEC_HEBREW
+#endif
+
+// HTTP file access
+#if !defined(TQT_NO_NETWORKPROTOCOL_HTTP) && (defined(TQT_NO_NETWORKPROTOCOL) || defined(TQT_NO_DNS))
+#define TQT_NO_NETWORKPROTOCOL_HTTP
+#endif
+
+// Tool-buttons
+#if !defined(TQT_NO_TOOLBUTTON) && (defined(TQT_NO_BUTTON) || defined(TQT_NO_ICONSET) || defined(TQT_NO_STYLE))
+#define TQT_NO_TOOLBUTTON
+#endif
+
+// Big Codecs (eg. CJK)
+#if !defined(TQT_NO_BIG_CODECS) && (defined(TQT_NO_CODEC_HEBREW))
+#define TQT_NO_BIG_CODECS
+#endif
+
+// Experimental internal class
+#if !defined(TQT_NO_DIALOGBUTTONS) && (defined(TQT_NO_LAYOUT) || defined(TQT_NO_STYLE) || defined(TQT_NO_PUSHBUTTON))
+#define TQT_NO_DIALOGBUTTONS
+#endif
+
+// Document Object Model
+#if !defined(TQT_NO_DOM) && (defined(TQT_NO_XML) || defined(TQT_NO_MIME))
+#define TQT_NO_DOM
+#endif
+
+// Scrollable view widgets
+#if !defined(TQT_NO_SCROLLVIEW) && (defined(TQT_NO_SCROLLBAR) || defined(TQT_NO_FRAME))
+#define TQT_NO_SCROLLVIEW
+#endif
+
+// Tab-bars
+#if !defined(TQT_NO_TABBAR) && (defined(TQT_NO_TOOLBUTTON))
+#define TQT_NO_TABBAR
+#endif
+
+// Drag and drop
+#if !defined(TQT_NO_DRAGANDDROP) && (defined(TQT_NO_MIME) || defined(TQT_NO_TQWS_PROPERTIES) || defined(TQT_NO_IMAGEIO_XPM))
+#define TQT_NO_DRAGANDDROP
+#endif
+
+// TQGridView
+#if !defined(TQT_NO_GRIDVIEW) && (defined(TQT_NO_SCROLLVIEW))
+#define TQT_NO_GRIDVIEW
+#endif
+
+// Popup-menus
+#if !defined(TQT_NO_POPUPMENU) && (defined(TQT_NO_MENUDATA) || defined(TQT_NO_FRAME))
+#define TQT_NO_POPUPMENU
+#endif
+
+// TQCanvas
+#if !defined(TQT_NO_CANVAS) && (defined(TQT_NO_SCROLLVIEW) || defined(TQT_NO_BEZIER))
+#define TQT_NO_CANVAS
+#endif
+
+// Dynamic module linking
+#if !defined(TQT_NO_COMPONENT) && (defined(TQT_NO_TQUUID_STRING) || defined(TQT_NO_SETTINGS) || defined(TQT_NO_SPRINTF) || defined(TQT_NO_LIBRARY) || defined(TQT_NO_DATESTRING))
+#define TQT_NO_COMPONENT
+#endif
+
+// TQListBox
+#if !defined(TQT_NO_LISTBOX) && (defined(TQT_NO_SCROLLVIEW) || defined(TQT_NO_STRINGLIST))
+#define TQT_NO_LISTBOX
+#endif
+
+// Menu bars
+#if !defined(TQT_NO_MENUBAR) && (defined(TQT_NO_POPUPMENU))
+#define TQT_NO_MENUBAR
+#endif
+
+// TQMessageBox
+#if !defined(TQT_NO_MESSAGEBOX) && (defined(TQT_NO_DIALOG) || defined(TQT_NO_PUSHBUTTON) || defined(TQT_NO_LABEL))
+#define TQT_NO_MESSAGEBOX
+#endif
+
+// FTP file access
+#if !defined(TQT_NO_NETWORKPROTOCOL_FTP) && (defined(TQT_NO_NETWORKPROTOCOL) || defined(TQT_NO_DNS) || defined(TQT_NO_TEXTDATE))
+#define TQT_NO_NETWORKPROTOCOL_FTP
+#endif
+
+// Spin boxes
+#if !defined(TQT_NO_SPINBOX) && (defined(TQT_NO_RANGECONTROL) || defined(TQT_NO_SPINWIDGET) || defined(TQT_NO_LINEEDIT) || defined(TQT_NO_VALIDATOR))
+#define TQT_NO_SPINBOX
+#endif
+
+// RichText (HTML) tables and images
+#if !defined(TQT_NO_TEXTCUSTOMITEM) && (defined(TQT_NO_RICHTEXT) || defined(TQT_NO_MIME))
+#define TQT_NO_TEXTCUSTOMITEM
+#endif
+
+// TQDateTimeEdit
+#if !defined(TQT_NO_DATETIMEEDIT) && (defined(TQT_NO_RICHTEXT) || defined(TQT_NO_SPINWIDGET) || defined(TQT_NO_DATESTRING))
+#define TQT_NO_DATETIMEEDIT
+#endif
+
+// TQTextCodecPlugin
+#if !defined(TQT_NO_TEXTCODECPLUGIN) && (defined(TQT_NO_COMPONENT) || defined(TQT_NO_TEXTCODEC))
+#define TQT_NO_TEXTCODECPLUGIN
+#endif
+
+// TQImageFormatPlugin
+#if !defined(TQT_NO_IMAGEFORMATPLUGIN) && (defined(TQT_NO_COMPONENT) || defined(TQT_NO_IMAGEIO))
+#define TQT_NO_IMAGEFORMATPLUGIN
+#endif
+
+// TQSqlForm
+#if !defined(TQT_NO_STQL_FORM) && (defined(TQT_NO_SQL) || defined(TQT_NO_PROPERTIES))
+#define TQT_NO_STQL_FORM
+#endif
+
+// Scalable Vector Graphics (SVG)
+#if !defined(TQT_NO_SVG) && (defined(TQT_NO_DOM) || defined(TQT_NO_TRANSFORMATIONS) || defined(TQT_NO_SPRINTF))
+#define TQT_NO_SVG
+#endif
+
+// TQIconView
+#if !defined(TQT_NO_ICONVIEW) && (defined(TQT_NO_SCROLLVIEW) || defined(TQT_NO_IMAGEIO_XPM) || defined(TQT_NO_IMAGE_HEURISTIC_MASK))
+#define TQT_NO_ICONVIEW
+#endif
+
+// Tab widgets
+#if !defined(TQT_NO_TABWIDGET) && (defined(TQT_NO_TABBAR) || defined(TQT_NO_WIDGETSTACK))
+#define TQT_NO_TABWIDGET
+#endif
+
+// "What's this" help
+#if !defined(TQT_NO_WHATSTHIS) && (defined(TQT_NO_TOOLTIP) || defined(TQT_NO_TOOLBUTTON))
+#define TQT_NO_WHATSTHIS
+#endif
+
+// TQWidgetPlugin
+#if !defined(TQT_NO_WIDGETPLUGIN) && (defined(TQT_NO_COMPONENT) || defined(TQT_NO_ICONSET))
+#define TQT_NO_WIDGETPLUGIN
+#endif
+
+// TQProgressDialog
+#if !defined(TQT_NO_PROGRESSDIALOG) && (defined(TQT_NO_SEMIMODAL) || defined(TQT_NO_LABEL) || defined(TQT_NO_PUSHBUTTON) || defined(TQT_NO_PROGRESSBAR))
+#define TQT_NO_PROGRESSDIALOG
+#endif
+
+// Motif-plus style
+#if !defined(TQT_NO_STYLE_MOTIFPLUS) && (defined(TQT_NO_STYLE_MOTIF) || defined(TQT_NO_TRANSFORMATIONS) || defined(TQT_NO_BUTTON) || defined(TQT_NO_SCROLLBAR) || defined(TQT_NO_SLIDER))
+#define TQT_NO_STYLE_MOTIFPLUS
+#endif
+
+// Rich text edit
+#if !defined(TQT_NO_TEXTEDIT) && (defined(TQT_NO_RICHTEXT) || defined(TQT_NO_SCROLLVIEW))
+#define TQT_NO_TEXTEDIT
+#endif
+
+// TQWizard
+#if !defined(TQT_NO_WIZARD) && (defined(TQT_NO_DIALOG) || defined(TQT_NO_WIDGETSTACK) || defined(TQT_NO_PUSHBUTTON) || defined(TQT_NO_LAYOUT) || defined(TQT_NO_LABEL))
+#define TQT_NO_WIZARD
+#endif
+
+// Multi-line edits
+#if !defined(TQT_NO_MULTILINEEDIT) && (defined(TQT_NO_TEXTEDIT))
+#define TQT_NO_MULTILINEEDIT
+#endif
+
+// Rich text syntax highlighting
+#if !defined(TQT_NO_SYNTAXHIGHLIGHTER) && (defined(TQT_NO_TEXTEDIT))
+#define TQT_NO_SYNTAXHIGHLIGHTER
+#endif
+
+// TQTextView
+#if !defined(TQT_NO_TEXTVIEW) && (defined(TQT_NO_TEXTEDIT))
+#define TQT_NO_TEXTVIEW
+#endif
+
+// TQTabDialog
+#if !defined(TQT_NO_TABDIALOG) && (defined(TQT_NO_DIALOG) || defined(TQT_NO_PUSHBUTTON) || defined(TQT_NO_LAYOUT) || defined(TQT_NO_TABWIDGET))
+#define TQT_NO_TABDIALOG
+#endif
+
+// TQTextBrowser
+#if !defined(TQT_NO_TEXTBROWSER) && (defined(TQT_NO_TEXTVIEW) || defined(TQT_NO_MIME))
+#define TQT_NO_TEXTBROWSER
+#endif
+
+// TQListView
+#if !defined(TQT_NO_LISTVIEW) && (defined(TQT_NO_SCROLLVIEW) || defined(TQT_NO_HEADER) || defined(TQT_NO_LINEEDIT))
+#define TQT_NO_LISTVIEW
+#endif
+
+// TQComboBox
+#if !defined(TQT_NO_COMBOBOX) && (defined(TQT_NO_LISTBOX) || defined(TQT_NO_LINEEDIT) || defined(TQT_NO_POPUPMENU))
+#define TQT_NO_COMBOBOX
+#endif
+
+// TQColorDialog
+#if !defined(TQT_NO_COLORDIALOG) && (defined(TQT_NO_DIALOG) || defined(TQT_NO_LABEL) || defined(TQT_NO_PUSHBUTTON) || defined(TQT_NO_LINEEDIT) || defined(TQT_NO_VALIDATOR) || defined(TQT_NO_GRIDVIEW) || defined(TQT_NO_LAYOUT))
+#define TQT_NO_COLORDIALOG
+#endif
+
+// Tool box
+#if !defined(TQT_NO_TOOLBOX) && (defined(TQT_NO_ICONSET) || defined(TQT_NO_SCROLLVIEW) || defined(TQT_NO_TOOLTIP) || defined(TQT_NO_LAYOUT) || defined(TQT_NO_TOOLBUTTON))
+#define TQT_NO_TOOLBOX
+#endif
+
+// SGI style
+#if !defined(TQT_NO_STYLE_SGI) && (defined(TQT_NO_STYLE_MOTIF) || defined(TQT_NO_TRANSFORMATIONS) || defined(TQT_NO_BUTTON) || defined(TQT_NO_SCROLLBAR) || defined(TQT_NO_SLIDER) || defined(TQT_NO_LINEEDIT) || defined(TQT_NO_MENUBAR))
+#define TQT_NO_STYLE_SGI
+#endif
+
+// TQErrorMessage
+#if !defined(TQT_NO_ERRORMESSAGE) && (defined(TQT_NO_DIALOG) || defined(TQT_NO_PUSHBUTTON) || defined(TQT_NO_LABEL) || defined(TQT_NO_CHECKBOX) || defined(TQT_NO_TEXTVIEW))
+#define TQT_NO_ERRORMESSAGE
+#endif
+
+// Main-windows
+#if !defined(TQT_NO_MAINWINDOW) && (defined(TQT_NO_STRINGLIST) || defined(TQT_NO_POPUPMENU) || defined(TQT_NO_TITLEBAR) || defined(TQT_NO_RESIZEHANDLER) || defined(TQT_NO_TOOLBUTTON) || defined(TQT_NO_STATUSBAR))
+#define TQT_NO_MAINWINDOW
+#endif
+
+// Toolbars
+#if !defined(TQT_NO_TOOLBAR) && (defined(TQT_NO_MAINWINDOW))
+#define TQT_NO_TOOLBAR
+#endif
+
+// TQAction
+#if !defined(TQT_NO_ACTION) && (defined(TQT_NO_TOOLBUTTON) || defined(TQT_NO_COMBOBOX))
+#define TQT_NO_ACTION
+#endif
+
+// TQTable
+#if !defined(TQT_NO_TABLE) && (defined(TQT_NO_COMBOBOX) || defined(TQT_NO_HEADER) || defined(TQT_NO_CHECKBOX))
+#define TQT_NO_TABLE
+#endif
+
+// TQFontDialog
+#if !defined(TQT_NO_FONTDIALOG) && (defined(TQT_NO_DIALOG) || defined(TQT_NO_FONTDATABASE) || defined(TQT_NO_COMBOBOX) || defined(TQT_NO_LABEL) || defined(TQT_NO_CHECKBOX) || defined(TQT_NO_PUSHBUTTON) || defined(TQT_NO_VGROUPBOX) || defined(TQT_NO_VALIDATOR))
+#define TQT_NO_FONTDIALOG
+#endif
+
+// TQInputDialog
+#if !defined(TQT_NO_INPUTDIALOG) && (defined(TQT_NO_DIALOG) || defined(TQT_NO_COMBOBOX) || defined(TQT_NO_LABEL) || defined(TQT_NO_PUSHBUTTON) || defined(TQT_NO_SPINBOX) || defined(TQT_NO_WIDGETSTACK) || defined(TQT_NO_LAYOUT))
+#define TQT_NO_INPUTDIALOG
+#endif
+
+// SQL value editor widgets
+#if !defined(TQT_NO_STQL_EDIT_WIDGETS) && (defined(TQT_NO_SQL) || defined(TQT_NO_SPINBOX) || defined(TQT_NO_COMBOBOX) || defined(TQT_NO_CHECKBOX) || defined(TQT_NO_DATETIMEEDIT))
+#define TQT_NO_STQL_EDIT_WIDGETS
+#endif
+
+// TQPrintDialog
+#if !defined(TQT_NO_PRINTDIALOG) && (defined(TQT_NO_DIALOG) || defined(TQT_NO_LISTVIEW) || defined(TQT_NO_PRINTER) || defined(TQT_NO_COMBOBOX) || defined(TQT_NO_LABEL) || defined(TQT_NO_BUTTONGROUP) || defined(TQT_NO_SPINBOX) || defined(TQT_NO_RADIOBUTTON) || defined(TQT_NO_PUSHBUTTON) || defined(TQT_NO_DIR))
+#define TQT_NO_PRINTDIALOG
+#endif
+
+// TQFileDialog
+#if !defined(TQT_NO_FILEDIALOG) && (defined(TQT_NO_MESSAGEBOX) || defined(TQT_NO_LISTVIEW) || defined(TQT_NO_NETWORKPROTOCOL) || defined(TQT_NO_COMBOBOX) || defined(TQT_NO_SEMIMODAL) || defined(TQT_NO_REGEXP_CAPTURE) || defined(TQT_NO_TOOLBUTTON) || defined(TQT_NO_BUTTONGROUP) || defined(TQT_NO_VBOX) || defined(TQT_NO_SPLITTER) || defined(TQT_NO_PROGRESSBAR) || defined(TQT_NO_WIDGETSTACK) || defined(TQT_NO_DATESTRING))
+#define TQT_NO_FILEDIALOG
+#endif
+
+// SQL table widgets
+#if !defined(TQT_NO_STQL_VIEW_WIDGETS) && (defined(TQT_NO_STQL_FORM) || defined(TQT_NO_STQL_EDIT_WIDGETS) || defined(TQT_NO_TABLE))
+#define TQT_NO_STQL_VIEW_WIDGETS
+#endif
+
+// TQWorkSpace
+#if !defined(TQT_NO_WORKSPACE) && (defined(TQT_NO_SCROLLBAR) || defined(TQT_NO_VBOX) || defined(TQT_NO_TITLEBAR) || defined(TQT_NO_RESIZEHANDLER) || defined(TQT_NO_POPUPMENU) || defined(TQT_NO_LABEL) || defined(TQT_NO_TOOLBUTTON) || defined(TQT_NO_MAINWINDOW) || defined(TQT_NO_TOOLBAR) || defined(TQT_NO_MENUBAR))
+#define TQT_NO_WORKSPACE
+#endif
+
diff --git a/tqtinterface/qt4/src/tools/tqfile.cpp b/tqtinterface/qt4/src/tools/tqfile.cpp
new file mode 100644
index 0000000..c53c9f7
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqfile.cpp
@@ -0,0 +1,783 @@
+/****************************************************************************
+**
+** Implementation of TQFile class
+**
+** Created : 930812
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "tqplatformdefs.h"
+
+// POSIX Large File Support redefines open -> open64
+#if defined(open)
+# undef open
+#endif
+
+// POSIX Large File Support redefines truncate -> truncate64
+#if defined(truncate)
+# undef truncate
+#endif
+
+#include "tqfile.h"
+#ifndef NO_ERRNO_H
+#include <errno.h>
+#endif
+
+
+// Duplicated from tqobject.h, but we cannot include tqobject.h here since
+// it causes qmake to not build on irix g++
+#define TQT_TRANSLATE_NOOP(scope,x) (x)
+
+const char* qt_fileerr_unknown	= TQT_TRANSLATE_NOOP( "TQFile", "Unknown error" );
+const char* qt_fileerr_read	= TQT_TRANSLATE_NOOP( "TQFile", "Could not read from the file" );
+const char* qt_fileerr_write	= TQT_TRANSLATE_NOOP( "TQFile", "Could not write to the file" );
+
+#define TQFILEERR_EACCES		TQT_TRANSLATE_NOOP( "TQFile", "Permission denied" )
+#define TQFILEERR_EMFILE		TQT_TRANSLATE_NOOP( "TQFile", "Too many open files" )
+#define TQFILEERR_ENOENT		TQT_TRANSLATE_NOOP( "TQFile", "No such file or directory" )
+#define TQFILEERR_ENOSPC		TQT_TRANSLATE_NOOP( "TQFile", "No space left on tqdevice" )
+
+#ifdef USE_QT4
+
+/*!
+    \overload
+
+    Reads a line of text.
+
+    Reads bytes from the file into string \a s, until end-of-line or
+    \a maxlen bytes have been read, whichever occurs first. Returns
+    the number of bytes read, or -1 if there was an error, e.g. end of
+    file. Any terminating newline is not stripped.
+
+    This function is only efficient for buffered files. Avoid using
+    readLine() for files that have been opened with the \c IO_Raw
+    flag.
+
+    Note that the string is read as plain Latin1 bytes, not Unicode.
+
+    \sa readBlock(), TQTextStream::readLine()
+*/
+
+TQ_LONG TQFile::readLine( TQString& s, TQ_ULONG maxlen )
+{
+    TQByteArray ba(maxlen);
+    TQ_LONG l = readLine(ba.data(),maxlen);
+    if ( l >= 0 ) {
+	ba.truncate(l);
+	s = TQString(ba);
+    }
+    return l;
+}
+
+#else // USE_QT4
+
+class TQFilePrivate
+{
+public:
+    TQString errorString;
+};
+
+extern bool qt_file_access( const TQString& fn, int t );
+
+/*!
+    \class TQFile tqfile.h
+    \reentrant
+    \brief The TQFile class is an I/O tqdevice that operates on files.
+
+    \ingroup io
+    \mainclass
+
+    TQFile is an I/O tqdevice for reading and writing binary and text
+    files. A TQFile may be used by itself or more conveniently with a
+    TQDataStream or TQTextStream.
+
+    The file name is usually passed in the constructor but can be
+    changed with setName(). You can check for a file's existence with
+    exists() and remove a file with remove().
+
+    The file is opened with open(), closed with close() and flushed
+    with flush(). Data is usually read and written using TQDataStream
+    or TQTextStream, but you can read with readBlock() and readLine()
+    and write with writeBlock(). TQFile also supports getch(),
+    ungetch() and putch().
+
+    The size of the file is returned by size(). You can get the
+    current file position or move to a new file position using the
+    at() functions. If you've reached the end of the file, atEnd()
+    returns TRUE. The file handle is returned by handle().
+
+    Here is a code fragment that uses TQTextStream to read a text file
+    line by line. It prints each line with a line number.
+    \code
+    TQStringList lines;
+    TQFile file( "file.txt" );
+    if ( file.open( IO_ReadOnly ) ) {
+	TQTextStream stream( &file );
+	TQString line;
+	int i = 1;
+	while ( !stream.atEnd() ) {
+	    line = stream.readLine(); // line of text excluding '\n'
+	    printf( "%3d: %s\n", i++, line.latin1() );
+	    lines += line;
+	}
+	file.close();
+    }
+    \endcode
+
+    Writing text is just as easy. The following example shows how to
+    write the data we read into the string list from the previous
+    example:
+    \code
+    TQFile file( "file.txt" );
+    if ( file.open( IO_WriteOnly ) ) {
+	TQTextStream stream( &file );
+	for ( TQStringList::Iterator it = lines.begin(); it != lines.end(); ++it )
+	    stream << *it << "\n";
+	file.close();
+    }
+    \endcode
+
+    The TQFileInfo class holds detailed information about a file, such
+    as access permissions, file dates and file types.
+
+    The TQDir class manages directories and lists of file names.
+
+    TQt uses Unicode file names. If you want to do your own I/O on Unix
+    systems you may want to use encodeName() (and decodeName()) to
+    convert the file name into the local encoding.
+
+    \important readAll() at()
+
+    \sa TQDataStream, TQTextStream
+*/
+
+/*!
+    \fn TQ_LONG TQFile::writeBlock( const TQByteArray& data )
+
+    \overload
+*/
+
+
+/*!
+    Constructs a TQFile with no name.
+*/
+
+TQFile::TQFile()
+: d(0)
+{
+    init();
+}
+
+/*!
+    Constructs a TQFile with a file name \a name.
+
+    \sa setName()
+*/
+
+TQFile::TQFile( const TQString &name )
+    : fn(name), d(0)
+{
+    init();
+}
+
+
+/*!
+    Destroys a TQFile. Calls close().
+*/
+
+TQFile::~TQFile()
+{
+    close();
+    delete d;
+}
+
+
+/*!
+  \internal
+  Initialize internal data.
+*/
+
+void TQFile::init()
+{
+    delete d;
+    d = new TQFilePrivate;
+    setFlags( IO_Direct );
+    setqStatus( IO_Ok );
+    setErrorString( qt_fileerr_unknown );
+    fh	   = 0;
+    fd	   = 0;
+    length = 0;
+    ioIndex = 0;
+    ext_f  = FALSE;				// not an external file handle
+}
+
+
+/*!
+    \fn TQString TQFile::name() const
+
+    Returns the name set by setName().
+
+    \sa setName(), TQFileInfo::fileName()
+*/
+
+/*!
+    Sets the name of the file to \a name. The name can have no path, a
+    relative path or an absolute absolute path.
+
+    Do not call this function if the file has already been opened.
+
+    If the file name has no path or a relative path, the path used
+    will be whatever the application's current directory path is
+    \e{at the time of the open()} call.
+
+    Example:
+    \code
+	TQFile file;
+	TQDir::setCurrent( "/tmp" );
+	file.setName( "readme.txt" );
+	TQDir::setCurrent( "/home" );
+	file.open( IO_ReadOnly );      // opens "/home/readme.txt" under Unix
+    \endcode
+
+    Note that the directory separator "/" works for all operating
+    systems supported by TQt.
+
+    \sa name(), TQFileInfo, TQDir
+*/
+
+void TQFile::setName( const TQString &name )
+{
+    if ( isOpen() ) {
+#if defined(TQT_CHECK_STATE)
+	qWarning( "TQFile::setName: File is open" );
+#endif
+	close();
+    }
+    fn = name;
+}
+
+/*!
+    \overload
+
+    Returns TRUE if this file exists; otherwise returns FALSE.
+
+    \sa name()
+*/
+
+bool TQFile::exists() const
+{
+    return qt_file_access( fn, F_OK );
+}
+
+/*!
+    Returns TRUE if the file given by \a fileName exists; otherwise
+    returns FALSE.
+*/
+
+bool TQFile::exists( const TQString &fileName )
+{
+    return qt_file_access( fileName, F_OK );
+}
+
+
+/*!
+    Removes the file specified by the file name currently set. Returns
+    TRUE if successful; otherwise returns FALSE.
+
+    The file is closed before it is removed.
+*/
+
+bool TQFile::remove()
+{
+    close();
+    return remove( fn );
+}
+
+#if defined(TQ_OS_MAC) || defined(TQ_OS_MSDOS) || defined(TQ_OS_WIN32) || defined(TQ_OS_OS2)
+# define HAS_TEXT_FILEMODE			// has translate/text filemode
+#endif
+#if defined(O_NONBLOCK)
+# define HAS_ASYNC_FILEMODE
+# define OPEN_ASYNC O_NONBLOCK
+#elif defined(O_NDELAY)
+# define HAS_ASYNC_FILEMODE
+# define OPEN_ASYNC O_NDELAY
+#endif
+
+/*!
+    Flushes the file buffer to the disk.
+
+    close() also flushes the file buffer.
+*/
+
+void TQFile::flush()
+{
+    if ( isOpen() && fh ) {			// can only flush open/buffered file
+        if ( fflush( fh )  ) {		// write error
+            if ( errno == ENOSPC )			// disk is full
+                setqStatus( IO_ResourceError );
+            else
+                setqStatus( IO_WriteError );
+            setErrorStringErrno( errno );
+        }
+    }
+}
+
+/*! \reimp
+    \fn TQIODevice::Offset TQFile::at() const
+*/
+
+/*!
+    Returns TRUE if the end of file has been reached; otherwise returns FALSE.
+    If TQFile has not been open()'d, then the behavior is undefined.
+
+    \sa size()
+*/
+
+bool TQFile::atEnd() const
+{
+    if ( !isOpen() ) {
+#if defined(TQT_CHECK_STATE)
+	qWarning( "TQFile::atEnd: File is not open" );
+#endif
+	return FALSE;
+    }
+    if ( isDirectAccess() && !isTranslated() ) {
+	if ( at() < size() )
+	    return FALSE;
+    }
+    const TQString errorString = d->errorString;
+    const bool ret = TQIODevice::atEnd();
+    if (errorString != d->errorString)
+        d->errorString = errorString;
+    return ret;
+}
+
+/*!
+    Reads a line of text.
+
+    Reads bytes from the file into the char* \a p, until end-of-line
+    or \a maxlen bytes have been read, whichever occurs first. Returns
+    the number of bytes read, or -1 if there was an error. Any
+    terminating newline is not stripped.
+
+    This function is only efficient for buffered files. Avoid
+    readLine() for files that have been opened with the \c IO_Raw
+    flag.
+
+    \sa readBlock(), TQTextStream::readLine()
+*/
+
+TQ_LONG TQFile::readLine( char *p, TQ_ULONG maxlen )
+{
+    if ( maxlen == 0 )				// application bug?
+	return 0;
+#if defined(TQT_CHECK_STATE)
+    TQ_CHECK_PTR( p );
+    if ( !isOpen() ) {				// file not open
+	qWarning( "TQFile::readLine: File not open" );
+	return -1;
+    }
+    if ( !isReadable() ) {			// reading not permitted
+	qWarning( "TQFile::readLine: Read operation not permitted" );
+	return -1;
+    }
+#endif
+    TQ_LONG nread;				// number of bytes read
+    if ( isRaw() ) {				// raw file
+	nread = TQIODevice::readLine( p, maxlen );
+    } else {					// buffered file
+	p = fgets( p, maxlen, fh );
+	if ( p ) {
+	    nread = tqstrlen( p );
+	    if ( !isSequentialAccess() )
+		ioIndex += nread;
+	} else {
+	    nread = -1;
+	    setqStatus(IO_ReadError);
+	    setErrorString( qt_fileerr_read );
+	}
+    }
+    return nread;
+}
+
+
+/*!
+    \overload
+
+    Reads a line of text.
+
+    Reads bytes from the file into string \a s, until end-of-line or
+    \a maxlen bytes have been read, whichever occurs first. Returns
+    the number of bytes read, or -1 if there was an error, e.g. end of
+    file. Any terminating newline is not stripped.
+
+    This function is only efficient for buffered files. Avoid using
+    readLine() for files that have been opened with the \c IO_Raw
+    flag.
+
+    Note that the string is read as plain Latin1 bytes, not Unicode.
+
+    \sa readBlock(), TQTextStream::readLine()
+*/
+
+TQ_LONG TQFile::readLine( TQString& s, TQ_ULONG maxlen )
+{
+    TQByteArray ba(maxlen);
+    TQ_LONG l = readLine(ba.data(),maxlen);
+    if ( l >= 0 ) {
+	ba.truncate(l);
+	s = TQString(ba);
+    }
+    return l;
+}
+
+
+/*!
+    Reads a single byte/character from the file.
+
+    Returns the byte/character read, or -1 if the end of the file has
+    been reached.
+
+    \sa putch(), ungetch()
+*/
+
+int TQFile::getch()
+{
+#if defined(TQT_CHECK_STATE)
+    if ( !isOpen() ) {				// file not open
+	qWarning( "TQFile::getch: File not open" );
+	return EOF;
+    }
+    if ( !isReadable() ) {			// reading not permitted
+	qWarning( "TQFile::getch: Read operation not permitted" );
+	return EOF;
+    }
+#endif
+
+    int ch;
+
+    if ( !ungetchBuffer.isEmpty() ) {
+	int len = ungetchBuffer.length();
+	ch = ungetchBuffer[ len-1 ];
+	ungetchBuffer.truncate( len - 1 );
+	return ch;
+    }
+
+    if ( isRaw() ) {				// raw file (inefficient)
+	char buf[1];
+	ch = readBlock( buf, 1 ) == 1 ? buf[0] : EOF;
+    } else {					// buffered file
+	if ( (ch = getc( fh )) != EOF ) {
+	    if ( !isSequentialAccess() )
+		ioIndex++;
+	} else {
+	    setqStatus(IO_ReadError);
+	    setErrorString( qt_fileerr_read );
+	}
+    }
+    return ch;
+}
+
+/*!
+    Writes the character \a ch to the file.
+
+    Returns \a ch, or -1 if some error occurred.
+
+    \sa getch(), ungetch()
+*/
+
+int TQFile::putch( int ch )
+{
+#if defined(TQT_CHECK_STATE)
+    if ( !isOpen() ) {				// file not open
+	qWarning( "TQFile::putch: File not open" );
+	return EOF;
+    }
+    if ( !isWritable() ) {			// writing not permitted
+	qWarning( "TQFile::putch: Write operation not permitted" );
+	return EOF;
+    }
+#endif
+    if ( isRaw() ) {				// raw file (inefficient)
+	char buf[1];
+	buf[0] = ch;
+	ch = writeBlock( buf, 1 ) == 1 ? ch : EOF;
+    } else {					// buffered file
+	if ( (ch = putc( ch, fh )) != EOF ) {
+	    if ( !isSequentialAccess() )
+		ioIndex++;
+	    if ( ioIndex > length )		// update file length
+		length = ioIndex;
+	} else {
+	    setqStatus(IO_WriteError);
+	    setErrorString( qt_fileerr_write );
+	}
+    }
+    return ch;
+}
+
+/*!
+    Puts the character \a ch back into the file and decrements the
+    index if it is not zero.
+
+    This function is normally called to "undo" a getch() operation.
+
+    Returns \a ch, or -1 if an error occurred.
+
+    \sa getch(), putch()
+*/
+
+int TQFile::ungetch( int ch )
+{
+#if defined(TQT_CHECK_STATE)
+    if ( !isOpen() ) {				// file not open
+	qWarning( "TQFile::ungetch: File not open" );
+	return EOF;
+    }
+    if ( !isReadable() ) {			// reading not permitted
+	qWarning( "TQFile::ungetch: Read operation not permitted" );
+	return EOF;
+    }
+#endif
+    if ( ch == EOF )				// cannot unget EOF
+	return ch;
+
+    if ( isSequentialAccess() && !fh) {
+	// pipe or similar => we cannot ungetch, so do it manually
+	ungetchBuffer += TQChar(ch);
+	return ch;
+    }
+
+    if ( isRaw() ) {				// raw file (very inefficient)
+	char buf[1];
+	at( ioIndex-1 );
+	buf[0] = ch;
+	if ( writeBlock(buf, 1) == 1 )
+	    at ( ioIndex-1 );
+	else
+	    ch = EOF;
+    } else {					// buffered file
+	if ( (ch = ungetc(ch, fh)) != EOF ) {
+	    if ( !isSequentialAccess() )
+		ioIndex--;
+	} else {
+	    setqStatus( IO_ReadError );
+	    setErrorString( qt_fileerr_read );
+	}
+    }
+    return ch;
+}
+
+
+static TQCString locale_encoder( const TQString &fileName )
+{
+    return fileName.local8Bit();
+}
+
+
+static TQFile::EncoderFn encoder = locale_encoder;
+
+/*!
+    When you use TQFile, TQFileInfo, and TQDir to access the file system
+    with TQt, you can use Unicode file names. On Unix, these file names
+    are converted to an 8-bit encoding. If you want to do your own
+    file I/O on Unix, you should convert the file name using this
+    function. On Windows NT/2000, Unicode file names are supported
+    directly in the file system and this function should be avoided.
+    On Windows 95, non-Latin1 locales are not supported.
+
+    By default, this function converts \a fileName to the local 8-bit
+    encoding determined by the user's locale. This is sufficient for
+    file names that the user chooses. File names hard-coded into the
+    application should only use 7-bit ASCII filename characters.
+
+    The conversion scheme can be changed using setEncodingFunction().
+    This might be useful if you wish to give the user an option to
+    store file names in UTF-8, etc., but be aware that such file names
+    would probably then be unrecognizable when seen by other programs.
+
+    \sa decodeName()
+*/
+
+TQCString TQFile::encodeName( const TQString &fileName )
+{
+    return (*encoder)(fileName);
+}
+
+/*!
+    \enum TQFile::EncoderFn
+
+    This is used by TQFile::setEncodingFunction().
+*/
+
+/*!
+    \nonreentrant
+
+    Sets the function for encoding Unicode file names to \a f. The
+    default encodes in the locale-specific 8-bit encoding.
+
+    \sa encodeName()
+*/
+void TQFile::setEncodingFunction( EncoderFn f )
+{
+    encoder = f;
+}
+
+static
+TQString locale_decoder( const TQCString &localFileName )
+{
+#ifndef TQ_WS_MAC
+    return TQString::fromLocal8Bit(localFileName);
+#else
+    extern TQString qt_mac_precomposeFileName(const TQString &); // qglobal.cpp
+    return qt_mac_precomposeFileName(TQString::fromLocal8Bit(localFileName));
+#endif
+}
+
+static TQFile::DecoderFn decoder = locale_decoder;
+
+/*!
+    This does the reverse of TQFile::encodeName() using \a localFileName.
+
+    \sa setDecodingFunction()
+*/
+TQString TQFile::decodeName( const TQCString &localFileName )
+{
+    return (*decoder)(localFileName);
+}
+
+/*!
+    \enum TQFile::DecoderFn
+
+    This is used by TQFile::setDecodingFunction().
+*/
+
+/*!
+    \nonreentrant
+
+    Sets the function for decoding 8-bit file names to \a f. The
+    default uses the locale-specific 8-bit encoding.
+
+    \sa encodeName(), decodeName()
+*/
+
+void TQFile::setDecodingFunction( DecoderFn f )
+{
+    decoder = f;
+}
+
+/*!
+    Returns a human-readable description of the reason of an error that occurred
+    on the tqdevice. The error described by the string corresponds to changes of
+    TQIODevice::status(). If the status is reset, the error string is also reset.
+
+    The returned strings are not translated with the TQObject::tr() or
+    TQApplication::translate() functions. They are marked as translatable
+    strings in the "TQFile" context. Before you show the string to the user you
+    should translate it first, for example:
+
+    \code
+	TQFile f( "address.dat" );
+	if ( !f.open( IO_ReadOnly ) {
+	    TQMessageBox::critical(
+		this,
+		tr("Open failed"),
+		tr("Could not open file for reading: %1").arg( tqApp->translate("TQFile",f.errorString()) )
+		);
+	    return;
+	}
+    \endcode
+
+    \sa TQIODevice::status(), TQIODevice::resetqStatus(), setErrorString()
+*/
+
+TQString	TQFile::errorString() const
+{
+    if ( status() == IO_Ok )
+	return qt_fileerr_unknown;
+    return d->errorString;
+}
+
+/*!
+    \nonreentrant
+
+    Sets the error string returned by the errorString() function to \a str.
+
+    \sa errorString(), TQIODevice::status()
+*/
+
+void TQFile::setErrorString( const TQString& str )
+{
+    d->errorString = str;
+}
+
+void TQFile::setErrorStringErrno( int errnum )
+{
+    switch ( errnum ) {
+	case EACCES:
+	    d->errorString = TQFILEERR_EACCES;
+	    break;
+	case EMFILE:
+	    d->errorString = TQFILEERR_EMFILE;
+	    break;
+	case ENOENT:
+	    d->errorString = TQFILEERR_ENOENT;
+	    break;
+	case ENOSPC:
+	    d->errorString = TQFILEERR_ENOSPC;
+	    break;
+	default:
+#ifndef TQ_OS_TEMP
+	    d->errorString = TQString::fromLocal8Bit( strerror( errnum ) );
+#else
+	    {
+		unsigned short *string;
+		FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,
+			       NULL,
+			       errnum,
+			       MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+			       (LPTSTR)&string,
+			       0,
+			       NULL );
+		d->errorString = TQString::fromUcs2( string );
+	        LocalFree( (HLOCAL)string );
+	    }
+#endif
+	    break;
+    }
+}
+
+#endif // USE_QT4
\ No newline at end of file
diff --git a/tqtinterface/qt4/src/tools/tqfile.h b/tqtinterface/qt4/src/tools/tqfile.h
new file mode 100644
index 0000000..10b69e6
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqfile.h
@@ -0,0 +1,209 @@
+/****************************************************************************
+**
+** Definition of TQFile class
+**
+** Created : 930831
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQFILE_H
+#define TQFILE_H
+
+#include "tqtglobaldefines.h"
+
+#ifndef TQT_H
+#include "tqiodevice.h"
+#include "tqstring.h"
+#include <stdio.h>
+#endif // TQT_H
+
+#ifdef USE_QT4
+
+#include <Qt/qfile.h>
+
+#endif // USE_QT4
+
+class TQDir;
+class TQFilePrivate;
+
+#ifdef USE_QT4
+
+class TQ_EXPORT TQFile : public QFile
+{
+public:
+	TQFile() : QFile() {}
+	TQFile( const QString &name ) : QFile( name ) {}
+
+	bool open( int aFlags, FILE * f ) { return QFile::open( f, (QIODevice::OpenModeFlag)aFlags ); }
+	bool open( int aFlags, int f ) { return QFile::open( f, (QIODevice::OpenModeFlag)aFlags ); }
+	TQString name() const { return fileName(); }
+	void setName( const QString &name ) { setFileName(name); }
+	bool open( int om ) { return QFile::open((OpenMode)om); }
+	int state() const { return isOpen() ? 0x1000 : 0; }
+
+	inline TQ_LONG readLine( char *data, TQ_ULONG maxlen ) { return QFile::readLine(data, maxlen); }
+	TQ_LONG readLine( TQString &, TQ_ULONG maxlen );
+
+	TQIODevice::Status status() const {
+#if !defined(QT_NO_QOBJECT)
+		const QFile *f = qobject_cast<const QFile *>(this);
+		if (f) return (int) f->error();
+#endif
+		return isOpen() ? 0 /* IO_Ok */ : 8 /* IO_UnspecifiedError */;
+	}
+
+	inline TQIODevice::Offset at() const { return TQT_TQIODEVICE_CONST(this)->at(); }
+	inline bool at(TQIODevice::Offset offset) { return TQT_TQIODEVICE(this)->at(offset); }
+	inline TQIODevice::Offset tqat() const { return TQT_TQIODEVICE_CONST(this)->at(); }
+	inline bool tqat(TQIODevice::Offset offset) { return TQT_TQIODEVICE(this)->at(offset); }
+
+	inline qint64 readBlock(char *data, quint64 maxlen) { return read(data, maxlen); }
+	inline qint64 writeBlock(const char *data, quint64 len) { return write(data, len); }
+	inline qint64 writeBlock(const QByteArray &data) { return write(data); }
+
+	inline int getch() { char c; return getChar(&c) ? int(uchar(c)) : -1; }
+	inline int putch(int c) { return putChar(char(c)) ? int(uchar(c)) : -1; }
+	inline int ungetch(int c) { ungetChar(uchar(c)); return c; }
+
+	inline bool isDirectAccess() const { return !isSequential(); }
+	inline bool isSequentialAccess() const { return isSequential(); }
+	inline bool isCombinedAccess() const { return false; }
+	inline bool isBuffered() const { return true; }
+	inline bool isRaw() const { return false; }
+	inline bool isSynchronous() const { return true; }
+	inline bool isAsynchronous() const { return false; }
+	inline bool isTranslated() const { return (openMode() & Text) != 0; }
+	inline bool isInactive() const { return !isOpen(); }
+
+// 	inline bool open( int mode ) = 0;
+
+protected:
+        void setqStatus( int ) { std::cout << "[WARNING] TQIODevice::setqStatus() UNIMPLEMENTED\n\r"; }
+        void resetqStatus() { TQT_TQIODEVICE(this)->resetStatus(); }
+
+	void setFlags( int f ) { setOpenMode((QIODevice::OpenModeFlag)f); }
+	void setType( int ) { printf("[WARNING] TQIODevice::setType() unimplemented\n\r"); }
+	void setMode( int f ) { setOpenMode((QIODevice::OpenModeFlag)f); }
+	void setState( int state ) {
+		switch (state) {
+			case (IO_Open):
+				open(openMode());
+				break;
+		}
+	}
+};
+
+#else // USE_QT4
+
+class TQ_EXPORT TQFile : public TQIODevice			// file I/O tqdevice class
+{
+public:
+    TQFile();
+    TQFile( const TQString &name );
+   ~TQFile();
+
+    TQString	name()	const;
+    void	setName( const TQString &name );
+
+    typedef TQCString (*EncoderFn)( const TQString &fileName );
+    typedef TQString (*DecoderFn)( const TQCString &localfileName );
+    static TQCString encodeName( const TQString &fileName );
+    static TQString decodeName( const TQCString &localFileName );
+    static void setEncodingFunction( EncoderFn );
+    static void setDecodingFunction( DecoderFn );
+
+    bool	exists()   const;
+    static bool exists( const TQString &fileName );
+
+    bool	remove();
+    static bool remove( const TQString &fileName );
+
+    bool	open( int );
+    bool	open( int, FILE * );
+    bool	open( int, int );
+    void	close();
+    void	flush();
+
+    Offset	size() const;
+    Offset	at() const;
+    bool	at( Offset );
+    bool	atEnd() const;
+
+    TQ_LONG	readBlock( char *data, TQ_ULONG len );
+    TQ_LONG	writeBlock( const char *data, TQ_ULONG len );
+    TQ_LONG	writeBlock( const TQByteArray& data )
+		      { return TQIODevice::writeBlock(data); }
+    TQ_LONG	readLine( char *data, TQ_ULONG maxlen );
+    TQ_LONG	readLine( TQString &, TQ_ULONG maxlen );
+
+    int		getch();
+    int		putch( int );
+    int		ungetch( int );
+
+    int		handle() const;
+
+    TQString	errorString() const; // ### TQt 4: move into TQIODevice
+
+protected:
+    void	setErrorString( const TQString& ); // ### TQt 4: move into TQIODevice
+    TQString	fn;
+    FILE       *fh;
+    int		fd;
+    Offset	length;
+    bool	ext_f;
+    TQFilePrivate *d; // ### TQt 4: make private
+
+private:
+    void	init();
+    void	setErrorStringErrno( int );
+    TQCString	ungetchBuffer;
+
+private:	// Disabled copy constructor and operator=
+#if defined(TQ_DISABLE_COPY)
+    TQFile( const TQFile & );
+    TQFile &operator=( const TQFile & );
+#endif
+};
+
+
+inline TQString TQFile::name() const
+{ return fn; }
+
+inline TQIODevice::Offset TQFile::at() const
+{ return ioIndex; }
+
+#endif // USE_QT4
+
+#endif // TQFILE_H
diff --git a/tqtinterface/qt4/src/tools/tqfile_unix.cpp b/tqtinterface/qt4/src/tools/tqfile_unix.cpp
new file mode 100644
index 0000000..b76a2aa
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqfile_unix.cpp
@@ -0,0 +1,753 @@
+/****************************************************************************
+**
+** Implementation of TQFile class
+**
+** Created : 950628
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "tqplatformdefs.h"
+#include "tqtglobaldefines.h"
+
+// POSIX Large File Support redefines open -> open64
+static inline int qt_open(const char *pathname, int flags, mode_t mode)
+{ return ::open(pathname, flags, mode); }
+#if defined(open)
+# undef open
+#endif
+
+// POSIX Large File Support redefines truncate -> truncate64
+#if defined(truncate)
+# undef truncate
+#endif
+
+#include "tqfile.h"
+#include <errno.h>
+#include <limits.h>
+
+extern const char* qt_fileerr_read;
+
+bool qt_file_access( const TQString& fn, int t )
+{
+    if ( fn.isEmpty() )
+	return FALSE;
+    return ::access( TQFile::encodeName(fn), t ) == 0;
+}
+
+#ifdef USE_QT4
+
+#else // USE_QT4
+
+/*!
+    \overload
+    Removes the file \a fileName.
+  Returns TRUE if successful, otherwise FALSE.
+*/
+
+bool TQFile::remove( const TQString &fileName )
+{
+    if ( fileName.isEmpty() ) {
+#if defined(TQT_CHECK_NULL)
+	qWarning( "TQFile::remove: Empty or null file name" );
+#endif
+	return FALSE;
+    }
+    return unlink( TQFile::encodeName(fileName) ) == 0;
+}
+
+#if defined(O_NONBLOCK)
+# define HAS_ASYNC_FILEMODE
+# define OPEN_ASYNC O_NONBLOCK
+#elif defined(O_NDELAY)
+# define HAS_ASYNC_FILEMODE
+# define OPEN_ASYNC O_NDELAY
+#endif
+
+/*!
+    Opens the file specified by the file name currently set, using the
+    mode \a m. Returns TRUE if successful, otherwise FALSE.
+
+    \keyword IO_Raw
+    \keyword IO_ReadOnly
+    \keyword IO_WriteOnly
+    \keyword IO_ReadWrite
+    \keyword IO_Append
+    \keyword IO_Truncate
+    \keyword IO_Translate
+
+    The mode parameter \a m must be a combination of the following flags:
+    \table
+    \header \i Flag \i Meaning
+    \row \i IO_Raw
+	 \i Raw (non-buffered) file access.
+    \row \i IO_ReadOnly
+	 \i Opens the file in read-only mode.
+    \row \i IO_WriteOnly
+	 \i Opens the file in write-only mode. If this flag is used
+	    with another flag, e.g. \c IO_ReadOnly or \c IO_Raw or \c
+	    IO_Append, the file is \e not truncated; but if used on
+	    its own (or with \c IO_Truncate), the file is truncated.
+    \row \i IO_ReadWrite
+	 \i Opens the file in read/write mode, equivalent to \c
+	    (IO_ReadOnly | IO_WriteOnly).
+    \row \i IO_Append
+	 \i Opens the file in append mode. (You must actually use \c
+	    (IO_WriteOnly | IO_Append) to make the file writable and
+	    to go into append mode.) This mode is very useful when you
+	    want to write something to a log file. The file index is
+	    set to the end of the file. Note that the result is
+	    undefined if you position the file index manually using
+	    at() in append mode.
+    \row \i IO_Truncate
+	 \i Truncates the file.
+    \row \i IO_Translate
+	 \i Enables carriage returns and linefeed translation for text
+	    files under Windows.
+    \endtable
+
+    The raw access mode is best when I/O is block-operated using a 4KB
+    block size or greater. Buffered access works better when reading
+    small portions of data at a time.
+
+    \warning When working with buffered files, data may not be written
+    to the file at once. Call flush() to make sure that the data is
+    really written.
+
+    \warning If you have a buffered file opened for both reading and
+    writing you must not perform an input operation immediately after
+    an output operation or vice versa. You should always call flush()
+    or a file positioning operation, e.g. at(), between input and
+    output operations, otherwise the buffer may contain garbage.
+
+    If the file does not exist and \c IO_WriteOnly or \c IO_ReadWrite
+    is specified, it is created.
+
+    Example:
+    \code
+	TQFile f1( "/tmp/data.bin" );
+	f1.open( IO_Raw | IO_ReadWrite );
+
+	TQFile f2( "readme.txt" );
+	f2.open( IO_ReadOnly | IO_Translate );
+
+	TQFile f3( "audit.log" );
+	f3.open( IO_WriteOnly | IO_Append );
+    \endcode
+
+    \sa name(), close(), isOpen(), flush()
+*/
+
+bool TQFile::open( int m )
+{
+    if ( isOpen() ) {				// file already open
+#if defined(TQT_CHECK_STATE)
+	qWarning( "TQFile::open: File already open" );
+#endif
+	return FALSE;
+    }
+    if ( fn.isEmpty() ) {			// no file name defined
+#if defined(TQT_CHECK_NULL)
+	qWarning( "TQFile::open: No file name specified" );
+#endif
+	return FALSE;
+    }
+    init();					// reset params
+    setMode( m );
+    if ( !(isReadable() || isWritable()) ) {
+#if defined(TQT_CHECK_RANGE)
+	qWarning( "TQFile::open: File access not specified" );
+#endif
+	return FALSE;
+    }
+    bool ok = TRUE;
+    struct stat st;
+    if ( isRaw() ) {
+	int oflags = O_RDONLY;
+	if ( isReadable() && isWritable() )
+	    oflags = O_RDWR;
+	else if ( isWritable() )
+	    oflags = O_WRONLY;
+	if ( flags() & IO_Append ) {		// append to end of file?
+	    if ( flags() & IO_Truncate )
+		oflags |= (O_CREAT | O_TRUNC);
+	    else
+		oflags |= (O_APPEND | O_CREAT);
+	    setFlags( flags() | IO_WriteOnly ); // append implies write
+	} else if ( isWritable() ) {		// create/trunc if writable
+	    if ( flags() & IO_Truncate )
+		oflags |= (O_CREAT | O_TRUNC);
+	    else
+		oflags |= O_CREAT;
+	}
+#if defined(HAS_TEXT_FILEMODE)
+	if ( isTranslated() )
+	    oflags |= OPEN_TEXT;
+	else
+	    oflags |= OPEN_BINARY;
+#endif
+#if defined(HAS_ASYNC_FILEMODE)
+	if ( isAsynchronous() )
+	    oflags |= OPEN_ASYNC;
+#endif
+	fd = qt_open( TQFile::encodeName(fn), oflags, 0666 );
+
+	if ( fd != -1 ) {			// open successful
+	    ::fstat( fd, &st );			// get the stat for later usage
+	} else {
+	    ok = FALSE;
+	}
+    } else {					// buffered file I/O
+	TQCString perm;
+	char perm2[4];
+	bool try_create = FALSE;
+	if ( flags() & IO_Append ) {		// append to end of file?
+	    setFlags( flags() | IO_WriteOnly ); // append implies write
+	    perm = isReadable() ? "a+" : "a";
+	} else {
+	    if ( isReadWrite() ) {
+		if ( flags() & IO_Truncate ) {
+		    perm = "w+";
+		} else {
+		    perm = "r+";
+		    try_create = TRUE;		// try to create if not exists
+		}
+	    } else if ( isReadable() ) {
+		perm = "r";
+	    } else if ( isWritable() ) {
+		perm = "w";
+	    }
+	}
+	qstrcpy( perm2, perm );
+#if defined(HAS_TEXT_FILEMODE)
+	if ( isTranslated() )
+	    strcat( perm2, "t" );
+	else
+	    strcat( perm2, "b" );
+#endif
+	for (;;) { // At most twice
+
+	    fh = fopen( TQFile::encodeName(fn), perm2 );
+
+	    if ( !fh && try_create ) {
+		perm2[0] = 'w';			// try "w+" instead of "r+"
+		try_create = FALSE;
+	    } else {
+		break;
+	    }
+	}
+	if ( fh ) {
+	    ::fstat( fileno(fh), &st );		// get the stat for later usage
+	} else {
+	    ok = FALSE;
+	}
+    }
+    if ( ok ) {
+	setState( IO_Open );
+	// on successful open the file stat was got; now test what type
+	// of file we have
+	if ( (st.st_mode & S_IFMT) != S_IFREG ) {
+	    // non-seekable
+	    setType( IO_Sequential );
+	    length = INT_MAX;
+	    ioIndex = 0;
+	} else {
+#if defined(TQT_LARGEFILE_SUPPORT) && !defined(TQT_ABI_QT4)
+	    length = st.st_size > UINT_MAX ? UINT_MAX : (Offset)st.st_size;
+#else
+	    length = (Offset)st.st_size;
+#endif
+	    ioIndex = (flags() & IO_Append) == 0 ? 0 : length;
+	    if ( !(flags()&IO_Truncate) && length == 0 && isReadable() ) {
+		// try if you can read from it (if you can, it's a sequential
+		// tqdevice; e.g. a file in the /proc filesystem)
+		int c = getch();
+		if ( c != -1 ) {
+		    ungetch(c);
+		    setType( IO_Sequential );
+		    length = INT_MAX;
+		    ioIndex = 0;
+		}
+		resetqStatus();
+	    }
+	}
+    } else {
+	init();
+	if ( errno == EMFILE )			// no more file handles/descrs
+	    setqStatus( IO_ResourceError );
+	else
+	    setqStatus( IO_OpenError );
+	setErrorStringErrno( errno );
+    }
+    return ok;
+}
+
+/*!
+    \overload
+  Opens a file in the mode \a m using an existing file handle \a f.
+  Returns TRUE if successful, otherwise FALSE.
+
+  Example:
+  \code
+    #include <stdio.h>
+
+    void printError( const char* msg )
+    {
+	TQFile f;
+	f.open( IO_WriteOnly, stderr );
+	f.writeBlock( msg, tqstrlen(msg) );	// write to stderr
+	f.close();
+    }
+  \endcode
+
+  When a TQFile is opened using this function, close() does not actually
+  close the file, only flushes it.
+
+  \warning If \a f is \c stdin, \c stdout, \c stderr, you may not
+  be able to seek.  See TQIODevice::isSequentialAccess() for more
+  information.
+
+  \sa close()
+*/
+
+bool TQFile::open( int m, FILE *f )
+{
+    if ( isOpen() ) {
+#if defined(TQT_CHECK_RANGE)
+	qWarning( "TQFile::open: File already open" );
+#endif
+	return FALSE;
+    }
+    init();
+    setMode( m &~IO_Raw );
+    setState( IO_Open );
+    fh = f;
+    ext_f = TRUE;
+    struct stat st;
+    ::fstat( fileno(fh), &st );
+#if defined(TQT_LARGEFILE_SUPPORT)
+#if !defined(TQT_ABI_QT4)
+    off_t tmp = ftello( fh );
+    ioIndex = tmp > UINT_MAX ? UINT_MAX : (Offset)tmp;
+#else
+    ioIndex = (Offset)ftello( fh );
+#endif
+#else
+    ioIndex = (Offset)ftell( fh );
+#endif
+    if ( (st.st_mode & S_IFMT) != S_IFREG || f == stdin ) { //stdin is non seekable
+	// non-seekable
+	setType( IO_Sequential );
+	length = INT_MAX;
+	ioIndex = 0;
+    } else {
+#if defined(TQT_LARGEFILE_SUPPORT) && !defined(TQT_ABI_QT4)
+	length = st.st_size > UINT_MAX ? UINT_MAX : (Offset)st.st_size;
+#else
+	length = (Offset)st.st_size;
+#endif
+	if ( !(flags()&IO_Truncate) && length == 0 && isReadable() ) {
+	    // try if you can read from it (if you can, it's a sequential
+	    // tqdevice; e.g. a file in the /proc filesystem)
+	    int c = getch();
+	    if ( c != -1 ) {
+		ungetch(c);
+		setType( IO_Sequential );
+		length = INT_MAX;
+		ioIndex = 0;
+	    }
+	    resetqStatus();
+	}
+    }
+    return TRUE;
+}
+
+/*!
+    \overload
+  Opens a file in the mode \a m using an existing file descriptor \a f.
+  Returns TRUE if successful, otherwise FALSE.
+
+  When a TQFile is opened using this function, close() does not actually
+  close the file.
+
+  The TQFile that is opened using this function, is automatically set to be in
+  raw mode; this means that the file input/output functions are slow. If you
+  run into performance issues, you should try to use one of the other open
+  functions.
+
+  \warning If \a f is one of 0 (stdin), 1 (stdout) or 2 (stderr), you may not
+  be able to seek. size() is set to \c INT_MAX (in limits.h).
+
+  \sa close()
+*/
+
+
+bool TQFile::open( int m, int f )
+{
+    if ( isOpen() ) {
+#if defined(TQT_CHECK_RANGE)
+	qWarning( "TQFile::open: File already open" );
+#endif
+	return FALSE;
+    }
+    init();
+    setMode( m |IO_Raw );
+    setState( IO_Open );
+    fd = f;
+    ext_f = TRUE;
+    struct stat st;
+    ::fstat( fd, &st );
+#if defined(TQT_LARGEFILE_SUPPORT) && !defined(TQT_ABI_QT4)
+    off_t tmp = ::lseek(fd, 0, SEEK_CUR);
+    ioIndex = tmp > UINT_MAX ? UINT_MAX : (Offset)tmp;
+#else
+    ioIndex = (Offset)::lseek(fd, 0, SEEK_CUR);
+#endif
+    if ( (st.st_mode & S_IFMT) != S_IFREG || f == 0 ) { // stdin is not seekable...
+	// non-seekable
+	setType( IO_Sequential );
+	length = INT_MAX;
+	ioIndex = 0;
+    } else {
+#if defined(TQT_LARGEFILE_SUPPORT) && !defined(TQT_ABI_QT4)
+	length = st.st_size > UINT_MAX ? UINT_MAX : (Offset)st.st_size;
+#else
+	length = (Offset)st.st_size;
+#endif
+	if ( length == 0 && isReadable() ) {
+	    // try if you can read from it (if you can, it's a sequential
+	    // tqdevice; e.g. a file in the /proc filesystem)
+	    int c = getch();
+	    if ( c != -1 ) {
+		ungetch(c);
+		setType( IO_Sequential );
+		length = INT_MAX;
+		ioIndex = 0;
+	    }
+	    resetqStatus();
+	}
+    }
+    return TRUE;
+}
+
+/*!
+  Returns the file size.
+  \sa at()
+*/
+
+TQIODevice::Offset TQFile::size() const
+{
+    struct stat st;
+    int ret = 0;
+    if ( isOpen() ) {
+	ret = ::fstat( fh ? fileno(fh) : fd, &st );
+    } else {
+	ret = ::stat( TQFile::encodeName(fn), &st );
+    }
+    if ( ret == -1 )
+	return 0;
+#if defined(TQT_LARGEFILE_SUPPORT) && !defined(TQT_ABI_QT4)
+    return (uint)st.st_size > UINT_MAX ? UINT_MAX : (Offset)st.st_size;
+#else
+    return st.st_size;
+#endif
+}
+
+
+/*!
+    \overload
+
+    Sets the file index to \a pos. Returns TRUE if successful;
+    otherwise returns FALSE.
+
+    Example:
+    \code
+    TQFile f( "data.bin" );
+    f.open( IO_ReadOnly );  // index set to 0
+    f.at( 100 );	    // set index to 100
+    f.at( f.at()+50 );	    // set index to 150
+    f.at( f.size()-80 );    // set index to 80 before EOF
+    f.close();
+    \endcode
+
+    Use \c at() without arguments to retrieve the file offset.
+
+    \warning The result is undefined if the file was open()'ed using
+    the \c IO_Append specifier.
+
+    \sa size(), open()
+*/
+
+bool TQFile::at( Offset pos )
+{
+    if ( !isOpen() ) {
+#if defined(TQT_CHECK_STATE)
+	qWarning( "TQFile::at: File is not open" );
+#endif
+	return FALSE;
+    }
+    if ( isSequentialAccess() )
+	return FALSE;
+    bool ok;
+    if ( isRaw() ) {
+	off_t l = ::lseek( fd, pos, SEEK_SET );
+	ok = ( l != -1 );
+	pos = (Offset)l;
+    } else {					// buffered file
+#if defined(TQT_LARGEFILE_SUPPORT)
+	ok = ( ::fseeko(fh, pos, SEEK_SET) == 0 );
+#else
+	ok = ( ::fseek(fh, pos, SEEK_SET) == 0 );
+#endif
+    }
+    if ( ok )
+#if defined(TQT_LARGEFILE_SUPPORT) && !defined(TQT_ABI_QT4)
+	ioIndex = pos > UINT_MAX ? UINT_MAX : (Offset)pos;
+#else
+	ioIndex = (Offset)pos;
+#endif
+#if defined(TQT_CHECK_RANGE)
+    else
+#if defined(TQT_ABI_QT4)
+	qWarning( "TQFile::at: Cannot set file position %lld", pos );
+#else
+	qWarning( "TQFile::at: Cannot set file position %lu", pos );
+#endif
+#endif
+    return ok;
+}
+
+/*!
+  \reimp
+
+  \warning We have experienced problems with some C libraries when a buffered
+  file is opened for both reading and writing. If a read operation takes place
+  immediately after a write operation, the read buffer tqcontains garbage data.
+  Worse, the same garbage is written to the file. Calling flush() before
+  readBlock() solved this problem.
+*/
+
+TQ_LONG TQFile::readBlock( char *p, TQ_ULONG len )
+{
+    if ( !len ) // nothing to do
+	return 0;
+
+#if defined(TQT_CHECK_NULL)
+    if ( !p )
+	qWarning( "TQFile::readBlock: Null pointer error" );
+#endif
+#if defined(TQT_CHECK_STATE)
+    if ( !isOpen() ) {
+	qWarning( "TQFile::readBlock: File not open" );
+	return -1;
+    }
+    if ( !isReadable() ) {
+	qWarning( "TQFile::readBlock: Read operation not permitted" );
+	return -1;
+    }
+#endif
+    TQ_ULONG nread = 0;					// number of bytes read
+    if ( !ungetchBuffer.isEmpty() ) {
+	// need to add these to the returned string.
+	uint l = ungetchBuffer.length();
+	while( nread < l ) {
+	    *p = ungetchBuffer.at( l - nread - 1 );
+	    p++;
+	    nread++;
+	}
+	ungetchBuffer.truncate( l - nread );
+    }
+
+    if ( nread < len ) {
+	if ( isRaw() ) {				// raw file
+	    nread += ::read( fd, p, len-nread );
+	    if ( len && nread <= 0 ) {
+		nread = 0;
+		setqStatus(IO_ReadError);
+		setErrorStringErrno( errno );
+	    }
+	} else {					// buffered file
+	    nread += fread( p, 1, len-nread, fh );
+	    if ( (uint)nread != len ) {
+		if ( ferror( fh ) || nread==0 ) {
+		    setqStatus(IO_ReadError);
+		    setErrorString( qt_fileerr_read );
+		}
+	    }
+	}
+    }
+    if ( !isSequentialAccess() )
+	ioIndex += nread;
+    return nread;
+}
+
+
+/*! \reimp
+
+  Writes \a len bytes from \a p to the file and returns the number of
+  bytes actually written.
+
+  Returns -1 if a serious error occurred.
+
+  \warning When working with buffered files, data may not be written
+  to the file at once. Call flush() to make sure the data is really
+  written.
+
+  \sa readBlock()
+*/
+
+TQ_LONG TQFile::writeBlock( const char *p, TQ_ULONG len )
+{
+    if ( !len ) // nothing to do
+	return 0;
+
+#if defined(TQT_CHECK_NULL)
+    if ( p == 0 && len != 0 )
+	qWarning( "TQFile::writeBlock: Null pointer error" );
+#endif
+#if defined(TQT_CHECK_STATE)
+    if ( !isOpen() ) {				// file not open
+	qWarning( "TQFile::writeBlock: File not open" );
+	return -1;
+    }
+    if ( !isWritable() ) {			// writing not permitted
+	qWarning( "TQFile::writeBlock: Write operation not permitted" );
+	return -1;
+    }
+#endif
+    TQ_ULONG nwritten;				// number of bytes written
+    if ( isRaw() )				// raw file
+	nwritten = ::write( fd, (void *)p, len );
+    else					// buffered file
+	nwritten = fwrite( p, 1, len, fh );
+    if ( nwritten != len ) {		// write error
+	if ( errno == ENOSPC )			// disk is full
+	    setqStatus( IO_ResourceError );
+	else
+	    setqStatus( IO_WriteError );
+	setErrorStringErrno( errno );
+	if ( !isSequentialAccess() ) {
+	    if ( isRaw() ) {			// recalc file position
+#if defined(TQT_LARGEFILE_SUPPORT) && !defined(TQT_ABI_QT4)
+		off_t tmp = ::lseek( fd, 0, SEEK_CUR );
+		ioIndex = tmp > UINT_MAX ? UINT_MAX : (Offset)tmp;
+#else
+		ioIndex = (Offset)::lseek( fd, 0, SEEK_CUR );
+#endif
+	    } else {
+#if defined(TQT_LARGEFILE_SUPPORT)
+#if !defined(TQT_ABI_QT4)
+		off_t tmp = (Offset)::fseeko( fh, 0, SEEK_CUR );
+		ioIndex = tmp > UINT_MAX ? UINT_MAX : (Offset)tmp;
+#else
+		ioIndex = (Offset)::fseeko( fh, 0, SEEK_CUR );
+#endif
+#else
+		ioIndex = (Offset)::fseek( fh, 0, SEEK_CUR );
+#endif
+	    }
+	}
+    } else {
+	if ( !isSequentialAccess() )
+	    ioIndex += nwritten;
+    }
+    if ( ioIndex > length )			// update file length
+	length = ioIndex;
+    return nwritten;
+}
+
+/*!
+  Returns the file handle of the file.
+
+  This is a small positive integer, suitable for use with C library
+  functions such as fdopen() and fcntl(). On systems that use file
+  descriptors for sockets (ie. Unix systems, but not Windows) the handle
+  can be used with TQSocketNotifier as well.
+
+  If the file is not open or there is an error, handle() returns -1.
+
+  \sa TQSocketNotifier
+*/
+
+int TQFile::handle() const
+{
+    if ( !isOpen() )
+	return -1;
+    else if ( fh )
+	return fileno( fh );
+    else
+	return fd;
+}
+
+/*!
+  Closes an open file.
+
+  The file is not closed if it was opened with an existing file handle.
+  If the existing file handle is a \c FILE*, the file is flushed.
+  If the existing file handle is an \c int file descriptor, nothing
+  is done to the file.
+
+  Some "write-behind" filesystems may report an unspecified error on
+  closing the file. These errors only indicate that something may
+  have gone wrong since the previous open(). In such a case status()
+  reports IO_UnspecifiedError after close(), otherwise IO_Ok.
+
+  \sa open(), flush()
+*/
+
+
+void TQFile::close()
+{
+    bool ok = FALSE;
+    if ( isOpen() ) {				// file is not open
+	if ( fh ) {				// buffered file
+	    if ( ext_f )
+		ok = fflush( fh ) != -1;	// flush instead of closing
+	    else
+		ok = fclose( fh ) != -1;
+	} else {				// raw file
+	    if ( ext_f )
+		ok = TRUE;			// cannot close
+	    else
+		ok = ::close( fd ) != -1;
+	}
+	init();					// restore internal state
+    }
+    if (!ok) {
+	setqStatus( IO_UnspecifiedError );
+	setErrorStringErrno( errno );
+    }
+}
+
+#endif // USE_QT4
\ No newline at end of file
diff --git a/tqtinterface/qt4/src/tools/tqfiledefs_p.h b/tqtinterface/qt4/src/tools/tqfiledefs_p.h
new file mode 100644
index 0000000..3ddd0bb
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqfiledefs_p.h
@@ -0,0 +1,67 @@
+/****************************************************************************
+**
+** Common macros and system include files for TQFile, TQFileInfo and TQDir.
+**
+** Created : 930812
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQFILEDEFS_P_H
+#define TQFILEDEFS_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the TQt API.  It exists for the convenience
+// of qfileinfo*.cpp.  This header file may change from version to version
+// without notice, or even be removed.
+//
+// We mean it.
+//
+//
+
+// Be sure to include qplatformdefs.h first!
+struct TQFileInfoCache
+{
+#if defined(TQ_WS_WIN)
+    TQT_STATBUF st;
+#else
+    struct stat st;
+#endif
+};
+
+
+#endif
diff --git a/tqtinterface/qt4/src/tools/tqfileinfo.cpp b/tqtinterface/qt4/src/tools/tqfileinfo.cpp
new file mode 100644
index 0000000..fbc1278
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqfileinfo.cpp
@@ -0,0 +1,710 @@
+/****************************************************************************
+**
+** Implementation of TQFileInfo class
+**
+** Created : 950628
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "tqplatformdefs.h"
+
+#include "tqfileinfo.h"
+#include "tqdatetime.h"
+#include "tqdir.h"
+#include "tqfiledefs_p.h"
+#include "tqdeepcopy.h"
+#if defined(TQT_LARGEFILE_SUPPORT) && !defined(TQT_ABI_QT4)
+#include <limits.h>
+#endif
+
+
+extern bool qt_file_access( const TQString& fn, int t );
+
+/*!
+    \class TQFileInfo
+    \reentrant
+    \brief The TQFileInfo class provides system-independent file information.
+
+    \ingroup io
+
+    TQFileInfo provides information about a file's name and position
+    (path) in the file system, its access rights and whether it is a
+    directory or symbolic link, etc. The file's size and last
+    modified/read times are also available.
+
+    A TQFileInfo can point to a file with either a relative or an
+    absolute file path. Absolute file paths begin with the directory
+    separator "/" (or with a drive specification on Windows). Relative
+    file names begin with a directory name or a file name and specify
+    a path relative to the current working directory. An example of an
+    absolute path is the string "/tmp/quartz". A relative path might
+    look like "src/fatlib". You can use the function isRelative() to
+    check whether a TQFileInfo is using a relative or an absolute file
+    path. You can call the function convertToAbs() to convert a
+    relative TQFileInfo's path to an absolute path.
+
+    The file that the TQFileInfo works on is set in the constructor or
+    later with setFile(). Use exists() to see if the file exists and
+    size() to get its size.
+
+    To speed up performance, TQFileInfo caches information about the
+    file. Because files can be changed by other users or programs, or
+    even by other parts of the same program, there is a function that
+    refreshes the file information: refresh(). If you want to switch
+    off a TQFileInfo's caching and force it to access the file system
+    every time you request information from it call setCaching(FALSE).
+
+    The file's type is obtained with isFile(), isDir() and
+    isSymLink(). The readLink() function provides the name of the file
+    the symlink points to.
+
+    Elements of the file's name can be extracted with dirPath() and
+    fileName(). The fileName()'s parts can be extracted with
+    baseName() and extension().
+
+    The file's dates are returned by created(), lastModified() and
+    lastRead(). Information about the file's access permissions is
+    obtained with isReadable(), isWritable() and isExecutable(). The
+    file's ownership is available from owner(), ownerId(), group() and
+    groupId(). You can examine a file's permissions and ownership in a
+    single statement using the permission() function.
+
+    If you need to read and traverse directories, see the TQDir class.
+*/
+
+/*!
+    \enum TQFileInfo::PermissionSpec
+
+    This enum is used by the permission() function to report the
+    permissions and ownership of a file. The values may be OR-ed
+    together to test multiple permissions and ownership values.
+
+    \value ReadOwner The file is readable by the owner of the file.
+    \value WriteOwner The file is writable by the owner of the file.
+    \value ExeOwner The file is executable by the owner of the file.
+    \value ReadUser The file is readable by the user.
+    \value WriteUser The file is writable by the user.
+    \value ExeUser The file is executable by the user.
+    \value ReadGroup The file is readable by the group.
+    \value WriteGroup The file is writable by the group.
+    \value ExeGroup The file is executable by the group.
+    \value ReadOther The file is readable by anyone.
+    \value WriteOther The file is writable by anyone.
+    \value ExeOther The file is executable by anyone.
+
+    \warning The semantics of \c ReadUser, \c WriteUser and \c ExeUser are
+    unfortunately not platform independent: on Unix, the rights of the owner of
+    the file are returned and on Windows the rights of the current user are
+    returned. This behavior might change in a future TQt version. If you want to
+    tqfind the rights of the owner of the file, you should use the flags \c
+    ReadOwner, \c WriteOwner and \c ExeOwner. If you want to tqfind out the
+    rights of the current user, you should use isReadable(), isWritable() and
+    isExecutable().
+*/
+
+
+/*!
+    Constructs a new empty TQFileInfo.
+*/
+
+TQFileInfo::TQFileInfo()
+{
+    fic	  = 0;
+    cache = TRUE;
+#if defined(TQ_OS_UNIX)
+    symLink = FALSE;
+#endif
+}
+
+/*!
+    Constructs a new TQFileInfo that gives information about the given
+    file. The \a file can also include an absolute or relative path.
+
+    \warning Some functions might behave in a counter-intuitive way
+    if \a file has a trailing directory separator.
+
+    \sa setFile(), isRelative(), TQDir::setCurrent(), TQDir::isRelativePath()
+*/
+
+TQFileInfo::TQFileInfo( const QString &file )
+{
+    fn	  = file;
+    slashify( fn );
+    fic	  = 0;
+    cache = TRUE;
+#if defined(TQ_OS_UNIX)
+    symLink = FALSE;
+#endif
+}
+
+/*!
+    Constructs a new TQFileInfo that gives information about file \a
+    file.
+
+    If the \a file has a relative path, the TQFileInfo will also have a
+    relative path.
+
+    \sa isRelative()
+*/
+
+TQFileInfo::TQFileInfo( const TQFile &file )
+{
+    fn	  = file.name();
+    slashify( fn );
+    fic	  = 0;
+    cache = TRUE;
+#if defined(TQ_OS_UNIX)
+    symLink = FALSE;
+#endif
+}
+
+/*!
+    Constructs a new TQFileInfo that gives information about the file
+    called \a fileName in the directory \a d.
+
+    If \a d has a relative path, the TQFileInfo will also have a
+    relative path.
+
+    \sa isRelative()
+*/
+#ifndef TQT_NO_DIR
+TQFileInfo::TQFileInfo( const TQDir &d, const TQString &fileName )
+{
+    fn	  = d.filePath( fileName );
+    slashify( fn );
+    fic	  = 0;
+    cache = TRUE;
+#if defined(TQ_OS_UNIX)
+    symLink = FALSE;
+#endif
+}
+#endif
+/*!
+    Constructs a new TQFileInfo that is a copy of \a fi.
+*/
+
+TQFileInfo::TQFileInfo( const TQFileInfo &fi )
+{
+    fn = fi.fn;
+    if ( fi.fic ) {
+	fic = new TQFileInfoCache;
+	*fic = *fi.fic;
+    } else {
+	fic = 0;
+    }
+    cache = fi.cache;
+#if defined(TQ_OS_UNIX)
+    symLink = fi.symLink;
+#endif
+}
+
+/*!
+    Destroys the TQFileInfo and frees its resources.
+*/
+
+TQFileInfo::~TQFileInfo()
+{
+    delete fic;
+}
+
+
+/*!
+    Makes a copy of \a fi and assigns it to this TQFileInfo.
+*/
+
+TQFileInfo &TQFileInfo::operator=( const TQFileInfo &fi )
+{
+    fn = fi.fn;
+    if ( !fi.fic ) {
+	delete fic;
+	fic = 0;
+    } else {
+	if ( !fic ) {
+	    fic = new TQFileInfoCache;
+	    TQ_CHECK_PTR( fic );
+	}
+	*fic = *fi.fic;
+    }
+    cache = fi.cache;
+#if defined(TQ_OS_UNIX)
+    symLink = fi.symLink;
+#endif
+    return *this;
+}
+
+
+/*!
+    Sets the file that the TQFileInfo provides information about to \a
+    file.
+
+    The \a file can also include an absolute or relative file path.
+    Absolute paths begin with the directory separator (e.g. "/" under
+    Unix) or a drive specification (under Windows). Relative file
+    names begin with a directory name or a file name and specify a
+    path relative to the current directory.
+
+    Example:
+    \code
+    TQString absolute = "/local/bin";
+    TQString relative = "local/bin";
+    TQFileInfo absFile( absolute );
+    TQFileInfo relFile( relative );
+
+    TQDir::setCurrent( TQDir::rootDirPath() );
+    // absFile and relFile now point to the same file
+
+    TQDir::setCurrent( "/tmp" );
+    // absFile now points to "/local/bin",
+    // while relFile points to "/tmp/local/bin"
+    \endcode
+
+    \sa isRelative(), TQDir::setCurrent(), TQDir::isRelativePath()
+*/
+
+void TQFileInfo::setFile( const TQString &file )
+{
+    fn = file;
+    slashify( fn );
+    delete fic;
+    fic = 0;
+}
+
+/*!
+    \overload
+
+    Sets the file that the TQFileInfo provides information about to \a
+    file.
+
+    If \a file includes a relative path, the TQFileInfo will also have
+    a relative path.
+
+    \sa isRelative()
+*/
+
+void TQFileInfo::setFile( const TQFile &file )
+{
+    fn	= file.name();
+    slashify( fn );
+    delete fic;
+    fic = 0;
+}
+
+/*!
+    \overload
+
+    Sets the file that the TQFileInfo provides information about to \a
+    fileName in directory \a d.
+
+    If \a fileName includes a relative path, the TQFileInfo will also
+    have a relative path.
+
+    \sa isRelative()
+*/
+#ifndef TQT_NO_DIR
+void TQFileInfo::setFile( const TQDir &d, const TQString &fileName )
+{
+    fn	= d.filePath( fileName );
+    slashify( fn );
+    delete fic;
+    fic = 0;
+}
+#endif
+
+/*!
+    Returns TRUE if the file exists; otherwise returns FALSE.
+*/
+
+bool TQFileInfo::exists() const
+{
+    return qt_file_access( fn, F_OK );
+}
+
+/*!
+    Refreshes the information about the file, i.e. reads in information
+    from the file system the next time a cached property is fetched.
+
+    \sa setCaching()
+*/
+
+void TQFileInfo::refresh() const
+{
+    TQFileInfo *that = (TQFileInfo*)this;		// Mutable function
+    delete that->fic;
+    that->fic = 0;
+}
+
+/*!
+    \fn bool TQFileInfo::caching() const
+
+    Returns TRUE if caching is enabled; otherwise returns FALSE.
+
+    \sa setCaching(), refresh()
+*/
+
+/*!
+    If \a enable is TRUE, enables caching of file information. If \a
+    enable is FALSE caching is disabled.
+
+    When caching is enabled, TQFileInfo reads the file information from
+    the file system the first time it's needed, but generally not
+    later.
+
+    Caching is enabled by default.
+
+    \sa refresh(), caching()
+*/
+
+void TQFileInfo::setCaching( bool enable )
+{
+    if ( cache == enable )
+	return;
+    cache = enable;
+    if ( cache ) {
+	delete fic;
+	fic = 0;
+    }
+}
+
+
+/*!
+    Returns the file name, including the path (which may be absolute
+    or relative).
+
+    \sa isRelative(), absFilePath()
+*/
+
+TQString TQFileInfo::filePath() const
+{
+    return fn;
+}
+
+/*!
+    Returns the base name of the file.
+
+    If \a complete is FALSE (the default) the base name consists of
+    all characters in the file name up to (but not including) the \e
+    first '.' character.
+
+    If \a complete is TRUE the base name consists of all characters in
+    the file up to (but not including) the \e last '.' character.
+
+    The path is not included in either case.
+
+    Example:
+    \code
+	TQFileInfo fi( "/tmp/archive.tar.gz" );
+	TQString base = fi.baseName();  // base = "archive"
+	base = fi.baseName( TRUE );    // base = "archive.tar"
+    \endcode
+
+    \sa fileName(), extension()
+*/
+
+TQString TQFileInfo::baseName( bool complete ) const
+{
+    TQString tmp = fileName();
+    int pos = complete ? tmp.tqfindRev( '.' ) : tmp.tqfind( '.' );
+    if ( pos == -1 )
+	return tmp;
+    else
+	return tmp.left( pos );
+}
+
+/*!
+    Returns the file's extension name.
+
+    If \a complete is TRUE (the default), extension() returns the
+    string of all characters in the file name after (but not
+    including) the first '.'  character.
+
+    If \a complete is FALSE, extension() returns the string of all
+    characters in the file name after (but not including) the last '.'
+    character.
+
+    Example:
+    \code
+	TQFileInfo fi( "/tmp/archive.tar.gz" );
+	TQString ext = fi.extension();  // ext = "tar.gz"
+	ext = fi.extension( FALSE );   // ext = "gz"
+    \endcode
+
+    \sa fileName(), baseName()
+*/
+
+TQString TQFileInfo::extension( bool complete ) const
+{
+    TQString s = fileName();
+    int pos = complete ? s.tqfind( '.' ) : s.tqfindRev( '.' );
+    if ( pos < 0 )
+	return TQString::tqfromLatin1( "" );
+    else
+	return s.right( s.length() - pos - 1 );
+}
+
+/*!
+    Returns the file's path as a TQDir object.
+
+    If the TQFileInfo is relative and \a absPath is FALSE, the TQDir
+    will be relative; otherwise it will be absolute.
+
+    \sa dirPath(), filePath(), fileName(), isRelative()
+*/
+#ifndef TQT_NO_DIR
+TQDir TQFileInfo::dir( bool absPath ) const
+{
+    return TQDir( dirPath(absPath) );
+}
+#endif
+
+
+/*!
+    Returns TRUE if the file is readable; otherwise returns FALSE.
+
+    \sa isWritable(), isExecutable(), permission()
+*/
+
+bool TQFileInfo::isReadable() const
+{
+#ifdef TQ_WS_WIN
+    return qt_file_access( fn, R_OK ) && permission( ReadUser );
+#else
+    return qt_file_access( fn, R_OK );
+#endif
+}
+
+/*!
+    Returns TRUE if the file is writable; otherwise returns FALSE.
+
+    \sa isReadable(), isExecutable(), permission()
+*/
+
+bool TQFileInfo::isWritable() const
+{
+#ifdef TQ_WS_WIN
+    return qt_file_access( fn, W_OK ) && permission( WriteUser );
+#else
+    return qt_file_access( fn, W_OK );
+#endif
+}
+
+/*!
+    Returns TRUE if the file is executable; otherwise returns FALSE.
+
+    \sa isReadable(), isWritable(), permission()
+*/
+
+bool TQFileInfo::isExecutable() const
+{
+#ifdef TQ_WS_WIN
+#if defined(_MSC_VER) && _MSC_VER >= 1400
+    return permission( ExeUser );
+#else
+    return qt_file_access( fn, X_OK ) && permission( ExeUser );
+#endif //_MSC_VER >= 1400
+#else
+    return qt_file_access( fn, X_OK );
+#endif
+}
+
+#ifndef TQ_WS_WIN
+bool TQFileInfo::isHidden() const
+{
+    return fileName()[ 0 ] == TQChar( '.' );
+}
+#endif
+
+/*!
+    Returns TRUE if the file path name is relative. Returns FALSE if
+    the path is absolute (e.g. under Unix a path is absolute if it
+    begins with a "/").
+*/
+#ifndef TQT_NO_DIR
+bool TQFileInfo::isRelative() const
+{
+    return TQDir::isRelativePath( fn );
+}
+
+/*!
+    Converts the file's path to an absolute path.
+
+    If it is already absolute, nothing is done.
+
+    \sa filePath(), isRelative()
+*/
+
+bool TQFileInfo::convertToAbs()
+{
+    if ( isRelative() )
+	fn = absFilePath();
+    return TQDir::isRelativePath( fn );
+}
+#endif
+
+/*!
+    Returns the file size in bytes, or 0 if the file does not exist or
+    if the size is 0 or if the size cannot be fetched.
+*/
+#if defined(TQT_ABI_QT4)
+TQIODevice::Offset TQFileInfo::size() const
+#else
+uint TQFileInfo::size() const
+#endif
+{
+    if ( !fic || !cache )
+	doStat();
+    if ( fic )
+#if defined(TQT_ABI_QT4)
+	return (TQIODevice::Offset)fic->st.st_size;
+#elif defined(TQT_LARGEFILE_SUPPORT)
+	return (uint)fic->st.st_size > UINT_MAX ? UINT_MAX : (uint)fic->st.st_size;
+#else
+	return (uint)fic->st.st_size;
+#endif
+    else
+	return 0;
+}
+
+/*!
+    Returns the date and time when the file was created.
+
+    On platforms where this information is not available, returns the
+    same as lastModified().
+
+    \sa created() lastModified() lastRead()
+*/
+
+TQDateTime TQFileInfo::created() const
+{
+    TQDateTime dt;
+    if ( !fic || !cache )
+	doStat();
+    if ( fic && fic->st.st_ctime != 0 ) {
+	dt.setTime_t( fic->st.st_ctime );
+	return dt;
+    } else {
+	return lastModified();
+    }
+}
+
+/*!
+    Returns the date and time when the file was last modified.
+
+    \sa created() lastModified() lastRead()
+*/
+
+TQDateTime TQFileInfo::lastModified() const
+{
+    TQDateTime dt;
+    if ( !fic || !cache )
+	doStat();
+    if ( fic )
+	dt.setTime_t( fic->st.st_mtime );
+    return dt;
+}
+
+/*!
+    Returns the date and time when the file was last read (accessed).
+
+    On platforms where this information is not available, returns the
+    same as lastModified().
+
+    \sa created() lastModified() lastRead()
+*/
+
+TQDateTime TQFileInfo::lastRead() const
+{
+    TQDateTime dt;
+    if ( !fic || !cache )
+	doStat();
+    if ( fic && fic->st.st_atime != 0 ) {
+	dt.setTime_t( fic->st.st_atime );
+	return dt;
+    } else {
+	return lastModified();
+    }
+}
+
+#ifndef TQT_NO_DIR
+
+/*!
+    Returns the absolute path including the file name.
+
+    The absolute path name consists of the full path and the file
+    name. On Unix this will always begin with the root, '/',
+    directory. On Windows this will always begin 'D:/' where D is a
+    drive letter, except for network shares that are not mapped to a
+    drive letter, in which case the path will begin '//sharename/'.
+
+    This function returns the same as filePath(), unless isRelative()
+    is TRUE.
+
+    If the TQFileInfo is empty it returns TQDir::currentDirPath().
+
+    This function can be time consuming under Unix (in the order of
+    milliseconds).
+
+    \sa isRelative(), filePath()
+*/
+TQString TQFileInfo::absFilePath() const
+{
+    TQString tmp;
+    if ( TQDir::isRelativePath(fn)
+#if defined(TQ_OS_WIN32)
+	 && fn[1] != ':'
+#endif
+	 ) {
+	tmp = TQDir::currentDirPath();
+	tmp += '/';
+    }
+    tmp += fn;
+    makeAbs( tmp );
+    return TQDir::cleanDirPath( tmp );
+}
+
+/*! \internal
+    Detaches all internal data.
+*/
+void TQFileInfo::detach()
+{
+    fn = TQDeepCopy<TQString>( fn );
+    if ( fic ) {
+	TQFileInfoCache *cur = fic;
+	fic = new TQFileInfoCache;
+	*fic = *cur;
+	delete cur;
+    }
+}
+
+#endif
diff --git a/tqtinterface/qt4/src/tools/tqfileinfo.h b/tqtinterface/qt4/src/tools/tqfileinfo.h
new file mode 100644
index 0000000..b87b2ad
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqfileinfo.h
@@ -0,0 +1,157 @@
+/****************************************************************************
+**
+** Definition of TQFileInfo class
+**
+** Created : 950628
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQFILEINFO_H
+#define TQFILEINFO_H
+
+#ifndef TQT_H
+#include "tqfile.h"
+#include "tqdatetime.h"
+#endif // TQT_H
+
+
+class TQDir;
+struct TQFileInfoCache;
+template <class T> class TQDeepCopy;
+
+
+class TQ_EXPORT TQFileInfo
+{
+public:
+    enum PermissionSpec {
+	ReadOwner = 04000, WriteOwner = 02000, ExeOwner = 01000,
+	ReadUser  = 00400, WriteUser  = 00200, ExeUser  = 00100,
+	ReadGroup = 00040, WriteGroup = 00020, ExeGroup = 00010,
+	ReadOther = 00004, WriteOther = 00002, ExeOther = 00001 };
+
+    TQFileInfo();
+    TQFileInfo( const QString &file );
+    TQFileInfo( const TQFile & );
+#ifndef TQT_NO_DIR
+    TQFileInfo( const TQDir &, const TQString &fileName );
+#endif
+    TQFileInfo( const TQFileInfo & );
+   ~TQFileInfo();
+
+    TQFileInfo  &operator=( const TQFileInfo & );
+
+    void	setFile( const TQString &file );
+    void	setFile( const TQFile & );
+#ifndef TQT_NO_DIR
+    void	setFile( const TQDir &, const TQString &fileName );
+#endif
+    bool	exists()	const;
+    void	refresh()	const;
+    bool	caching()	const;
+    void	setCaching( bool );
+
+    TQString	filePath()	const;
+    TQString	fileName()	const;
+#ifndef TQT_NO_DIR //###
+    TQString	absFilePath()	const;
+#endif
+    TQString	baseName( bool complete = FALSE ) const;
+    TQString	extension( bool complete = TRUE ) const;
+
+#ifndef TQT_NO_DIR //###
+    TQString	dirPath( bool absPath = FALSE ) const;
+#endif
+#ifndef TQT_NO_DIR
+    TQDir	dir( bool absPath = FALSE )	const;
+#endif
+    bool	isReadable()	const;
+    bool	isWritable()	const;
+    bool	isExecutable()	const;
+    bool 	isHidden()      const;
+
+#ifndef TQT_NO_DIR //###
+    bool	isRelative()	const;
+    bool	convertToAbs();
+#endif
+
+    bool	isFile()	const;
+    bool	isDir()		const;
+    bool	isSymLink()	const;
+
+    TQString	readLink()	const;
+
+    TQString	owner()		const;
+    uint	ownerId()	const;
+    TQString	group()		const;
+    uint	groupId()	const;
+
+    bool	permission( int permissionSpec ) const;
+
+#if (TQT_VERSION-0 >= 0x040000)
+#error "TQFileInfo::size() should return TQIODevice::Offset instead of uint"
+#elif defined(TQT_ABI_QT4)
+    TQIODevice::Offset size()	const;
+#else
+    uint	size()		const;
+#endif
+
+    TQDateTime	created()	const;
+    TQDateTime	lastModified()	const;
+    TQDateTime	lastRead()	const;
+
+private:
+    void	doStat() const;
+    static void slashify( TQString & );
+    static void makeAbs( TQString & );
+
+    TQString	fn;
+    TQFileInfoCache *fic;
+    bool	cache;
+#if defined(TQ_OS_UNIX)
+    bool        symLink;
+#endif
+
+    void detach();
+    friend class TQDeepCopy< TQFileInfo >;
+};
+
+
+inline bool TQFileInfo::caching() const
+{
+    return cache;
+}
+
+
+#endif // TQFILEINFO_H
diff --git a/tqtinterface/qt4/src/tools/tqfileinfo_unix.cpp b/tqtinterface/qt4/src/tools/tqfileinfo_unix.cpp
new file mode 100644
index 0000000..921b9f9
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqfileinfo_unix.cpp
@@ -0,0 +1,370 @@
+/****************************************************************************
+**
+** Implementation of TQFileInfo class
+**
+** Created : 950628
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "tqplatformdefs.h"
+#include "tqfileinfo.h"
+#include "tqfiledefs_p.h"
+#include "tqdatetime.h"
+#include "tqdir.h"
+
+#include <limits.h>
+#if !defined(TQWS) && defined(TQ_OS_MAC)
+# include <tqt_mac.h>
+#endif
+
+void TQFileInfo::slashify( TQString& )
+{
+    return;
+}
+
+
+void TQFileInfo::makeAbs( TQString & )
+{
+    return;
+}
+
+/*!
+    Returns TRUE if this object points to a file. Returns FALSE if the
+    object points to something which isn't a file, e.g. a directory or
+    a symlink.
+
+    \sa isDir(), isSymLink()
+*/
+bool TQFileInfo::isFile() const
+{
+    if ( !fic || !cache )
+	doStat();
+    return fic ? (fic->st.st_mode & S_IFMT) == S_IFREG : FALSE;
+}
+
+/*!
+    Returns TRUE if this object points to a directory or to a symbolic
+    link to a directory; otherwise returns FALSE.
+
+    \sa isFile(), isSymLink()
+*/
+bool TQFileInfo::isDir() const
+{
+    if ( !fic || !cache )
+	doStat();
+    return fic ? (fic->st.st_mode & S_IFMT) == S_IFDIR : FALSE;
+}
+
+/*!
+    Returns TRUE if this object points to a symbolic link (or to a
+    shortcut on Windows, or an alias on Mac OS X); otherwise returns
+    FALSE.
+
+    \sa isFile(), isDir(), readLink()
+*/
+
+bool TQFileInfo::isSymLink() const
+{
+    if ( !fic || !cache )
+	doStat();
+    if(symLink)
+        return TRUE;
+#if !defined(TQWS) && defined(TQ_OS_MAC)
+    {
+        FSRef fref;
+        if(FSPathMakeRef((const UInt8 *)TQFile::encodeName(fn).data(), &fref, NULL) == noErr) {
+            Boolean isAlias, isFolder;
+            if(FSIsAliasFile(&fref, &isAlias, &isFolder) == noErr)
+                return isAlias;
+        }
+    }
+#endif
+    return FALSE;
+}
+
+/*!
+    Returns the name a symlink (or shortcut on Windows) points to, or
+    a TQString::null if the object isn't a symbolic link.
+
+    This name may not represent an existing file; it is only a string.
+    TQFileInfo::exists() returns TRUE if the symlink points to an
+    existing file.
+
+    \sa exists(), isSymLink(), isDir(), isFile()
+*/
+
+TQString TQFileInfo::readLink() const
+{
+#if defined(TQ_OS_UNIX) && !defined(TQ_OS_OS2EMX)
+    char s[PATH_MAX+1];
+    if ( !isSymLink() )
+	return TQString();
+    int len = readlink( TQFile::encodeName(fn).data(), s, PATH_MAX );
+    if ( len >= 0 ) {
+	s[len] = '\0';
+	return TQFile::decodeName(s);
+    }
+#endif
+#if !defined(TQWS) && defined(TQ_OS_MAC)
+    {
+        FSRef fref;
+        if(FSPathMakeRef((const UInt8 *)TQFile::encodeName(fn).data(), &fref, NULL) == noErr) {
+            Boolean isAlias, isFolder;
+            if(FSResolveAliasFile(&fref, TRUE, &isFolder, &isAlias) == noErr && isAlias) {
+                AliasHandle alias;
+                if(FSNewAlias(0, &fref, &alias) == noErr && alias) {
+                    CFStringRef cfstr;
+                    if(FSCopyAliasInfo(alias, 0, 0, &cfstr, 0, 0) == noErr) {
+                        TQString cfstring2qstring(CFStringRef str); //qglobal.cpp
+                        return cfstring2qstring(cfstr);
+                    }
+                }
+            }
+        }
+    }
+#endif
+    return TQString();
+}
+
+static const uint nobodyID = (uint) -2;
+
+/*!
+    Returns the owner of the file. On systems where files
+    do not have owners, or if an error occurs, TQString::null is
+    returned.
+
+    This function can be time consuming under Unix (in the order of
+    milliseconds).
+
+    \sa ownerId(), group(), groupId()
+*/
+
+TQString TQFileInfo::owner() const
+{
+    passwd *pw = getpwuid( ownerId() );
+    if ( pw )
+	return TQFile::decodeName( pw->pw_name );
+    return TQString::null;
+}
+
+/*!
+    Returns the id of the owner of the file.
+
+    On Windows and on systems where files do not have owners this
+    function returns ((uint) -2).
+
+    \sa owner(), group(), groupId()
+*/
+
+uint TQFileInfo::ownerId() const
+{
+    if ( !fic || !cache )
+	doStat();
+    if ( fic )
+	return fic->st.st_uid;
+    return nobodyID;
+}
+
+/*!
+    Returns the group of the file. On Windows, on systems where files
+    do not have groups, or if an error occurs, TQString::null is
+    returned.
+
+    This function can be time consuming under Unix (in the order of
+    milliseconds).
+
+    \sa groupId(), owner(), ownerId()
+*/
+
+TQString TQFileInfo::group() const
+{
+    struct group *gr = getgrgid( groupId() );
+    if ( gr )
+	return TQFile::decodeName( gr->gr_name );
+    return TQString::null;
+}
+
+/*!
+    Returns the id of the group the file belongs to.
+
+    On Windows and on systems where files do not have groups this
+    function always returns (uint) -2.
+
+    \sa group(), owner(), ownerId()
+*/
+
+uint TQFileInfo::groupId() const
+{
+    if ( !fic || !cache )
+	doStat();
+    if ( fic )
+	return fic->st.st_gid;
+    return nobodyID;
+}
+
+
+/*!
+    Tests for file permissions. The \a permissionSpec argument can be
+    several flags of type \c PermissionSpec OR-ed together to check
+    for permission combinations.
+
+    On systems where files do not have permissions this function
+    always returns TRUE.
+
+    Example:
+    \code
+	TQFileInfo fi( "/tmp/archive.tar.gz" );
+	if ( fi.permission( TQFileInfo::WriteUser | TQFileInfo::ReadGroup ) )
+	    qWarning( "I can change the file; my group can read the file" );
+	if ( fi.permission( TQFileInfo::WriteGroup | TQFileInfo::WriteOther ) )
+	    qWarning( "The group or others can change the file" );
+    \endcode
+
+    \sa isReadable(), isWritable(), isExecutable()
+*/
+
+bool TQFileInfo::permission( int permissionSpec ) const
+{
+    if ( !fic || !cache )
+	doStat();
+    if ( fic ) {
+	uint tqmask = 0;
+	if ( permissionSpec & ReadOwner )
+	    tqmask |= S_IRUSR;
+	if ( permissionSpec & WriteOwner )
+	    tqmask |= S_IWUSR;
+	if ( permissionSpec & ExeOwner )
+	    tqmask |= S_IXUSR;
+	if ( permissionSpec & ReadUser )
+	    tqmask |= S_IRUSR;
+	if ( permissionSpec & WriteUser )
+	    tqmask |= S_IWUSR;
+	if ( permissionSpec & ExeUser )
+	    tqmask |= S_IXUSR;
+	if ( permissionSpec & ReadGroup )
+	    tqmask |= S_IRGRP;
+	if ( permissionSpec & WriteGroup )
+	    tqmask |= S_IWGRP;
+	if ( permissionSpec & ExeGroup )
+	    tqmask |= S_IXGRP;
+	if ( permissionSpec & ReadOther )
+	    tqmask |= S_IROTH;
+	if ( permissionSpec & WriteOther )
+	    tqmask |= S_IWOTH;
+	if ( permissionSpec & ExeOther )
+	    tqmask |= S_IXOTH;
+	if ( tqmask ) {
+	   return (fic->st.st_mode & tqmask) == tqmask;
+	} else {
+#if defined(TQT_CHECK_NULL)
+	   qWarning( "TQFileInfo::permission: permissionSpec is 0" );
+#endif
+	   return TRUE;
+	}
+    } else {
+	return FALSE;
+    }
+}
+
+void TQFileInfo::doStat() const
+{
+    TQFileInfo *that = ((TQFileInfo*)this);	// mutable function
+    if ( !that->fic )
+	that->fic = new TQFileInfoCache;
+    that->symLink = FALSE;
+    struct stat *b = &that->fic->st;
+#if defined(TQ_OS_UNIX) && defined(S_IFLNK)
+    if ( ::lstat( TQFile::encodeName(fn), b ) == 0 ) {
+	if ( S_ISLNK( b->st_mode ) )
+	    that->symLink = TRUE;
+	else
+	    return;
+    }
+#endif
+
+    int r = ::stat( TQFile::encodeName(fn), b );
+    if ( r != 0 && !that->symLink ) {
+	delete that->fic;
+	that->fic = 0;
+    }
+}
+
+/*!
+    Returns the file's path.
+
+    If \a absPath is TRUE an absolute path is returned.
+
+    \sa dir(), filePath(), fileName(), isRelative()
+*/
+#ifndef TQT_NO_DIR
+TQString TQFileInfo::dirPath( bool absPath ) const
+{
+    TQString s;
+    if ( absPath )
+	s = absFilePath();
+    else
+	s = fn;
+    int pos = s.tqfindRev( '/' );
+    if ( pos == -1 ) {
+	return TQString::tqfromLatin1( "." );
+    } else {
+	if ( pos == 0 )
+	    return TQString::tqfromLatin1( "/" );
+	return s.left( pos );
+    }
+}
+#endif
+
+/*!
+    Returns the name of the file, excluding the path.
+
+    Example:
+    \code
+	TQFileInfo fi( "/tmp/archive.tar.gz" );
+	TQString name = fi.fileName();		// name = "archive.tar.gz"
+    \endcode
+
+    \sa isRelative(), filePath(), baseName(), extension()
+*/
+
+TQString TQFileInfo::fileName() const
+{
+    int p = fn.tqfindRev( '/' );
+    if ( p == -1 ) {
+	return fn;
+    } else {
+	return fn.mid( p + 1 );
+    }
+}
diff --git a/tqtinterface/qt4/src/tools/tqgarray.cpp b/tqtinterface/qt4/src/tools/tqgarray.cpp
new file mode 100644
index 0000000..f0e89f9
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqgarray.cpp
@@ -0,0 +1,830 @@
+/****************************************************************************
+**
+** Implementation of TQGArray class
+**
+** Created : 930906
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "tqglobal.h"
+#if defined(TQ_CC_BOR)
+    // needed for qsort() because of a std namespace problem on Borland
+#   include "tqplatformdefs.h"
+#elif defined(TQ_WS_WIN)
+    // needed for bsearch on some platforms
+#   include "tqt_windows.h"
+#endif
+
+#define	 TQGARRAY_CPP
+#include "tqgarray.h"
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef TQT_THREAD_SUPPORT
+#  include <private/tqmutexpool_p.h>
+#endif // TQT_THREAD_SUPPORT
+
+/*
+  If USE_MALLOC isn't defined, we use new[] and delete[] to allocate
+  memory. The documentation for TQMemArray<T>::assign() explicitly
+  mentions that the array is freed using free(), so don't mess around
+  with USE_MALLOC unless you know what you're doing.
+*/
+#define USE_MALLOC
+
+#undef NEW
+#undef DELETE
+
+#if defined(USE_MALLOC)
+#define NEW(type,size)	((type*)malloc(size*sizeof(type)))
+#define DELETE(array)	(free((char*)array))
+#else
+#define NEW(type,size)	(new type[size])
+#define DELETE(array)	(delete[] array)
+#define DONT_USE_REALLOC			// comment to use realloc()
+#endif
+
+/*!
+  \class TQShared tqshared.h
+  \reentrant
+  \ingroup shared
+  \brief The TQShared class is used internally for implementing shared classes.
+
+  \internal
+
+  It only tqcontains a reference count and member functions to increment and
+  decrement it.
+
+  Shared classes normally have internal classes that inherit TQShared and
+  add the shared data.
+
+  \sa \link shclass.html Shared Classes\endlink
+*/
+
+/*!
+  \class TQGArray tqgarray.h
+  \reentrant
+  \ingroup shared
+  \ingroup collection
+  \brief The TQGArray class is an internal class for implementing the TQMemArray class.
+
+  \internal
+
+  TQGArray is a strictly internal class that acts as base class for the
+  TQMemArray template array.
+
+  It tqcontains an array of bytes and has no notion of an array element.
+*/
+
+
+/*!
+  Constructs a null array.
+*/
+
+TQGArray::TQGArray()
+{
+    shd = newData();
+    TQ_CHECK_PTR( shd );
+}
+
+/*!
+  Dummy constructor; does not allocate any data.
+
+  This constructor does not initialize any array data so subclasses
+  must do it. The intention is to make the code more efficient.
+*/
+
+TQGArray::TQGArray( int, int )
+{
+}
+
+/*!
+  Constructs an array with room for \a size bytes.
+*/
+
+TQGArray::TQGArray( int size )
+{
+    if ( size < 0 ) {
+#if defined(TQT_CHECK_RANGE)
+	qWarning( "TQGArray: Cannot allocate array with negative length" );
+#endif
+	size = 0;
+    }
+    shd = newData();
+    TQ_CHECK_PTR( shd );
+    if ( size == 0 )				// zero length
+	return;
+    shd->data = NEW(char,size);
+    TQ_CHECK_PTR( shd->data );
+    shd->len =
+#ifdef TQT_TQGARRAY_SPEED_OPTIM
+	shd->maxl =
+#endif
+	size;
+}
+
+/*!
+  Constructs a shallow copy of \a a.
+*/
+
+TQGArray::TQGArray( const TQGArray &a )
+{
+    shd = a.shd;
+    shd->ref();
+}
+
+/*!
+  Dereferences the array data and deletes it if this was the last
+  reference.
+*/
+
+TQGArray::~TQGArray()
+{
+    if ( shd && shd->deref() ) {		// delete when last reference
+	if ( shd->data )			// is lost
+	    DELETE(shd->data);
+	deleteData( shd );
+	shd = 0;
+    }
+}
+
+
+/*!
+  \fn TQGArray &TQGArray::operator=( const TQGArray &a )
+
+  Assigns a shallow copy of \a a to this array and returns a reference to
+  this array.  Equivalent to assign().
+*/
+
+/*!
+  \fn void TQGArray::detach()
+
+  Detaches this array from shared array data.
+*/
+
+/*!
+  \fn char *TQGArray::data() const
+
+  Returns a pointer to the actual array data.
+*/
+
+/*!
+  \fn uint TQGArray::nrefs() const
+
+  Returns the reference count.
+*/
+
+/*!
+  \fn uint TQGArray::size() const
+
+  Returns the size of the array, in bytes.
+*/
+
+
+/*!
+  Returns TRUE if this array is equal to \a a, otherwise FALSE.
+  The comparison is bitwise, of course.
+*/
+
+bool TQGArray::isEqual( const TQGArray &a ) const
+{
+    if ( size() != a.size() )			// different size
+	return FALSE;
+    if ( data() == a.data() )			// has same data
+	return TRUE;
+    return (size() ? memcmp( data(), a.data(), size() ) : 0) == 0;
+}
+
+
+/*!
+  Resizes the array to \a newsize bytes. \a optim is either
+  \c MemOptim (the default) or \c SpeedOptim.
+
+  <b>Note:</b> \c SpeedOptim is only available if TQt is built in a
+  particular configuration. By default, \c SpeedOptim is not available
+  for general use.
+*/
+bool TQGArray::resize( uint newsize, Optimization optim )
+{
+#ifndef TQT_TQGARRAY_SPEED_OPTIM
+    TQ_UNUSED(optim);
+#endif
+
+    if ( newsize == shd->len
+#ifdef TQT_TQGARRAY_SPEED_OPTIM
+	 && newsize == shd->maxl
+#endif
+	) // nothing to do
+	return TRUE;
+    if ( newsize == 0 ) {			// remove array
+	if ( shd->data )
+	    DELETE(shd->data);
+	shd->data = 0;
+	shd->len = 0;
+#ifdef TQT_TQGARRAY_SPEED_OPTIM
+	shd->maxl = 0;
+#endif
+	return TRUE;
+    }
+
+    uint newmaxl = newsize;
+#ifdef TQT_TQGARRAY_SPEED_OPTIM
+    if ( optim == SpeedOptim ) {
+	if ( newsize <= shd->maxl &&
+	     ( newsize * 4 > shd->maxl || shd->maxl <= 4 ) ) {
+	    shd->len = newsize;
+	    return TRUE;
+	}
+	newmaxl = 4;
+	while ( newmaxl < newsize )
+	    newmaxl *= 2;
+	// try to spare some memory
+	if ( newmaxl >= 1024 * 1024 && newsize <= newmaxl - (newmaxl >> 2) )
+	    newmaxl -= newmaxl >> 2;
+    }
+    shd->maxl = newmaxl;
+#endif
+
+    if ( shd->data ) {				// existing data
+#if defined(DONT_USE_REALLOC)
+	char *newdata = NEW(char,newsize);	// manual realloc
+	memcpy( newdata, shd->data, TQMIN(shd->len,newmaxl) );
+	DELETE(shd->data);
+	shd->data = newdata;
+#else
+	shd->data = (char *)realloc( shd->data, newmaxl );
+#endif
+    } else {
+	shd->data = NEW(char,newmaxl);
+    }
+    if ( !shd->data )				// no memory
+	return FALSE;
+    shd->len = newsize;
+    return TRUE;
+}
+
+/*!\overload
+*/
+bool TQGArray::resize( uint newsize )
+{
+    return resize( newsize, MemOptim );
+}
+
+
+/*!
+  Fills the array with the repeated occurrences of \a d, which is
+  \a sz bytes long.
+  If \a len is specified as different from -1, then the array will be
+  resized to \a len*sz before it is filled.
+
+  Returns TRUE if successful, or FALSE if the memory cannot be allocated
+  (only when \a len != -1).
+
+  \sa resize()
+*/
+
+bool TQGArray::fill( const char *d, int len, uint sz )
+{
+    if ( len < 0 )
+	len = shd->len/sz;			// default: use array length
+    else if ( !resize( len*sz ) )
+	return FALSE;
+    if ( sz == 1 )				// 8 bit elements
+	memset( data(), *d, len );
+    else if ( sz == 4 ) {			// 32 bit elements
+	register TQ_INT32 *x = (TQ_INT32*)data();
+	TQ_INT32 v = *((TQ_INT32*)d);
+	while ( len-- )
+	    *x++ = v;
+    } else if ( sz == 2 ) {			// 16 bit elements
+	register TQ_INT16 *x = (TQ_INT16*)data();
+	TQ_INT16 v = *((TQ_INT16*)d);
+	while ( len-- )
+	    *x++ = v;
+    } else {					// any other size elements
+	register char *x = data();
+	while ( len-- ) {			// more complicated
+	    memcpy( x, d, sz );
+	    x += sz;
+	}
+    }
+    return TRUE;
+}
+
+/*!
+    \overload
+  Shallow copy. Dereference the current array and references the data
+  contained in \a a instead. Returns a reference to this array.
+  \sa operator=()
+*/
+
+TQGArray &TQGArray::assign( const TQGArray &a )
+{
+    a.shd->ref();				// avoid 'a = a'
+    if ( shd->deref() ) {			// delete when last reference
+	if ( shd->data )			// is lost
+	    DELETE(shd->data);
+	deleteData( shd );
+    }
+    shd = a.shd;
+    return *this;
+}
+
+/*!
+  Shallow copy. Dereference the current array and references the
+  array data \a d, which tqcontains \a len bytes.
+  Returns a reference to this array.
+
+  Do not delete \a d later, because TQGArray takes care of that.
+*/
+
+TQGArray &TQGArray::assign( const char *d, uint len )
+{
+    if ( shd->count > 1 ) {			// disconnect this
+	shd->count--;
+	shd = newData();
+	TQ_CHECK_PTR( shd );
+    } else {
+	if ( shd->data )
+	    DELETE(shd->data);
+    }
+    shd->data = (char *)d;
+    shd->len =
+#ifdef TQT_TQGARRAY_SPEED_OPTIM
+	shd->maxl =
+#endif
+	len;
+    return *this;
+}
+
+/*!
+  Deep copy. Dereference the current array and obtains a copy of the data
+  contained in \a a instead. Returns a reference to this array.
+  \sa assign(), operator=()
+*/
+
+TQGArray &TQGArray::duplicate( const TQGArray &a )
+{
+    if ( a.shd == shd ) {			// a.duplicate(a) !
+	if ( shd->count > 1 ) {
+	    shd->count--;
+	    register array_data *n = newData();
+	    TQ_CHECK_PTR( n );
+	    if ( (n->len=shd->len) ) {
+		n->data = NEW(char,n->len);
+		TQ_CHECK_PTR( n->data );
+		if ( n->data )
+		    memcpy( n->data, shd->data, n->len );
+	    } else {
+		n->data = 0;
+	    }
+	    shd = n;
+	}
+	return *this;
+    }
+    char *oldptr = 0;
+    if ( shd->count > 1 ) {			// disconnect this
+	shd->count--;
+	shd = newData();
+	TQ_CHECK_PTR( shd );
+    } else {					// delete after copy was made
+	oldptr = shd->data;
+    }
+    if ( a.shd->len ) {				// duplicate data
+	shd->data = NEW(char,a.shd->len);
+	TQ_CHECK_PTR( shd->data );
+	if ( shd->data )
+	    memcpy( shd->data, a.shd->data, a.shd->len );
+    } else {
+	shd->data = 0;
+    }
+    shd->len =
+#ifdef TQT_TQGARRAY_SPEED_OPTIM
+	shd->maxl =
+#endif
+	a.shd->len;
+    if ( oldptr )
+	DELETE(oldptr);
+    return *this;
+}
+
+/*!
+    \overload
+  Deep copy. Dereferences the current array and obtains a copy of
+  \a len characters from array data \a d instead.  Returns a reference
+  to this array.
+  \sa assign(), operator=()
+*/
+
+TQGArray &TQGArray::duplicate( const char *d, uint len )
+{
+    char *data;
+    if ( d == 0 || len == 0 ) {
+	data = 0;
+	len  = 0;
+    } else {
+	if ( shd->count == 1 && shd->len == len ) {
+	    if ( shd->data != d )		// avoid self-assignment
+		memcpy( shd->data, d, len );	// use same buffer
+	    return *this;
+	}
+	data = NEW(char,len);
+	TQ_CHECK_PTR( data );
+	memcpy( data, d, len );
+    }
+    if ( shd->count > 1 ) {			// detach
+	shd->count--;
+	shd = newData();
+	TQ_CHECK_PTR( shd );
+    } else {					// just a single reference
+	if ( shd->data )
+	    DELETE(shd->data);
+    }
+    shd->data = data;
+    shd->len =
+#ifdef TQT_TQGARRAY_SPEED_OPTIM
+	shd->maxl =
+#endif
+	len;
+    return *this;
+}
+
+/*!
+  Resizes this array to \a len bytes and copies the \a len bytes at
+  address \a d into it.
+
+  \warning This function disregards the reference count mechanism.  If
+  other TQGArrays reference the same data as this, all will be updated.
+*/
+
+void TQGArray::store( const char *d, uint len )
+{						// store, but not deref
+    resize( len );
+    memcpy( shd->data, d, len );
+}
+
+
+/*!
+  \fn array_data *TQGArray::sharedBlock() const
+
+  Returns a pointer to the shared array block.
+
+  \warning
+
+  Do not use this function.  Using it is begging for trouble.  We dare
+  not remove it, for fear of breaking code, but we \e strongly
+  discourage new use of it.
+*/
+
+/*!
+  \fn void TQGArray::setSharedBlock( array_data *p )
+
+  Sets the shared array block to \a p.
+
+  \warning
+
+  Do not use this function.  Using it is begging for trouble.  We dare
+  not remove it, for fear of breaking code, but we \e strongly
+  discourage new use of it.
+*/
+
+
+/*!
+  Sets raw data and returns a reference to the array.
+
+  Dereferences the current array and sets the new array data to \a d and
+  the new array size to \a len.	 Do not attempt to resize or re-assign the
+  array data when raw data has been set.
+  Call resetRawData(d,len) to reset the array.
+
+  Setting raw data is useful because it sets TQMemArray data without
+  allocating memory or copying data.
+
+  Example of intended use:
+  \code
+    static uchar bindata[] = { 231, 1, 44, ... };
+    TQByteArray	a;
+    a.setRawData( bindata, sizeof(bindata) );	// a points to bindata
+    TQDataStream s( a, IO_ReadOnly );		// open on a's data
+    s >> <something>;				// read raw bindata
+    s.close();
+    a.resetRawData( bindata, sizeof(bindata) ); // finished
+  \endcode
+
+  Example of misuse (do not do this):
+  \code
+    static uchar bindata[] = { 231, 1, 44, ... };
+    TQByteArray	a, b;
+    a.setRawData( bindata, sizeof(bindata) );	// a points to bindata
+    a.resize( 8 );				// will crash
+    b = a;					// will crash
+    a[2] = 123;					// might crash
+      // forget to resetRawData - will crash
+  \endcode
+
+  \warning If you do not call resetRawData(), TQGArray will attempt to
+  deallocate or reallocate the raw data, which might not be too good.
+  Be careful.
+*/
+
+TQGArray &TQGArray::setRawData( const char *d, uint len )
+{
+    duplicate( 0, 0 );				// set null data
+    shd->data = (char *)d;
+    shd->len  = len;
+    return *this;
+}
+
+/*!
+  Resets raw data.
+
+  The arguments must be the data, \a d, and length \a len, that were
+  passed to setRawData().  This is for consistency checking.
+*/
+
+void TQGArray::resetRawData( const char *d, uint len )
+{
+    if ( d != shd->data || len != shd->len ) {
+#if defined(TQT_CHECK_STATE)
+	qWarning( "TQGArray::resetRawData: Inconsistent arguments" );
+#endif
+	return;
+    }
+    shd->data = 0;
+    shd->len  = 0;
+}
+
+
+/*!
+  Finds the first occurrence of \a d in the array from position \a index,
+  where \a sz is the size of the \a d element.
+
+  Note that \a index is given in units of \a sz, not bytes.
+
+  This function only compares whole cells, not bytes.
+*/
+
+int TQGArray::tqfind( const char *d, uint index, uint sz ) const
+{
+    index *= sz;
+    if ( index >= shd->len ) {
+#if defined(TQT_CHECK_RANGE)
+	qWarning( "TQGArray::tqfind: Index %d out of range", index/sz );
+#endif
+	return -1;
+    }
+    register uint i;
+    uint ii;
+    switch ( sz ) {
+	case 1: {				// 8 bit elements
+	    register char *x = data() + index;
+	    char v = *d;
+	    for ( i=index; i<shd->len; i++ ) {
+		if ( *x++ == v )
+		    break;
+	    }
+	    ii = i;
+	    }
+	    break;
+	case 2: {				// 16 bit elements
+	    register TQ_INT16 *x = (TQ_INT16*)(data() + index);
+	    TQ_INT16 v = *((TQ_INT16*)d);
+	    for ( i=index; i<shd->len; i+=2 ) {
+		if ( *x++ == v )
+		    break;
+	    }
+	    ii = i/2;
+	    }
+	    break;
+	case 4: {				// 32 bit elements
+	    register TQ_INT32 *x = (TQ_INT32*)(data() + index);
+	    TQ_INT32 v = *((TQ_INT32*)d);
+	    for ( i=index; i<shd->len; i+=4 ) {
+		if ( *x++ == v )
+		    break;
+	    }
+	    ii = i/4;
+	    }
+	    break;
+	default: {				// any size elements
+	    for ( i=index; i<shd->len; i+=sz ) {
+		if ( memcmp( d, &shd->data[i], sz ) == 0 )
+		    break;
+	    }
+	    ii = i/sz;
+	    }
+	    break;
+    }
+    return i<shd->len ? (int)ii : -1;
+}
+
+/*!
+  Returns the number of occurrences of \a d in the array, where \a sz is
+  the size of the \a d element.
+
+  This function only compares whole cells, not bytes.
+*/
+
+int TQGArray::tqcontains( const char *d, uint sz ) const
+{
+    register uint i = shd->len;
+    int count = 0;
+    switch ( sz ) {
+	case 1: {				// 8 bit elements
+	    register char *x = data();
+	    char v = *d;
+	    while ( i-- ) {
+		if ( *x++ == v )
+		    count++;
+	    }
+	    }
+	    break;
+	case 2: {				// 16 bit elements
+	    register TQ_INT16 *x = (TQ_INT16*)data();
+	    TQ_INT16 v = *((TQ_INT16*)d);
+	    i /= 2;
+	    while ( i-- ) {
+		if ( *x++ == v )
+		    count++;
+	    }
+	    }
+	    break;
+	case 4: {				// 32 bit elements
+	    register TQ_INT32 *x = (TQ_INT32*)data();
+	    TQ_INT32 v = *((TQ_INT32*)d);
+	    i /= 4;
+	    while ( i-- ) {
+		if ( *x++ == v )
+		    count++;
+	    }
+	    }
+	    break;
+	default: {				// any size elements
+	    for ( i=0; i<shd->len; i+=sz ) {
+		if ( memcmp(d, &shd->data[i], sz) == 0 )
+		    count++;
+	    }
+	    }
+	    break;
+    }
+    return count;
+}
+
+static int cmp_item_size = 0;
+
+#if defined(TQ_C_CALLBACKS)
+extern "C" {
+#endif
+
+#ifdef TQ_OS_TEMP
+static int __cdecl cmp_arr( const void *n1, const void *n2 )
+#else
+static int cmp_arr( const void *n1, const void *n2 )
+#endif
+{
+    return ( n1 && n2 ) ? memcmp( n1, n2, cmp_item_size )
+			: ( n1 ? 1 : ( n2 ? -1 : 0 ) );
+    // ### TQt 3.0: Add a virtual compareItems() method and call that instead
+}
+
+#if defined(TQ_C_CALLBACKS)
+}
+#endif
+
+/*!
+  Sorts the first \a sz items of the array.
+*/
+
+void TQGArray::sort( uint sz )
+{
+    int numItems = size() / sz;
+    if ( numItems < 2 )
+	return;
+
+#ifdef TQT_THREAD_SUPPORT
+    TQMutexLocker locker( tqt_global_mutexpool ?
+			 tqt_global_mutexpool->get( &cmp_item_size ) : 0 );
+#endif // TQT_THREAD_SUPPORT
+
+    cmp_item_size = sz;
+    qsort( shd->data, numItems, sz, cmp_arr );
+}
+
+/*!
+  Binary search; assumes that \a d is a sorted array of size \a sz.
+*/
+
+int TQGArray::bsearch( const char *d, uint sz ) const
+{
+    int numItems = size() / sz;
+    if ( !numItems )
+	return -1;
+
+#ifdef TQT_THREAD_SUPPORT
+    TQMutexLocker locker( tqt_global_mutexpool ?
+			 tqt_global_mutexpool->get( &cmp_item_size ) : 0 );
+#endif // TQT_THREAD_SUPPORT
+
+    cmp_item_size = sz;
+    char* r = (char*)::bsearch( d, shd->data, numItems, sz, cmp_arr );
+    if ( !r )
+	return -1;
+    while( (r >= shd->data + sz) && (cmp_arr( r - sz, d ) == 0) )
+	r -= sz;	// search to first of equal elements; bsearch is undef
+    return (int)(( r - shd->data ) / sz);
+}
+
+
+/*!
+  \fn char *TQGArray::at( uint index ) const
+
+  Returns a pointer to the byte at offset \a index in the array.
+*/
+
+/*!
+  Expand the array if necessary, and copies (the first part of) its
+  contents from the \a index * \a sz bytes at \a d.
+
+  Returns TRUE if the operation succeeds, FALSE if it runs out of
+  memory.
+
+  \warning This function disregards the reference count mechanism.  If
+  other TQGArrays reference the same data as this, all will be changed.
+*/
+
+bool TQGArray::setExpand( uint index, const char *d, uint sz )
+{
+    index *= sz;
+    if ( index >= shd->len ) {
+	if ( !resize( index+sz ) )		// no memory
+	    return FALSE;
+    }
+    memcpy( data() + index, d, sz );
+    return TRUE;
+}
+
+
+/*!
+  Prints a warning message if at() or [] is given a bad index.
+*/
+
+void TQGArray::msg_index( uint index )
+{
+#if defined(TQT_CHECK_RANGE)
+    qWarning( "TQGArray::at: Absolute index %d out of range", index );
+#else
+    TQ_UNUSED( index )
+#endif
+}
+
+
+/*!
+  Returns a new shared array block.
+*/
+
+TQGArray::array_data * TQGArray::newData()
+{
+    return new array_data;
+}
+
+
+/*!
+  Deletes the shared array block \a p.
+*/
+
+void TQGArray::deleteData( array_data *p )
+{
+    delete p;
+}
diff --git a/tqtinterface/qt4/src/tools/tqgarray.h b/tqtinterface/qt4/src/tools/tqgarray.h
new file mode 100644
index 0000000..b581621
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqgarray.h
@@ -0,0 +1,134 @@
+/****************************************************************************
+**
+** Definition of TQGArray class
+**
+** Created : 930906
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQGARRAY_H
+#define TQGARRAY_H
+
+#ifndef TQT_H
+#include "tqshared.h"
+#endif // TQT_H
+
+
+class TQ_EXPORT TQGArray					// generic array
+{
+friend class TQBuffer;
+public:
+    // do not use this, even though this is public
+    // ### make protected or private in TQt 4.0 beta?
+    struct array_data : public TQShared {	// shared array
+	array_data():data(0),len(0)
+#ifdef TQT_TQGARRAY_SPEED_OPTIM
+		    ,maxl(0)
+#endif
+	    {}
+	char *data;				// actual array data
+	uint  len;
+#ifdef TQT_TQGARRAY_SPEED_OPTIM
+	uint maxl;
+#endif
+    };
+    TQGArray();
+    enum Optimization { MemOptim, SpeedOptim };
+protected:
+    TQGArray( int, int );			// dummy; does not alloc
+    TQGArray( int size );			// allocate 'size' bytes
+    TQGArray( const TQGArray &a );		// shallow copy
+    virtual ~TQGArray();
+
+    TQGArray    &operator=( const TQGArray &a ) { return assign( a ); }
+
+    virtual void detach()	{ duplicate(*this); }
+
+    // ### TQt 4.0: maybe provide two versions of data(), at(), etc.
+    char       *data()	 const	{ return shd->data; }
+    uint	nrefs()	 const	{ return shd->count; }
+    uint	size()	 const	{ return shd->len; }
+    bool	isEqual( const TQGArray &a ) const;
+
+    bool	resize( uint newsize, Optimization optim );
+    bool	resize( uint newsize );
+
+    bool	fill( const char *d, int len, uint sz );
+
+    TQGArray    &assign( const TQGArray &a );
+    TQGArray    &assign( const char *d, uint len );
+    TQGArray    &duplicate( const TQGArray &a );
+    TQGArray    &duplicate( const char *d, uint len );
+    void	store( const char *d, uint len );
+
+    array_data *sharedBlock()	const		{ return shd; }
+    void	setSharedBlock( array_data *p ) { shd=(array_data*)p; }
+
+    TQGArray    &setRawData( const char *d, uint len );
+    void	resetRawData( const char *d, uint len );
+
+    int		tqfind( const char *d, uint index, uint sz ) const;
+    int		tqcontains( const char *d, uint sz ) const;
+
+    void	sort( uint sz );
+    int		bsearch( const char *d, uint sz ) const;
+
+    char       *at( uint index ) const;
+
+    bool	setExpand( uint index, const char *d, uint sz );
+
+protected:
+    virtual array_data *newData();
+    virtual void deleteData( array_data *p );
+
+private:
+    static void msg_index( uint );
+    array_data *shd;
+};
+
+
+inline char *TQGArray::at( uint index ) const
+{
+#if defined(TQT_CHECK_RANGE)
+    if ( index >= size() ) {
+	msg_index( index );
+	index = 0;
+    }
+#endif
+    return &shd->data[index];
+}
+
+
+#endif // TQGARRAY_H
diff --git a/tqtinterface/qt4/src/tools/tqgcache.cpp b/tqtinterface/qt4/src/tools/tqgcache.cpp
new file mode 100644
index 0000000..1d2d3bb
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqgcache.cpp
@@ -0,0 +1,866 @@
+/****************************************************************************
+**
+** Implementation of TQGCache and TQGCacheIterator classes
+**
+** Created : 950208
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "tqgcache.h"
+#include "tqptrlist.h"
+#include "tqdict.h"
+#include "tqstring.h"
+
+/*!
+  \class TQGCache tqgcache.h
+  \reentrant
+  \ingroup shared
+  \ingroup collection
+  \brief The TQGCache class is an internal class for implementing TQCache
+  template classes.
+
+  \internal
+
+  TQGCache is a strictly internal class that acts as a base class for the
+  \link collection.html collection classes\endlink TQCache and TQIntCache.
+*/
+
+
+/*****************************************************************************
+  TQGCacheItem class (internal cache item)
+ *****************************************************************************/
+
+struct TQCacheItem
+{
+    TQCacheItem( void *k, TQPtrCollection::Item d, int c, short p )
+	: priority(p), skipPriority(p), cost(c), key(k), data(d), node(0) {}
+    short	priority;
+    short	skipPriority;
+    int		cost;
+    void       *key;
+    TQPtrCollection::Item data;
+    TQLNode     *node;
+};
+
+
+/*****************************************************************************
+  TQCList class (internal list of cache items)
+ *****************************************************************************/
+
+class TQCList : private TQPtrList<TQCacheItem>
+{
+friend class TQGCacheIterator;
+friend class TQCListIt;
+public:
+    TQCList()	{}
+   ~TQCList();
+
+    void	insert( TQCacheItem * );		// insert according to priority
+    void	insert( int, TQCacheItem * );
+    void	take( TQCacheItem * );
+    void	reference( TQCacheItem * );
+
+    void	setAutoDelete( bool del ) { TQPtrCollection::setAutoDelete(del); }
+
+    bool	removeFirst()	{ return TQPtrList<TQCacheItem>::removeFirst(); }
+    bool	removeLast()	{ return TQPtrList<TQCacheItem>::removeLast(); }
+
+    TQCacheItem *first()		{ return TQPtrList<TQCacheItem>::first(); }
+    TQCacheItem *last()		{ return TQPtrList<TQCacheItem>::last(); }
+    TQCacheItem *prev()		{ return TQPtrList<TQCacheItem>::prev(); }
+    TQCacheItem *next()		{ return TQPtrList<TQCacheItem>::next(); }
+
+#if defined(TQT_DEBUG)
+    int		inserts;			// variables for statistics
+    int		insertCosts;
+    int		insertMisses;
+    int		tqfinds;
+    int		hits;
+    int		hitCosts;
+    int		dumps;
+    int		dumpCosts;
+#endif
+};
+
+
+TQCList::~TQCList()
+{
+#if defined(TQT_DEBUG)
+    TQ_ASSERT( count() == 0 );
+#endif
+}
+
+
+void TQCList::insert( TQCacheItem *ci )
+{
+    TQCacheItem *item = first();
+    while( item && item->skipPriority > ci->priority ) {
+	item->skipPriority--;
+	item = next();
+    }
+    if ( item )
+	TQPtrList<TQCacheItem>::insert( at(), ci );
+    else
+	append( ci );
+#if defined(TQT_DEBUG)
+    TQ_ASSERT( ci->node == 0 );
+#endif
+    ci->node = currentNode();
+}
+
+inline void TQCList::insert( int i, TQCacheItem *ci )
+{
+    TQPtrList<TQCacheItem>::insert( i, ci );
+#if defined(TQT_DEBUG)
+    TQ_ASSERT( ci->node == 0 );
+#endif
+    ci->node = currentNode();
+}
+
+
+void TQCList::take( TQCacheItem *ci )
+{
+    if ( ci ) {
+#if defined(TQT_DEBUG)
+	TQ_ASSERT( ci->node != 0 );
+#endif
+	takeNode( ci->node );
+	ci->node = 0;
+    }
+}
+
+
+inline void TQCList::reference( TQCacheItem *ci )
+{
+#if defined(TQT_DEBUG)
+    TQ_ASSERT( ci != 0 && ci->node != 0 );
+#endif
+    ci->skipPriority = ci->priority;
+    relinkNode( ci->node );			// relink as first item
+}
+
+
+class TQCListIt: public TQPtrListIterator<TQCacheItem>
+{
+public:
+    TQCListIt( const TQCList *p ): TQPtrListIterator<TQCacheItem>( *p ) {}
+    TQCListIt( const TQCListIt *p ): TQPtrListIterator<TQCacheItem>( *p ) {}
+};
+
+
+/*****************************************************************************
+  TQCDict class (internal dictionary of cache items)
+ *****************************************************************************/
+
+//
+// Since we need to decide if the dictionary should use an int or const
+// char * key (the "bool trivial" argument in the constructor below)
+// we cannot use the macro/template dict, but inherit directly from TQGDict.
+//
+
+class TQCDict : public TQGDict
+{
+public:
+    TQCDict( uint size, uint kt, bool caseSensitive, bool copyKeys )
+	: TQGDict( size, (KeyType)kt, caseSensitive, copyKeys ) {}
+    ~TQCDict();
+
+    void clear() { TQGDict::clear(); }
+
+    TQCacheItem *tqfind_string(const TQString &key) const
+	{ return (TQCacheItem*)((TQCDict*)this)->look_string(key, 0, 0); }
+    TQCacheItem *tqfind_ascii(const char *key) const
+	{ return (TQCacheItem*)((TQCDict*)this)->look_ascii(key, 0, 0); }
+    TQCacheItem *tqfind_int(long key) const
+	{ return (TQCacheItem*)((TQCDict*)this)->look_int(key, 0, 0); }
+
+    TQCacheItem *take_string(const TQString &key)
+	{ return (TQCacheItem*)TQGDict::take_string(key); }
+    TQCacheItem *take_ascii(const char *key)
+	{ return (TQCacheItem*)TQGDict::take_ascii(key); }
+    TQCacheItem *take_int(long key)
+	{ return (TQCacheItem*)TQGDict::take_int(key); }
+
+    bool  insert_string( const TQString &key, const TQCacheItem *ci )
+	{ return TQGDict::look_string(key,(Item)ci,1)!=0;}
+    bool  insert_ascii( const char *key, const TQCacheItem *ci )
+	{ return TQGDict::look_ascii(key,(Item)ci,1)!=0;}
+    bool  insert_int( long key, const TQCacheItem *ci )
+	{ return TQGDict::look_int(key,(Item)ci,1)!=0;}
+
+    bool  remove_string( TQCacheItem *item )
+	{ return TQGDict::remove_string(*((TQString*)(item->key)),item); }
+    bool  remove_ascii( TQCacheItem *item )
+	{ return TQGDict::remove_ascii((const char *)item->key,item); }
+    bool  remove_int( TQCacheItem *item )
+	{ return TQGDict::remove_int((long)item->key,item);}
+
+    void  statistics()			{ TQGDict::statistics(); }
+
+private:
+    void deleteItem( void *item )
+	{ if ( del_item ) { TQCacheItem *d = (TQCacheItem*)item; delete d; } }
+};
+
+inline TQCDict::~TQCDict()
+{
+    clear();
+}
+
+/*****************************************************************************
+  TQGDict member functions
+ *****************************************************************************/
+
+/*!
+  Constructs a cache.
+  The maximum cost of the cache is given by \a maxCost and the size by \a
+  size. The key type is \a kt which may be \c StringKey, \c AsciiKey,
+  \c IntKey or \c PtrKey. The case-sensitivity of lookups is set with
+  \a caseSensitive. Keys are copied if \a copyKeys is TRUE.
+*/
+
+TQGCache::TQGCache( int maxCost, uint size, KeyType kt, bool caseSensitive,
+		  bool copyKeys )
+{
+    keytype = kt;
+    lruList = new TQCList;
+    TQ_CHECK_PTR( lruList );
+    lruList->setAutoDelete( TRUE );
+    copyk   = ((keytype == AsciiKey) && copyKeys);
+    dict    = new TQCDict( size, kt, caseSensitive, FALSE );
+    TQ_CHECK_PTR( dict );
+    mCost   = maxCost;
+    tCost   = 0;
+#if defined(TQT_DEBUG)
+    lruList->inserts	  = 0;
+    lruList->insertCosts  = 0;
+    lruList->insertMisses = 0;
+    lruList->tqfinds	  = 0;
+    lruList->hits	  = 0;
+    lruList->hitCosts	  = 0;
+    lruList->dumps	  = 0;
+    lruList->dumpCosts	  = 0;
+#endif
+}
+
+/*!
+  Cannot copy a cache.
+*/
+
+TQGCache::TQGCache( const TQGCache & )
+    : TQPtrCollection()
+{
+#if defined(TQT_CHECK_NULL)
+    qFatal( "TQGCache::TQGCache(TQGCache &): Cannot copy a cache" );
+#endif
+}
+
+/*!
+  Removes all items from the cache and destroys it.
+*/
+
+TQGCache::~TQGCache()
+{
+    clear();
+    delete dict;
+    delete lruList;
+}
+
+/*!
+  Cannot assign a cache.
+*/
+
+TQGCache &TQGCache::operator=( const TQGCache & )
+{
+#if defined(TQT_CHECK_NULL)
+    qFatal( "TQGCache::operator=: Cannot copy a cache" );
+#endif
+    return *this;
+}
+
+
+/*!
+  Returns the number of items in the cache.
+*/
+
+uint TQGCache::count() const
+{
+    return dict->count();
+}
+
+/*!
+  Returns the size of the hash array.
+*/
+
+uint TQGCache::size() const
+{
+    return dict->size();
+}
+
+/*!
+  \fn int TQGCache::maxCost() const
+
+  Returns the maximum cache cost.
+*/
+
+/*!
+  \fn int TQGCache::totalCost() const
+
+  Returns the total cache cost.
+*/
+
+/*!
+  Sets the maximum cache cost to \a maxCost.
+*/
+
+void TQGCache::setMaxCost( int maxCost )
+{
+    if ( maxCost < tCost ) {
+	if ( !makeRoomFor(tCost - maxCost) )	// remove excess cost
+	    return;
+    }
+    mCost = maxCost;
+}
+
+
+/*!
+    Inserts an item with data \a data into the cache using key \a key.
+    The item has cost \a cost and priority \a priority.
+
+  \warning If this function returns FALSE, you must delete \a data
+  yourself.  Additionally, be very careful about using \a data after
+  calling this function, as any other insertions into the cache, from
+  anywhere in the application, or within TQt itself, could cause the
+  data to be discarded from the cache, and the pointer to become
+  invalid.
+*/
+
+bool TQGCache::insert_string( const TQString &key, TQPtrCollection::Item data,
+			     int cost, int priority)
+{
+    if ( tCost + cost > mCost ) {
+	if ( !makeRoomFor(tCost + cost - mCost, priority) ) {
+#if defined(TQT_DEBUG)
+	    lruList->insertMisses++;
+#endif
+	    return FALSE;
+	}
+    }
+#if defined(TQT_DEBUG)
+    TQ_ASSERT( keytype == StringKey );
+    lruList->inserts++;
+    lruList->insertCosts += cost;
+#endif
+    if ( priority < -32768 )
+	priority = -32768;
+    else if ( priority > 32767 )
+	priority = 32677;
+    TQCacheItem *ci = new TQCacheItem( new TQString(key), newItem(data),
+				     cost, (short)priority );
+    TQ_CHECK_PTR( ci );
+    lruList->insert( 0, ci );
+    dict->insert_string( key, ci );
+    tCost += cost;
+    return TRUE;
+}
+
+bool TQGCache::insert_other( const char *key, TQPtrCollection::Item data,
+			    int cost, int priority)
+{
+    if ( tCost + cost > mCost ) {
+	if ( !makeRoomFor(tCost + cost - mCost, priority) ) {
+#if defined(TQT_DEBUG)
+	    lruList->insertMisses++;
+#endif
+	    return FALSE;
+	}
+    }
+#if defined(TQT_DEBUG)
+    TQ_ASSERT( keytype != StringKey );
+    lruList->inserts++;
+    lruList->insertCosts += cost;
+#endif
+    if ( keytype == AsciiKey && copyk )
+	key = qstrdup( key );
+    if ( priority < -32768 )
+	priority = -32768;
+    else if ( priority > 32767 )
+	priority = 32677;
+    TQCacheItem *ci = new TQCacheItem( (void*)key, newItem(data), cost,
+				     (short)priority );
+    TQ_CHECK_PTR( ci );
+    lruList->insert( 0, ci );
+    if ( keytype == AsciiKey )
+	dict->insert_ascii( key, ci );
+    else
+	dict->insert_int( (long)key, ci );
+    tCost += cost;
+    return TRUE;
+}
+
+
+/*!
+  Removes the item with key \a key from the cache. Returns TRUE if the
+  item was removed; otherwise returns FALSE.
+*/
+
+bool TQGCache::remove_string( const TQString &key )
+{
+    Item d = take_string( key );
+    if ( d )
+	deleteItem( d );
+    return d != 0;
+}
+
+bool TQGCache::remove_other( const char *key )
+{
+    Item d = take_other( key );
+    if ( d )
+	deleteItem( d );
+    return d != 0;
+}
+
+
+/*!
+  Takes the item with key \a key out of the cache. The item is not
+  deleted. If no item has this \a key 0 is returned.
+*/
+
+TQPtrCollection::Item TQGCache::take_string( const TQString &key )
+{
+    TQCacheItem *ci = dict->take_string( key );	// take from dict
+    Item d;
+    if ( ci ) {
+	d = ci->data;
+	tCost -= ci->cost;
+	lruList->take( ci );			// take from list
+	delete (TQString*)ci->key;
+	delete ci;
+    } else {
+	d = 0;
+    }
+    return d;
+}
+
+/*!
+  Takes the item with key \a key out of the cache. The item is not
+  deleted. If no item has this \a key 0 is returned.
+*/
+
+TQPtrCollection::Item TQGCache::take_other( const char *key )
+{
+    TQCacheItem *ci;
+    if ( keytype == AsciiKey )
+	ci = dict->take_ascii( key );
+    else
+	ci = dict->take_int( (long)key );
+    Item d;
+    if ( ci ) {
+	d = ci->data;
+	tCost -= ci->cost;
+	lruList->take( ci );			// take from list
+	if ( copyk )
+	    delete [] (char *)ci->key;
+	delete ci;
+    } else {
+	d = 0;
+    }
+    return d;
+}
+
+
+/*!
+  Clears the cache.
+*/
+
+void TQGCache::clear()
+{
+    TQCacheItem *ci;
+    while ( (ci = lruList->first()) ) {
+	switch ( keytype ) {
+	    case StringKey:
+		dict->remove_string( ci );
+		delete (TQString*)ci->key;
+		break;
+	    case AsciiKey:
+		dict->remove_ascii( ci );
+		if ( copyk )
+		    delete [] (char*)ci->key;
+		break;
+	    case IntKey:
+		dict->remove_int( ci );
+		break;
+	    case PtrKey:			// unused
+		break;
+	}
+	deleteItem( ci->data );			// delete data
+	lruList->removeFirst();			// remove from list
+    }
+    tCost = 0;
+}
+
+
+/*!
+  Finds an item for \a key in the cache and adds a reference if \a ref is TRUE.
+*/
+
+TQPtrCollection::Item TQGCache::tqfind_string( const TQString &key, bool ref ) const
+{
+    TQCacheItem *ci = dict->tqfind_string( key );
+#if defined(TQT_DEBUG)
+    lruList->tqfinds++;
+#endif
+    if ( ci ) {
+#if defined(TQT_DEBUG)
+	lruList->hits++;
+	lruList->hitCosts += ci->cost;
+#endif
+	if ( ref )
+	    lruList->reference( ci );
+	return ci->data;
+    }
+    return 0;
+}
+
+
+/*!
+  Finds an item for \a key in the cache and adds a reference if \a ref is TRUE.
+*/
+
+TQPtrCollection::Item TQGCache::tqfind_other( const char *key, bool ref ) const
+{
+    TQCacheItem *ci = keytype == AsciiKey ? dict->tqfind_ascii(key)
+					 : dict->tqfind_int((long)key);
+#if defined(TQT_DEBUG)
+    lruList->tqfinds++;
+#endif
+    if ( ci ) {
+#if defined(TQT_DEBUG)
+	lruList->hits++;
+	lruList->hitCosts += ci->cost;
+#endif
+	if ( ref )
+	    lruList->reference( ci );
+	return ci->data;
+    }
+    return 0;
+}
+
+
+/*!
+  Allocates cache space for one or more items.
+*/
+
+bool TQGCache::makeRoomFor( int cost, int priority )
+{
+    if ( cost > mCost )				// cannot make room for more
+	return FALSE;				//   than maximum cost
+    if ( priority == -1 )
+	priority = 32767;
+    register TQCacheItem *ci = lruList->last();
+    int cntCost = 0;
+    int dumps	= 0;				// number of items to dump
+    while ( cntCost < cost && ci && ci->skipPriority <= priority ) {
+	cntCost += ci->cost;
+	ci	 = lruList->prev();
+	dumps++;
+    }
+    if ( cntCost < cost )			// can enough cost be dumped?
+	return FALSE;				// no
+#if defined(TQT_DEBUG)
+    TQ_ASSERT( dumps > 0 );
+#endif
+    while ( dumps-- ) {
+	ci = lruList->last();
+#if defined(TQT_DEBUG)
+	lruList->dumps++;
+	lruList->dumpCosts += ci->cost;
+#endif
+	switch ( keytype ) {
+	    case StringKey:
+		dict->remove_string( ci );
+		delete (TQString*)ci->key;
+		break;
+	    case AsciiKey:
+		dict->remove_ascii( ci );
+		if ( copyk )
+		    delete [] (char *)ci->key;
+		break;
+	    case IntKey:
+		dict->remove_int( ci );
+		break;
+	    case PtrKey:			// unused
+		break;
+	}
+	deleteItem( ci->data );			// delete data
+	lruList->removeLast();			// remove from list
+    }
+    tCost -= cntCost;
+    return TRUE;
+}
+
+
+/*!
+  Outputs debug statistics.
+*/
+
+void TQGCache::statistics() const
+{
+#if defined(TQT_DEBUG)
+    TQString line;
+    line.fill( '*', 80 );
+    qDebug( line.ascii() );
+    qDebug( "CACHE STATISTICS:" );
+    qDebug( "cache tqcontains %d item%s, with a total cost of %d",
+	   count(), count() != 1 ? "s" : "", tCost );
+    qDebug( "maximum cost is %d, cache is %d%% full.",
+	   mCost, (200*tCost + mCost) / (mCost*2) );
+    qDebug( "tqfind() has been called %d time%s",
+	   lruList->tqfinds, lruList->tqfinds != 1 ? "s" : "" );
+    qDebug( "%d of these were hits, items found had a total cost of %d.",
+	   lruList->hits,lruList->hitCosts );
+    qDebug( "%d item%s %s been inserted with a total cost of %d.",
+	   lruList->inserts,lruList->inserts != 1 ? "s" : "",
+	   lruList->inserts != 1 ? "have" : "has", lruList->insertCosts );
+    qDebug( "%d item%s %s too large or had too low priority to be inserted.",
+	   lruList->insertMisses, lruList->insertMisses != 1 ? "s" : "",
+	   lruList->insertMisses != 1 ? "were" : "was" );
+    qDebug( "%d item%s %s been thrown away with a total cost of %d.",
+	   lruList->dumps, lruList->dumps != 1 ? "s" : "",
+	   lruList->dumps != 1 ? "have" : "has", lruList->dumpCosts );
+    qDebug( "Statistics from internal dictionary class:" );
+    dict->statistics();
+    qDebug( line.ascii() );
+#endif
+}
+
+
+/*****************************************************************************
+  TQGCacheIterator member functions
+ *****************************************************************************/
+
+/*!
+  \class TQGCacheIterator tqgcache.h
+  \reentrant
+  \ingroup shared
+  \ingroup collection
+  \brief The TQGCacheIterator class is an internal class for implementing TQCacheIterator and
+  TQIntCacheIterator.
+
+  \internal
+
+  TQGCacheIterator is a strictly internal class that does the heavy work for
+  TQCacheIterator and TQIntCacheIterator.
+*/
+
+/*!
+  Constructs an iterator that operates on the cache \a c.
+*/
+
+TQGCacheIterator::TQGCacheIterator( const TQGCache &c )
+{
+    it = new TQCListIt( c.lruList );
+#if defined(TQT_DEBUG)
+    TQ_ASSERT( it != 0 );
+#endif
+}
+
+/*!
+  Constructs an iterator that operates on the same cache as \a ci.
+*/
+
+TQGCacheIterator::TQGCacheIterator( const TQGCacheIterator &ci )
+{
+    it = new TQCListIt( ci.it );
+#if defined(TQT_DEBUG)
+    TQ_ASSERT( it != 0 );
+#endif
+}
+
+/*!
+  Destroys the iterator.
+*/
+
+TQGCacheIterator::~TQGCacheIterator()
+{
+    delete it;
+}
+
+/*!
+  Assigns the iterator \a ci to this cache iterator.
+*/
+
+TQGCacheIterator &TQGCacheIterator::operator=( const TQGCacheIterator &ci )
+{
+    *it = *ci.it;
+    return *this;
+}
+
+/*!
+  Returns the number of items in the cache.
+*/
+
+uint TQGCacheIterator::count() const
+{
+    return it->count();
+}
+
+/*!
+  Returns TRUE if the iterator points to the first item.
+*/
+
+bool  TQGCacheIterator::atFirst() const
+{
+    return it->atFirst();
+}
+
+/*!
+  Returns TRUE if the iterator points to the last item.
+*/
+
+bool TQGCacheIterator::atLast() const
+{
+    return it->atLast();
+}
+
+/*!
+  Sets the list iterator to point to the first item in the cache.
+*/
+
+TQPtrCollection::Item TQGCacheIterator::toFirst()
+{
+    TQCacheItem *item = it->toFirst();
+    return item ? item->data : 0;
+}
+
+/*!
+  Sets the list iterator to point to the last item in the cache.
+*/
+
+TQPtrCollection::Item TQGCacheIterator::toLast()
+{
+    TQCacheItem *item = it->toLast();
+    return item ? item->data : 0;
+}
+
+/*!
+  Returns the current item.
+*/
+
+TQPtrCollection::Item TQGCacheIterator::get() const
+{
+    TQCacheItem *item = it->current();
+    return item ? item->data : 0;
+}
+
+/*!
+  Returns the key of the current item.
+*/
+
+TQString TQGCacheIterator::getKeyString() const
+{
+    TQCacheItem *item = it->current();
+    return item ? *((TQString*)item->key) : TQString::null;
+}
+
+/*!
+  Returns the key of the current item, as a \0-terminated C string.
+*/
+
+const char *TQGCacheIterator::getKeyAscii() const
+{
+    TQCacheItem *item = it->current();
+    return item ? (const char *)item->key : 0;
+}
+
+/*!
+  Returns the key of the current item, as a long.
+*/
+
+long TQGCacheIterator::getKeyInt() const
+{
+    TQCacheItem *item = it->current();
+    return item ? (long)item->key : 0;
+}
+
+/*!
+  Moves to the next item (postfix).
+*/
+
+TQPtrCollection::Item TQGCacheIterator::operator()()
+{
+    TQCacheItem *item = it->operator()();
+    return item ? item->data : 0;
+}
+
+/*!
+  Moves to the next item (prefix).
+*/
+
+TQPtrCollection::Item TQGCacheIterator::operator++()
+{
+    TQCacheItem *item = it->operator++();
+    return item ? item->data : 0;
+}
+
+/*!
+  Moves \a jump positions forward.
+*/
+
+TQPtrCollection::Item TQGCacheIterator::operator+=( uint jump )
+{
+    TQCacheItem *item = it->operator+=(jump);
+    return item ? item->data : 0;
+}
+
+/*!
+  Moves to the previous item (prefix).
+*/
+
+TQPtrCollection::Item TQGCacheIterator::operator--()
+{
+    TQCacheItem *item = it->operator--();
+    return item ? item->data : 0;
+}
+
+/*!
+  Moves \a jump positions backward.
+*/
+
+TQPtrCollection::Item TQGCacheIterator::operator-=( uint jump )
+{
+    TQCacheItem *item = it->operator-=(jump);
+    return item ? item->data : 0;
+}
diff --git a/tqtinterface/qt4/src/tools/tqgcache.h b/tqtinterface/qt4/src/tools/tqgcache.h
new file mode 100644
index 0000000..7d54656
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqgcache.h
@@ -0,0 +1,131 @@
+/****************************************************************************
+**
+** Definition of TQGCache and TQGCacheIterator classes
+**
+** Created : 950208
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQGCACHE_H
+#define TQGCACHE_H
+
+#ifndef TQT_H
+#include "tqptrcollection.h"
+#include "tqglist.h"
+#include "tqgdict.h"
+#endif // TQT_H
+
+
+class TQCList;					// internal classes
+class TQCListIt;
+class TQCDict;
+
+
+class TQ_EXPORT TQGCache : public TQPtrCollection	// generic LRU cache
+{
+friend class TQGCacheIterator;
+protected:
+    enum KeyType { StringKey, AsciiKey, IntKey, PtrKey };
+      // identical to TQGDict's, but PtrKey is not used at the moment
+
+    TQGCache( int maxCost, uint size, KeyType kt, bool caseSensitive,
+	     bool copyKeys );
+    TQGCache( const TQGCache & );			// not allowed, calls fatal()
+   ~TQGCache();
+    TQGCache &operator=( const TQGCache & );	// not allowed, calls fatal()
+
+    uint    count()	const;
+    uint    size()	const;
+    int	    maxCost()	const	{ return mCost; }
+    int	    totalCost() const	{ return tCost; }
+    void    setMaxCost( int maxCost );
+    void    clear();
+
+    bool    insert_string( const TQString &key, TQPtrCollection::Item,
+			   int cost, int priority );
+    bool    insert_other( const char *key, TQPtrCollection::Item,
+			  int cost, int priority );
+    bool    remove_string( const TQString &key );
+    bool    remove_other( const char *key );
+    TQPtrCollection::Item take_string( const TQString &key );
+    TQPtrCollection::Item take_other( const char *key );
+
+    TQPtrCollection::Item tqfind_string( const TQString &key, bool ref=TRUE ) const;
+    TQPtrCollection::Item tqfind_other( const char *key, bool ref=TRUE ) const;
+
+    void    statistics() const;
+
+private:
+    bool    makeRoomFor( int cost, int priority = -1 );
+    KeyType keytype;
+    TQCList *lruList;
+    TQCDict *dict;
+    int	    mCost;
+    int	    tCost;
+    bool    copyk;
+};
+
+
+class TQ_EXPORT TQGCacheIterator			// generic cache iterator
+{
+protected:
+    TQGCacheIterator( const TQGCache & );
+    TQGCacheIterator( const TQGCacheIterator & );
+   ~TQGCacheIterator();
+    TQGCacheIterator &operator=( const TQGCacheIterator & );
+
+    uint	      count()   const;
+    bool	      atFirst() const;
+    bool	      atLast()  const;
+    TQPtrCollection::Item toFirst();
+    TQPtrCollection::Item toLast();
+
+    TQPtrCollection::Item get() const;
+    TQString	      getKeyString() const;
+    const char       *getKeyAscii()  const;
+    long	      getKeyInt()    const;
+
+    TQPtrCollection::Item operator()();
+    TQPtrCollection::Item operator++();
+    TQPtrCollection::Item operator+=( uint );
+    TQPtrCollection::Item operator--();
+    TQPtrCollection::Item operator-=( uint );
+
+protected:
+    TQCListIt *it;				// iterator on cache list
+};
+
+
+#endif // TQGCACHE_H
diff --git a/tqtinterface/qt4/src/tools/tqgdict.cpp b/tqtinterface/qt4/src/tools/tqgdict.cpp
new file mode 100644
index 0000000..c4c21d9
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqgdict.cpp
@@ -0,0 +1,1151 @@
+/****************************************************************************
+**
+** Implementation of TQGDict and TQGDictIterator classes
+**
+** Created : 920529
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "tqgdict.h"
+#include "tqptrlist.h"
+#include "tqstring.h"
+#include "tqdatastream.h"
+#include <ctype.h>
+
+/*!
+  \class TQGDict
+  \reentrant
+  \ingroup collection
+  \brief The TQGDict class is an internal class for implementing TQDict template classes.
+
+  \internal
+
+  TQGDict is a strictly internal class that acts as a base class for the
+  \link collection.html collection classes\endlink TQDict and TQIntDict.
+
+  TQGDict has some virtual functions that can be reimplemented to customize
+  the subclasses.
+  \list
+  \i read() reads a collection/dictionary item from a TQDataStream.
+  \i write() writes a collection/dictionary item to a TQDataStream.
+  \endlist
+  Normally, you do not have to reimplement any of these functions.
+*/
+
+static const int op_tqfind = 0;
+static const int op_insert = 1;
+static const int op_tqreplace = 2;
+
+
+class TQGDItList : public TQPtrList<TQGDictIterator>
+{
+public:
+    TQGDItList() : TQPtrList<TQGDictIterator>() {}
+    TQGDItList( const TQGDItList &list ) : TQPtrList<TQGDictIterator>(list) {}
+    ~TQGDItList() { clear(); }
+    TQGDItList &operator=(const TQGDItList &list)
+	{ return (TQGDItList&)TQPtrList<TQGDictIterator>::operator=(list); }
+};
+
+
+/*****************************************************************************
+  Default implementation of special and virtual functions
+ *****************************************************************************/
+
+/*!
+  Returns the hash key for \a key, when key is a string.
+*/
+
+int TQGDict::hashKeyString( const TQString &key )
+{
+#if defined(TQT_CHECK_NULL)
+    if ( key.isNull() )
+	qWarning( "TQGDict::hashKeyString: Invalid null key" );
+#endif
+    int i;
+    register uint h=0;
+    uint g;
+    const TQChar *p = key.tqunicode();
+    if ( cases ) {				// case sensitive
+	for ( i=0; i<(int)key.length(); i++ ) {
+	    h = (h<<4) + p[i].cell();
+	    if ( (g = h & 0xf0000000) )
+		h ^= g >> 24;
+	    h &= ~g;
+	}
+    } else {					// case insensitive
+	for ( i=0; i<(int)key.length(); i++ ) {
+	    h = (h<<4) + p[i].lower().cell();
+	    if ( (g = h & 0xf0000000) )
+		h ^= g >> 24;
+	    h &= ~g;
+	}
+    }
+    int index = h;
+    if ( index < 0 )				// adjust index to table size
+	index = -index;
+    return index;
+}
+
+/*!
+  Returns the hash key for \a key, which is a C string.
+*/
+
+int TQGDict::hashKeyAscii( const char *key )
+{
+#if defined(TQT_CHECK_NULL)
+    if ( key == 0 )
+	qWarning( "TQGDict::hashAsciiKey: Invalid null key" );
+#endif
+    register const char *k = key;
+    register uint h=0;
+    uint g;
+    if ( cases ) {				// case sensitive
+	while ( *k ) {
+	    h = (h<<4) + *k++;
+	    if ( (g = h & 0xf0000000) )
+		h ^= g >> 24;
+	    h &= ~g;
+	}
+    } else {					// case insensitive
+	while ( *k ) {
+	    h = (h<<4) + tolower((uchar) *k);
+	    if ( (g = h & 0xf0000000) )
+		h ^= g >> 24;
+	    h &= ~g;
+	    k++;
+	}
+    }
+    int index = h;
+    if ( index < 0 )				// adjust index to table size
+	index = -index;
+    return index;
+}
+
+#ifndef TQT_NO_DATASTREAM
+
+/*!
+    \overload
+  Reads a collection/dictionary item from the stream \a s and returns a
+  reference to the stream.
+
+  The default implementation sets \a item to 0.
+
+  \sa write()
+*/
+
+TQDataStream& TQGDict::read( TQDataStream &s, TQPtrCollection::Item &item )
+{
+    item = 0;
+    return s;
+}
+
+/*!
+    \overload
+  Writes a collection/dictionary item to the stream \a s and returns a
+  reference to the stream.
+
+  \sa read()
+*/
+
+TQDataStream& TQGDict::write( TQDataStream &s, TQPtrCollection::Item ) const
+{
+    return s;
+}
+#endif //TQT_NO_DATASTREAM
+
+/*****************************************************************************
+  TQGDict member functions
+ *****************************************************************************/
+
+/*!
+  Constructs a dictionary.
+
+  \a len is the initial size of the dictionary.
+  The key type is \a kt which may be \c StringKey, \c AsciiKey,
+  \c IntKey or \c PtrKey. The case-sensitivity of lookups is set with
+  \a caseSensitive. Keys are copied if \a copyKeys is TRUE.
+*/
+
+TQGDict::TQGDict( uint len, KeyType kt, bool caseSensitive, bool copyKeys )
+{
+    init( len, kt, caseSensitive, copyKeys );
+}
+
+
+void TQGDict::init( uint len, KeyType kt, bool caseSensitive, bool copyKeys )
+{
+    vlen = len ? len : 17;
+    vec = new TQBaseBucket *[ vlen ];
+
+    TQ_CHECK_PTR( vec );
+    memset( (char*)vec, 0, vlen*sizeof(TQBaseBucket*) );
+    numItems  = 0;
+    iterators = 0;
+    // The caseSensitive and copyKey options don't make sense for
+    // all dict types.
+    switch ( (keytype = (uint)kt) ) {
+	case StringKey:
+	    cases = caseSensitive;
+	    copyk = FALSE;
+	    break;
+	case AsciiKey:
+	    cases = caseSensitive;
+	    copyk = copyKeys;
+	    break;
+	default:
+	    cases = FALSE;
+	    copyk = FALSE;
+	    break;
+    }
+}
+
+
+/*!
+  Constructs a copy of \a dict.
+*/
+
+TQGDict::TQGDict( const TQGDict & dict )
+    : TQPtrCollection( dict )
+{
+    init( dict.vlen, (KeyType)dict.keytype, dict.cases, dict.copyk );
+    TQGDictIterator it( dict );
+    while ( it.get() ) {			// copy from other dict
+	switch ( keytype ) {
+	    case StringKey:
+		look_string( it.getKeyString(), it.get(), op_insert );
+		break;
+	    case AsciiKey:
+		look_ascii( it.getKeyAscii(), it.get(), op_insert );
+		break;
+	    case IntKey:
+		look_int( it.getKeyInt(), it.get(), op_insert );
+		break;
+	    case PtrKey:
+		look_ptr( it.getKeyPtr(), it.get(), op_insert );
+		break;
+	}
+	++it;
+    }
+}
+
+
+/*!
+  Removes all items from the dictionary and destroys it.
+*/
+
+TQGDict::~TQGDict()
+{
+    clear();					// delete everything
+    delete [] vec;
+    if ( !iterators )				// no iterators for this dict
+	return;
+    TQGDictIterator *i = iterators->first();
+    while ( i ) {				// notify all iterators that
+	i->dict = 0;				// this dict is deleted
+	i = iterators->next();
+    }
+    delete iterators;
+}
+
+
+/*!
+  Assigns \a dict to this dictionary.
+*/
+
+TQGDict &TQGDict::operator=( const TQGDict &dict )
+{
+    if ( &dict == this )
+	return *this;
+    clear();
+    TQGDictIterator it( dict );
+    while ( it.get() ) {			// copy from other dict
+	switch ( keytype ) {
+	    case StringKey:
+		look_string( it.getKeyString(), it.get(), op_insert );
+		break;
+	    case AsciiKey:
+		look_ascii( it.getKeyAscii(), it.get(), op_insert );
+		break;
+	    case IntKey:
+		look_int( it.getKeyInt(), it.get(), op_insert );
+		break;
+	    case PtrKey:
+		look_ptr( it.getKeyPtr(), it.get(), op_insert );
+		break;
+	}
+	++it;
+    }
+    return *this;
+}
+
+/*!
+  \fn uint TQGDict::count() const
+
+  Returns the number of items in the dictionary.
+*/
+
+/*!
+  \fn uint TQGDict::size() const
+
+  Returns the size of the hash array.
+*/
+
+/*!
+  The do-it-all function; \a op is one of op_tqfind, op_insert, op_tqreplace.
+  The key is \a key and the item is \a d.
+*/
+
+TQPtrCollection::Item TQGDict::look_string( const TQString &key, TQPtrCollection::Item d,
+				       int op )
+{
+    TQStringBucket *n = 0;
+    int	index = hashKeyString(key) % vlen;
+    if ( op == op_tqfind ) {			// tqfind
+	if ( cases ) {
+	    n = (TQStringBucket*)vec[index];
+	    while( n != 0 ) {
+		if ( key == n->getKey() )
+		    return n->getData();	// item found
+		n = (TQStringBucket*)n->getNext();
+	    }
+	} else {
+	    TQString k = key.lower();
+	    n = (TQStringBucket*)vec[index];
+	    while( n != 0 ) {
+		if ( k == n->getKey().lower() )
+		    return n->getData();	// item found
+		n = (TQStringBucket*)n->getNext();
+	    }
+	}
+	return 0;				// not found
+    }
+    if ( op == op_tqreplace ) {			// tqreplace
+	if ( vec[index] != 0 )			// maybe something there
+	    remove_string( key );
+    }
+    // op_insert or op_tqreplace
+    n = new TQStringBucket(key,newItem(d),vec[index]);
+    TQ_CHECK_PTR( n );
+#if defined(TQT_CHECK_NULL)
+    if ( n->getData() == 0 )
+	qWarning( "TQDict: Cannot insert null item" );
+#endif
+    vec[index] = n;
+    numItems++;
+    return n->getData();
+}
+
+TQPtrCollection::Item TQGDict::look_ascii( const char *key, TQPtrCollection::Item d, int op )
+{
+    TQAsciiBucket *n;
+    int	index = hashKeyAscii(key) % vlen;
+    if ( op == op_tqfind ) {			// tqfind
+	if ( cases ) {
+	    for ( n=(TQAsciiBucket*)vec[index]; n;
+		  n=(TQAsciiBucket*)n->getNext() ) {
+		if ( qstrcmp(n->getKey(),key) == 0 )
+		    return n->getData();	// item found
+	    }
+	} else {
+	    for ( n=(TQAsciiBucket*)vec[index]; n;
+		  n=(TQAsciiBucket*)n->getNext() ) {
+		if ( qstricmp(n->getKey(),key) == 0 )
+		    return n->getData();	// item found
+	    }
+	}
+	return 0;				// not found
+    }
+    if ( op == op_tqreplace ) {			// tqreplace
+	if ( vec[index] != 0 )			// maybe something there
+	    remove_ascii( key );
+    }
+    // op_insert or op_tqreplace
+    n = new TQAsciiBucket(copyk ? qstrdup(key) : key,newItem(d),vec[index]);
+    TQ_CHECK_PTR( n );
+#if defined(TQT_CHECK_NULL)
+    if ( n->getData() == 0 )
+	qWarning( "TQAsciiDict: Cannot insert null item" );
+#endif
+    vec[index] = n;
+    numItems++;
+    return n->getData();
+}
+
+TQPtrCollection::Item TQGDict::look_int( long key, TQPtrCollection::Item d, int op )
+{
+    TQIntBucket *n;
+    int index = (int)((ulong)key % vlen);	// simple hash
+    if ( op == op_tqfind ) {			// tqfind
+	for ( n=(TQIntBucket*)vec[index]; n;
+	      n=(TQIntBucket*)n->getNext() ) {
+	    if ( n->getKey() == key )
+		return n->getData();		// item found
+	}
+	return 0;				// not found
+    }
+    if ( op == op_tqreplace ) {			// tqreplace
+	if ( vec[index] != 0 )			// maybe something there
+	    remove_int( key );
+    }
+    // op_insert or op_tqreplace
+    n = new TQIntBucket(key,newItem(d),vec[index]);
+    TQ_CHECK_PTR( n );
+#if defined(TQT_CHECK_NULL)
+    if ( n->getData() == 0 )
+	qWarning( "TQIntDict: Cannot insert null item" );
+#endif
+    vec[index] = n;
+    numItems++;
+    return n->getData();
+}
+
+TQPtrCollection::Item TQGDict::look_ptr( void *key, TQPtrCollection::Item d, int op )
+{
+    TQPtrBucket *n;
+    int index = (int)((ulong)key % vlen);	// simple hash
+    if ( op == op_tqfind ) {			// tqfind
+	for ( n=(TQPtrBucket*)vec[index]; n;
+	      n=(TQPtrBucket*)n->getNext() ) {
+	    if ( n->getKey() == key )
+		return n->getData();		// item found
+	}
+	return 0;				// not found
+    }
+    if ( op == op_tqreplace ) {			// tqreplace
+	if ( vec[index] != 0 )			// maybe something there
+	    remove_ptr( key );
+    }
+    // op_insert or op_tqreplace
+    n = new TQPtrBucket(key,newItem(d),vec[index]);
+    TQ_CHECK_PTR( n );
+#if defined(TQT_CHECK_NULL)
+    if ( n->getData() == 0 )
+	qWarning( "TQPtrDict: Cannot insert null item" );
+#endif
+    vec[index] = n;
+    numItems++;
+    return n->getData();
+}
+
+
+/*!
+  Changes the size of the hashtable to \a newsize.
+  The contents of the dictionary are preserved,
+  but all iterators on the dictionary become invalid.
+*/
+void TQGDict::resize( uint newsize )
+{
+    // Save old information
+    TQBaseBucket **old_vec = vec;
+    uint old_vlen  = vlen;
+    bool old_copyk = copyk;
+
+    vec = new TQBaseBucket *[vlen = newsize];
+    TQ_CHECK_PTR( vec );
+    memset( (char*)vec, 0, vlen*sizeof(TQBaseBucket*) );
+    numItems = 0;
+    copyk = FALSE;
+
+    // Reinsert every item from vec, deleting vec as we go
+    for ( uint index = 0; index < old_vlen; index++ ) {
+	switch ( keytype ) {
+	    case StringKey:
+		{
+		    TQStringBucket *n=(TQStringBucket *)old_vec[index];
+		    while ( n ) {
+			look_string( n->getKey(), n->getData(), op_insert );
+			TQStringBucket *t=(TQStringBucket *)n->getNext();
+			delete n;
+			n = t;
+		    }
+		}
+		break;
+	    case AsciiKey:
+		{
+		    TQAsciiBucket *n=(TQAsciiBucket *)old_vec[index];
+		    while ( n ) {
+			look_ascii( n->getKey(), n->getData(), op_insert );
+			TQAsciiBucket *t=(TQAsciiBucket *)n->getNext();
+			delete n;
+			n = t;
+		    }
+		}
+		break;
+	    case IntKey:
+		{
+		    TQIntBucket *n=(TQIntBucket *)old_vec[index];
+		    while ( n ) {
+			look_int( n->getKey(), n->getData(), op_insert );
+			TQIntBucket *t=(TQIntBucket *)n->getNext();
+			delete n;
+			n = t;
+		    }
+		}
+		break;
+	    case PtrKey:
+		{
+		    TQPtrBucket *n=(TQPtrBucket *)old_vec[index];
+		    while ( n ) {
+			look_ptr( n->getKey(), n->getData(), op_insert );
+			TQPtrBucket *t=(TQPtrBucket *)n->getNext();
+			delete n;
+			n = t;
+		    }
+		}
+		break;
+	}
+    }
+    delete [] old_vec;
+
+    // Restore state
+    copyk = old_copyk;
+
+    // Invalidate all iterators, since order is lost
+    if ( iterators && iterators->count() ) {
+	TQGDictIterator *i = iterators->first();
+	while ( i ) {
+	    i->toFirst();
+	    i = iterators->next();
+	}
+    }
+}
+
+/*!
+  Unlinks the bucket with the specified key (and specified data pointer,
+  if it is set).
+*/
+
+void TQGDict::unlink_common( int index, TQBaseBucket *node, TQBaseBucket *prev )
+{
+    if ( iterators && iterators->count() ) {	// update iterators
+	TQGDictIterator *i = iterators->first();
+	while ( i ) {				// tqinvalidate all iterators
+	    if ( i->curNode == node )		// referring to pending node
+		i->operator++();
+	    i = iterators->next();
+	}
+    }
+    if ( prev )					// unlink node
+	prev->setNext( node->getNext() );
+    else
+	vec[index] = node->getNext();
+    numItems--;
+}
+
+TQStringBucket *TQGDict::unlink_string( const TQString &key, TQPtrCollection::Item d )
+{
+    if ( numItems == 0 )			// nothing in dictionary
+	return 0;
+    TQStringBucket *n;
+    TQStringBucket *prev = 0;
+    int index = hashKeyString(key) % vlen;
+    if ( cases ) {
+	for ( n=(TQStringBucket*)vec[index]; n;
+	      n=(TQStringBucket*)n->getNext() ) {
+	    bool found = (key == n->getKey());
+	    if ( found && d )
+		found = (n->getData() == d);
+	    if ( found ) {
+		unlink_common(index,n,prev);
+		return n;
+	    }
+	    prev = n;
+	}
+    } else {
+	TQString k = key.lower();
+	for ( n=(TQStringBucket*)vec[index]; n;
+	      n=(TQStringBucket*)n->getNext() ) {
+	    bool found = (k == n->getKey().lower());
+	    if ( found && d )
+		found = (n->getData() == d);
+	    if ( found ) {
+		unlink_common(index,n,prev);
+		return n;
+	    }
+	    prev = n;
+	}
+    }
+    return 0;
+}
+
+TQAsciiBucket *TQGDict::unlink_ascii( const char *key, TQPtrCollection::Item d )
+{
+    if ( numItems == 0 )			// nothing in dictionary
+	return 0;
+    TQAsciiBucket *n;
+    TQAsciiBucket *prev = 0;
+    int index = hashKeyAscii(key) % vlen;
+    for ( n=(TQAsciiBucket *)vec[index]; n; n=(TQAsciiBucket *)n->getNext() ) {
+	bool found = (cases ? qstrcmp(n->getKey(),key)
+		       : qstricmp(n->getKey(),key)) == 0;
+	if ( found && d )
+	    found = (n->getData() == d);
+	if ( found ) {
+	    unlink_common(index,n,prev);
+	    return n;
+	}
+	prev = n;
+    }
+    return 0;
+}
+
+TQIntBucket *TQGDict::unlink_int( long key, TQPtrCollection::Item d )
+{
+    if ( numItems == 0 )			// nothing in dictionary
+	return 0;
+    TQIntBucket *n;
+    TQIntBucket *prev = 0;
+    int index = (int)((ulong)key % vlen);
+    for ( n=(TQIntBucket *)vec[index]; n; n=(TQIntBucket *)n->getNext() ) {
+	bool found = (n->getKey() == key);
+	if ( found && d )
+	    found = (n->getData() == d);
+	if ( found ) {
+	    unlink_common(index,n,prev);
+	    return n;
+	}
+	prev = n;
+    }
+    return 0;
+}
+
+TQPtrBucket *TQGDict::unlink_ptr( void *key, TQPtrCollection::Item d )
+{
+    if ( numItems == 0 )			// nothing in dictionary
+	return 0;
+    TQPtrBucket *n;
+    TQPtrBucket *prev = 0;
+    int index = (int)((ulong)key % vlen);
+    for ( n=(TQPtrBucket *)vec[index]; n; n=(TQPtrBucket *)n->getNext() ) {
+	bool found = (n->getKey() == key);
+	if ( found && d )
+	    found = (n->getData() == d);
+	if ( found ) {
+	    unlink_common(index,n,prev);
+	    return n;
+	}
+	prev = n;
+    }
+    return 0;
+}
+
+
+/*!
+  Removes the item with the specified \a key.  If \a item is not null,
+  the remove will match the \a item as well (used to remove an
+  item when several items have the same key).
+*/
+
+bool TQGDict::remove_string( const TQString &key, TQPtrCollection::Item item )
+{
+    TQStringBucket *n = unlink_string( key, item );
+    if ( n ) {
+	deleteItem( n->getData() );
+	delete n;
+	return TRUE;
+    } else {
+	return FALSE;
+    }
+}
+
+bool TQGDict::remove_ascii( const char *key, TQPtrCollection::Item item )
+{
+    TQAsciiBucket *n = unlink_ascii( key, item );
+    if ( n ) {
+	if ( copyk )
+	    delete [] (char *)n->getKey();
+	deleteItem( n->getData() );
+	delete n;
+    }
+    return n != 0;
+}
+
+bool TQGDict::remove_int( long key, TQPtrCollection::Item item )
+{
+    TQIntBucket *n = unlink_int( key, item );
+    if ( n ) {
+	deleteItem( n->getData() );
+	delete n;
+    }
+    return n != 0;
+}
+
+bool TQGDict::remove_ptr( void *key, TQPtrCollection::Item item )
+{
+    TQPtrBucket *n = unlink_ptr( key, item );
+    if ( n ) {
+	deleteItem( n->getData() );
+	delete n;
+    }
+    return n != 0;
+}
+
+TQPtrCollection::Item TQGDict::take_string( const TQString &key )
+{
+    TQStringBucket *n = unlink_string( key );
+    Item d;
+    if ( n ) {
+	d = n->getData();
+	delete n;
+    } else {
+	d = 0;
+    }
+    return d;
+}
+
+TQPtrCollection::Item TQGDict::take_ascii( const char *key )
+{
+    TQAsciiBucket *n = unlink_ascii( key );
+    Item d;
+    if ( n ) {
+	if ( copyk )
+	    delete [] (char *)n->getKey();
+	d = n->getData();
+	delete n;
+    } else {
+	d = 0;
+    }
+    return d;
+}
+
+TQPtrCollection::Item TQGDict::take_int( long key )
+{
+    TQIntBucket *n = unlink_int( key );
+    Item d;
+    if ( n ) {
+	d = n->getData();
+	delete n;
+    } else {
+	d = 0;
+    }
+    return d;
+}
+
+TQPtrCollection::Item TQGDict::take_ptr( void *key )
+{
+    TQPtrBucket *n = unlink_ptr( key );
+    Item d;
+    if ( n ) {
+	d = n->getData();
+	delete n;
+    } else {
+	d = 0;
+    }
+    return d;
+}
+
+/*!
+  Removes all items from the dictionary.
+*/
+void TQGDict::clear()
+{
+    if ( !numItems )
+	return;
+    numItems = 0;				// disable remove() function
+    for ( uint j=0; j<vlen; j++ ) {		// destroy hash table
+	if ( vec[j] ) {
+	    switch ( keytype ) {
+		case StringKey:
+		    {
+			TQStringBucket *n=(TQStringBucket *)vec[j];
+			while ( n ) {
+			    TQStringBucket *next = (TQStringBucket*)n->getNext();
+			    deleteItem( n->getData() );
+			    delete n;
+			    n = next;
+			}
+		    }
+		    break;
+		case AsciiKey:
+		    {
+			TQAsciiBucket *n=(TQAsciiBucket *)vec[j];
+			while ( n ) {
+			    TQAsciiBucket *next = (TQAsciiBucket*)n->getNext();
+			    if ( copyk )
+				delete [] (char *)n->getKey();
+			    deleteItem( n->getData() );
+			    delete n;
+			    n = next;
+			}
+		    }
+		    break;
+		case IntKey:
+		    {
+			TQIntBucket *n=(TQIntBucket *)vec[j];
+			while ( n ) {
+			    TQIntBucket *next = (TQIntBucket*)n->getNext();
+			    deleteItem( n->getData() );
+			    delete n;
+			    n = next;
+			}
+		    }
+		    break;
+		case PtrKey:
+		    {
+			TQPtrBucket *n=(TQPtrBucket *)vec[j];
+			while ( n ) {
+			    TQPtrBucket *next = (TQPtrBucket*)n->getNext();
+			    deleteItem( n->getData() );
+			    delete n;
+			    n = next;
+			}
+		    }
+		    break;
+	    }
+	    vec[j] = 0;				// detach list of buckets
+	}
+    }
+    if ( iterators && iterators->count() ) {	// tqinvalidate all iterators
+	TQGDictIterator *i = iterators->first();
+	while ( i ) {
+	    i->curNode = 0;
+	    i = iterators->next();
+	}
+    }
+}
+
+/*!
+  Outputs debug statistics.
+*/
+void TQGDict::statistics() const
+{
+#if defined(TQT_DEBUG)
+    TQString line;
+    line.fill( '-', 60 );
+    double real, ideal;
+    qDebug( line.ascii() );
+    qDebug( "DICTIONARY STATISTICS:" );
+    if ( count() == 0 ) {
+	qDebug( "Empty!" );
+	qDebug( line.ascii() );
+	return;
+    }
+    real = 0.0;
+    ideal = (float)count()/(2.0*size())*(count()+2.0*size()-1);
+    uint i = 0;
+    while ( i<size() ) {
+	TQBaseBucket *n = vec[i];
+	int b = 0;
+	while ( n ) {				// count number of buckets
+	    b++;
+	    n = n->getNext();
+	}
+	real = real + (double)b * ((double)b+1.0)/2.0;
+	char buf[80], *pbuf;
+	if ( b > 78 )
+	    b = 78;
+	pbuf = buf;
+	while ( b-- )
+	    *pbuf++ = '*';
+	*pbuf = '\0';
+	qDebug( buf );
+	i++;
+    }
+    qDebug( "Array size = %d", size() );
+    qDebug( "# items    = %d", count() );
+    qDebug( "Real dist  = %g", real );
+    qDebug( "Rand dist  = %g", ideal );
+    qDebug( "Real/Rand  = %g", real/ideal );
+    qDebug( line.ascii() );
+#endif // TQT_DEBUG
+}
+
+
+/*****************************************************************************
+  TQGDict stream functions
+ *****************************************************************************/
+#ifndef TQT_NO_DATASTREAM
+TQDataStream &operator>>( TQDataStream &s, TQGDict &dict )
+{
+    return dict.read( s );
+}
+
+TQDataStream &operator<<( TQDataStream &s, const TQGDict &dict )
+{
+    return dict.write( s );
+}
+
+#if defined(TQ_CC_DEC) && defined(__alpha) && (__DECCXX_VER-0 >= 50190001)
+#pragma message disable narrowptr
+#endif
+
+/*!
+  Reads a dictionary from the stream \a s.
+*/
+
+TQDataStream &TQGDict::read( TQDataStream &s )
+{
+    uint num;
+    s >> num;					// read number of items
+    clear();					// clear dict
+    while ( num-- ) {				// read all items
+	Item d;
+	switch ( keytype ) {
+	    case StringKey:
+		{
+		    TQString k;
+		    s >> k;
+		    read( s, d );
+		    look_string( k, d, op_insert );
+		}
+		break;
+	    case AsciiKey:
+		{
+		    char *k;
+		    s >> k;
+		    read( s, d );
+		    look_ascii( k, d, op_insert );
+		    if ( copyk )
+			delete [] k;
+		}
+		break;
+	    case IntKey:
+		{
+		    TQ_UINT32 k;
+		    s >> k;
+		    read( s, d );
+		    look_int( k, d, op_insert );
+		}
+		break;
+	    case PtrKey:
+		{
+		    TQ_UINT32 k;
+		    s >> k;
+		    read( s, d );
+		    // ### cannot insert 0 - this renders the thing
+		    // useless since all pointers are written as 0,
+		    // but hey, serializing pointers?  can it be done
+		    // at all, ever?
+		    if ( k )
+			look_ptr( (void *)k, d, op_insert );
+		}
+		break;
+	}
+    }
+    return s;
+}
+
+/*!
+  Writes the dictionary to the stream \a s.
+*/
+
+TQDataStream& TQGDict::write( TQDataStream &s ) const
+{
+    s << count();				// write number of items
+    uint i = 0;
+    while ( i<size() ) {
+	TQBaseBucket *n = vec[i];
+	while ( n ) {				// write all buckets
+	    switch ( keytype ) {
+		case StringKey:
+		    s << ((TQStringBucket*)n)->getKey();
+		    break;
+		case AsciiKey:
+		    s << ((TQAsciiBucket*)n)->getKey();
+		    break;
+		case IntKey:
+		    s << (TQ_UINT32)((TQIntBucket*)n)->getKey();
+		    break;
+		case PtrKey:
+		    s << (TQ_UINT32)0; // ### cannot serialize a pointer
+		    break;
+	    }
+	    write( s, n->getData() );		// write data
+	    n = n->getNext();
+	}
+	i++;
+    }
+    return s;
+}
+#endif //TQT_NO_DATASTREAM
+
+/*****************************************************************************
+  TQGDictIterator member functions
+ *****************************************************************************/
+
+/*!
+  \class TQGDictIterator tqgdict.h
+  \reentrant
+  \ingroup collection
+  \brief The TQGDictIterator class is an internal class for implementing TQDictIterator and TQIntDictIterator.
+
+  \internal
+
+  TQGDictIterator is a strictly internal class that does the heavy work for
+  TQDictIterator and TQIntDictIterator.
+*/
+
+/*!
+  Constructs an iterator that operates on the dictionary \a d.
+*/
+
+TQGDictIterator::TQGDictIterator( const TQGDict &d )
+{
+    dict = (TQGDict *)&d;			// get reference to dict
+    toFirst();					// set to first noe
+    if ( !dict->iterators ) {
+	dict->iterators = new TQGDItList;	// create iterator list
+	TQ_CHECK_PTR( dict->iterators );
+    }
+    dict->iterators->append( this );		// attach iterator to dict
+}
+
+/*!
+  Constructs a copy of the iterator \a it.
+*/
+
+TQGDictIterator::TQGDictIterator( const TQGDictIterator &it )
+{
+    dict = it.dict;
+    curNode = it.curNode;
+    curIndex = it.curIndex;
+    if ( dict )
+	dict->iterators->append( this );	// attach iterator to dict
+}
+
+/*!
+  Assigns a copy of the iterator \a it and returns a reference to this
+  iterator.
+*/
+
+TQGDictIterator &TQGDictIterator::operator=( const TQGDictIterator &it )
+{
+    if ( dict )					// detach from old dict
+	dict->iterators->removeRef( this );
+    dict = it.dict;
+    curNode = it.curNode;
+    curIndex = it.curIndex;
+    if ( dict )
+	dict->iterators->append( this );	// attach to new list
+    return *this;
+}
+
+/*!
+  Destroys the iterator.
+*/
+
+TQGDictIterator::~TQGDictIterator()
+{
+    if ( dict )					// detach iterator from dict
+	dict->iterators->removeRef( this );
+}
+
+
+/*!
+  Sets the iterator to point to the first item in the dictionary.
+*/
+
+TQPtrCollection::Item TQGDictIterator::toFirst()
+{
+    if ( !dict ) {
+#if defined(TQT_CHECK_NULL)
+	qWarning( "TQGDictIterator::toFirst: Dictionary has been deleted" );
+#endif
+	return 0;
+    }
+    if ( dict->count() == 0 ) {			// empty dictionary
+	curNode = 0;
+	return 0;
+    }
+    register uint i = 0;
+    register TQBaseBucket **v = dict->vec;
+    while ( !(*v++) )
+	i++;
+    curNode = dict->vec[i];
+    curIndex = i;
+    return curNode->getData();
+}
+
+
+/*!
+  Moves to the next item (postfix).
+*/
+
+TQPtrCollection::Item TQGDictIterator::operator()()
+{
+    if ( !dict ) {
+#if defined(TQT_CHECK_NULL)
+	qWarning( "TQGDictIterator::operator(): Dictionary has been deleted" );
+#endif
+	return 0;
+    }
+    if ( !curNode )
+	return 0;
+    TQPtrCollection::Item d = curNode->getData();
+    this->operator++();
+    return d;
+}
+
+/*!
+  Moves to the next item (prefix).
+*/
+
+TQPtrCollection::Item TQGDictIterator::operator++()
+{
+    if ( !dict ) {
+#if defined(TQT_CHECK_NULL)
+	qWarning( "TQGDictIterator::operator++: Dictionary has been deleted" );
+#endif
+	return 0;
+    }
+    if ( !curNode )
+	return 0;
+    curNode = curNode->getNext();
+    if ( !curNode ) {				// no next bucket
+	register uint i = curIndex + 1;		// look from next vec element
+	register TQBaseBucket **v = &dict->vec[i];
+	while ( i < dict->size() && !(*v++) )
+	    i++;
+	if ( i == dict->size() ) {		// nothing found
+	    curNode = 0;
+	    return 0;
+	}
+	curNode = dict->vec[i];
+	curIndex = i;
+    }
+    return curNode->getData();
+}
+
+/*!
+  Moves \a jumps positions forward.
+*/
+
+TQPtrCollection::Item TQGDictIterator::operator+=( uint jumps )
+{
+    while ( curNode && jumps-- )
+	operator++();
+    return curNode ? curNode->getData() : 0;
+}
diff --git a/tqtinterface/qt4/src/tools/tqgdict.h b/tqtinterface/qt4/src/tools/tqgdict.h
new file mode 100644
index 0000000..d9bd543
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqgdict.h
@@ -0,0 +1,225 @@
+/****************************************************************************
+**
+** Definition of TQGDict and TQGDictIterator classes
+**
+** Created : 920529
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQGDICT_H
+#define TQGDICT_H
+
+#ifndef TQT_H
+#include "tqptrcollection.h"
+#include "tqstring.h"
+#endif // TQT_H
+
+class TQGDictIterator;
+class TQGDItList;
+
+
+class TQBaseBucket				// internal dict node
+{
+public:
+    TQPtrCollection::Item	 getData()			{ return data; }
+    TQPtrCollection::Item	 setData( TQPtrCollection::Item d ) { return data = d; }
+    TQBaseBucket		*getNext()			{ return next; }
+    void		 setNext( TQBaseBucket *n)	{ next = n; }
+protected:
+    TQBaseBucket( TQPtrCollection::Item d, TQBaseBucket *n ) : data(d), next(n) {}
+    TQPtrCollection::Item	 data;
+    TQBaseBucket		*next;
+};
+
+class TQStringBucket : public TQBaseBucket
+{
+public:
+    TQStringBucket( const TQString &k, TQPtrCollection::Item d, TQBaseBucket *n )
+	: TQBaseBucket(d,n), key(k)		{}
+    const TQString  &getKey() const		{ return key; }
+private:
+    TQString	    key;
+};
+
+class TQAsciiBucket : public TQBaseBucket
+{
+public:
+    TQAsciiBucket( const char *k, TQPtrCollection::Item d, TQBaseBucket *n )
+	: TQBaseBucket(d,n), key(k) {}
+    const char *getKey() const { return key; }
+private:
+    const char *key;
+};
+
+class TQIntBucket : public TQBaseBucket
+{
+public:
+    TQIntBucket( long k, TQPtrCollection::Item d, TQBaseBucket *n )
+	: TQBaseBucket(d,n), key(k) {}
+    long  getKey() const { return key; }
+private:
+    long  key;
+};
+
+class TQPtrBucket : public TQBaseBucket
+{
+public:
+    TQPtrBucket( void *k, TQPtrCollection::Item d, TQBaseBucket *n )
+	: TQBaseBucket(d,n), key(k) {}
+    void *getKey() const { return key; }
+private:
+    void *key;
+};
+
+
+class TQ_EXPORT TQGDict : public TQPtrCollection	// generic dictionary class
+{
+public:
+    uint	count() const	{ return numItems; }
+    uint	size()	const	{ return vlen; }
+    TQPtrCollection::Item look_string( const TQString& key, TQPtrCollection::Item,
+				   int );
+    TQPtrCollection::Item look_ascii( const char *key, TQPtrCollection::Item, int );
+    TQPtrCollection::Item look_int( long key, TQPtrCollection::Item, int );
+    TQPtrCollection::Item look_ptr( void *key, TQPtrCollection::Item, int );
+#ifndef TQT_NO_DATASTREAM
+    TQDataStream &read( TQDataStream & );
+    TQDataStream &write( TQDataStream & ) const;
+#endif
+protected:
+    enum KeyType { StringKey, AsciiKey, IntKey, PtrKey };
+
+    TQGDict( uint len, KeyType kt, bool cs, bool ck );
+    TQGDict( const TQGDict & );
+   ~TQGDict();
+
+    TQGDict     &operator=( const TQGDict & );
+
+    bool	remove_string( const TQString &key, TQPtrCollection::Item item=0 );
+    bool	remove_ascii( const char *key, TQPtrCollection::Item item=0 );
+    bool	remove_int( long key, TQPtrCollection::Item item=0 );
+    bool	remove_ptr( void *key, TQPtrCollection::Item item=0 );
+    TQPtrCollection::Item take_string( const TQString &key );
+    TQPtrCollection::Item take_ascii( const char *key );
+    TQPtrCollection::Item take_int( long key );
+    TQPtrCollection::Item take_ptr( void *key );
+
+    void	clear();
+    void	resize( uint );
+
+    int		hashKeyString( const TQString & );
+    int		hashKeyAscii( const char * );
+
+    void	statistics() const;
+
+#ifndef TQT_NO_DATASTREAM
+    virtual TQDataStream &read( TQDataStream &, TQPtrCollection::Item & );
+    virtual TQDataStream &write( TQDataStream &, TQPtrCollection::Item ) const;
+#endif
+private:
+    TQBaseBucket **vec;
+    uint	vlen;
+    uint	numItems;
+    uint	keytype	: 2;
+    uint	cases	: 1;
+    uint	copyk	: 1;
+    TQGDItList  *iterators;
+    void	   unlink_common( int, TQBaseBucket *, TQBaseBucket * );
+    TQStringBucket *unlink_string( const TQString &,
+				  TQPtrCollection::Item item = 0 );
+    TQAsciiBucket  *unlink_ascii( const char *, TQPtrCollection::Item item = 0 );
+    TQIntBucket    *unlink_int( long, TQPtrCollection::Item item = 0 );
+    TQPtrBucket    *unlink_ptr( void *, TQPtrCollection::Item item = 0 );
+    void	init( uint, KeyType, bool, bool );
+    friend class TQGDictIterator;
+};
+
+
+class TQ_EXPORT TQGDictIterator			// generic dictionary iterator
+{
+friend class TQGDict;
+public:
+    TQGDictIterator( const TQGDict & );
+    TQGDictIterator( const TQGDictIterator & );
+    TQGDictIterator &operator=( const TQGDictIterator & );
+   ~TQGDictIterator();
+
+    TQPtrCollection::Item toFirst();
+
+    TQPtrCollection::Item get()	     const;
+    TQString	      getKeyString() const;
+    const char	     *getKeyAscii()  const;
+    long	      getKeyInt()    const;
+    void	     *getKeyPtr()    const;
+
+    TQPtrCollection::Item operator()();
+    TQPtrCollection::Item operator++();
+    TQPtrCollection::Item operator+=(uint);
+
+protected:
+    TQGDict	     *dict;
+
+private:
+    TQBaseBucket      *curNode;
+    uint	      curIndex;
+};
+
+inline TQPtrCollection::Item TQGDictIterator::get() const
+{
+    return curNode ? curNode->getData() : 0;
+}
+
+inline TQString TQGDictIterator::getKeyString() const
+{
+    return curNode ? ((TQStringBucket*)curNode)->getKey() : TQString::null;
+}
+
+inline const char *TQGDictIterator::getKeyAscii() const
+{
+    return curNode ? ((TQAsciiBucket*)curNode)->getKey() : 0;
+}
+
+inline long TQGDictIterator::getKeyInt() const
+{
+    return curNode ? ((TQIntBucket*)curNode)->getKey() : 0;
+}
+
+inline void *TQGDictIterator::getKeyPtr() const
+{
+    return curNode ? ((TQPtrBucket*)curNode)->getKey() : 0;
+}
+
+
+#endif // TQGDICT_H
diff --git a/tqtinterface/qt4/src/tools/tqgeneric.h b/tqtinterface/qt4/src/tools/tqgeneric.h
new file mode 100644
index 0000000..9ab0d6f
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqgeneric.h
@@ -0,0 +1,46 @@
+/****************************************************************************
+**
+** Macros for pasting tokens; utilized by our generic classes
+**
+** Created : 920529
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQGENERIC_H
+#define TQGENERIC_H
+
+#error "do not include tqgeneric.h any more"
+
+#endif // TQGENERIC_H
diff --git a/tqtinterface/qt4/src/tools/tqglist.cpp b/tqtinterface/qt4/src/tools/tqglist.cpp
new file mode 100644
index 0000000..944c27c
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqglist.cpp
@@ -0,0 +1,1267 @@
+/****************************************************************************
+**
+** Implementation of TQGList and TQGListIterator classes
+**
+** Created : 920624
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "tqglist.h"
+#include "tqgvector.h"
+#include "tqdatastream.h"
+#include "tqvaluelist.h"
+
+/*!
+  \class TQLNode tqglist.h
+  \reentrant
+  \ingroup collection
+  \brief The TQLNode class is an internal class for the TQPtrList template collection.
+
+  \internal
+
+  TQLNode is a doubly-linked list node. It has three pointers:
+  \list 1
+  \i Pointer to the previous node.
+  \i Pointer to the next node.
+  \i Pointer to the actual data.
+  \endlist
+
+  It might sometimes be practical to have direct access to the list nodes
+  in a TQPtrList, but it is seldom required.
+
+  Be very careful if you want to access the list nodes. The heap can
+  easily get corrupted if you make a mistake.
+
+  \sa TQPtrList::currentNode(), TQPtrList::removeNode(), TQPtrList::takeNode()
+*/
+
+/*!
+  \fn TQPtrCollection::Item TQLNode::getData()
+  Returns a pointer (\c void*) to the actual data in the list node.
+*/
+
+
+/*!
+  \class TQGList tqglist.h
+  \reentrant
+  \ingroup collection
+  \brief The TQGList class is an internal class for implementing TQt collection classes.
+
+  \internal
+
+  TQGList is a strictly internal class that acts as a base class for
+  several collection classes; TQPtrList, TQPtrQueue and TQPtrStack.
+
+  TQGList has some virtual functions that can be reimplemented to
+  customize the subclasses, namely compareItems(), read() and
+  write. Normally, you do not have to reimplement any of these
+  functions.  If you still want to reimplement them, see the TQStrList
+  class (tqstrlist.h) for an example.
+*/
+
+
+/* Internal helper class for TQGList. Contains some optimization for
+   the typically case where only one iterators is activre on the list.
+ */
+class TQGListIteratorList
+{
+public:
+    TQGListIteratorList()
+	: list(0), iterator(0) {
+    }
+    ~TQGListIteratorList() {
+	notifyClear( TRUE );
+	delete list;
+    }
+
+    void add( TQGListIterator* i ) {
+	if ( !iterator ) {
+	    iterator = i;
+	} else if ( list ) {
+	    list->push_front( i );
+	} else {
+	    list = new TQValueList<TQGListIterator*>;
+	    list->push_front( i );
+	}
+    }
+
+    void remove( TQGListIterator* i ) {
+	if ( iterator == i ) {
+	    iterator = 0;
+	} else if ( list ) {
+	    list->remove( i );
+	    if ( list->isEmpty() ) {
+		delete list;
+		list = 0;
+	    }
+	}
+    }
+
+    void notifyClear( bool zeroList ) {
+	if ( iterator ) {
+	    if ( zeroList )
+		iterator->list = 0;
+	    iterator->curNode = 0;
+	}
+	if ( list ) {
+	    for ( TQValueList<TQGListIterator*>::Iterator i = list->begin(); i != list->end(); ++i ) {
+		if ( zeroList )
+		    (*i)->list = 0;
+		(*i)->curNode = 0;
+	    }
+	}
+    }
+
+    void notifyRemove( TQLNode* n, TQLNode* curNode ) {
+	if ( iterator ) {
+	    if ( iterator->curNode == n )
+		iterator->curNode = curNode;
+	}
+	if ( list ) {
+	    for ( TQValueList<TQGListIterator*>::Iterator i = list->begin(); i != list->end(); ++i ) {
+		if ( (*i)->curNode == n )
+		    (*i)->curNode = curNode;
+	    }
+	}
+    }
+
+private:
+    TQValueList<TQGListIterator*>* list;
+    TQGListIterator* iterator;
+};
+
+
+
+/*****************************************************************************
+  Default implementation of virtual functions
+ *****************************************************************************/
+
+/*!
+  Documented as TQPtrList::compareItems().
+
+  Compares \a item1 with \a item2.
+*/
+int TQGList::compareItems( TQPtrCollection::Item item1, TQPtrCollection::Item item2 )
+{
+    return item1 != item2;			// compare pointers
+}
+
+#ifndef TQT_NO_DATASTREAM
+/*!
+    \overload
+  Reads a collection/list item from the stream \a s and returns a reference
+  to the stream.
+
+  The default implementation sets \a item to 0.
+
+  \sa write()
+*/
+
+TQDataStream &TQGList::read( TQDataStream &s, TQPtrCollection::Item &item )
+{
+    item = 0;
+    return s;
+}
+
+/*!
+    \overload
+  Writes a collection/list item to the stream \a s and
+  returns a reference to the stream.
+
+  The default implementation does nothing.
+
+  \sa read()
+*/
+
+TQDataStream &TQGList::write( TQDataStream &s, TQPtrCollection::Item ) const
+{
+    return s;
+}
+#endif // TQT_NO_DATASTREAM
+
+/*****************************************************************************
+  TQGList member functions
+ *****************************************************************************/
+
+/*!
+  Constructs an empty list.
+*/
+
+TQGList::TQGList()
+{
+    firstNode = lastNode = curNode = 0;		// initialize list
+    numNodes  = 0;
+    curIndex  = -1;
+    iterators = 0;				// initialize iterator list
+}
+
+/*!
+  Constructs a copy of \a list.
+*/
+
+TQGList::TQGList( const TQGList & list )
+    : TQPtrCollection( list )
+{
+    firstNode = lastNode = curNode = 0;		// initialize list
+    numNodes  = 0;
+    curIndex  = -1;
+    iterators = 0;				// initialize iterator list
+    TQLNode *n = list.firstNode;
+    while ( n ) {				// copy all items from list
+	append( n->data );
+	n = n->next;
+    }
+}
+
+/*!
+  Removes all items from the list and destroys the list.
+*/
+
+TQGList::~TQGList()
+{
+    clear();
+    delete iterators;
+    // Workaround for GCC 2.7.* bug. Compiler constructs 'static' TQGList
+    // instances twice on the same address and therefore tries to destruct
+    // twice on the same address! This is insane but let's try not to crash
+    // here.
+    iterators = 0;
+}
+
+
+/*!
+  Assigns \a list to this list.
+*/
+
+TQGList& TQGList::operator=( const TQGList &list )
+{
+    if ( &list == this )
+	return *this;
+
+    clear();
+    if ( list.count() > 0 ) {
+	TQLNode *n = list.firstNode;
+	while ( n ) {				// copy all items from list
+	    append( n->data );
+	    n = n->next;
+	}
+	curNode	 = firstNode;
+	curIndex = 0;
+    }
+    return *this;
+}
+
+/*!
+  Compares this list with \a list. Returns TRUE if the lists
+  contain the same data, otherwise FALSE.
+*/
+
+bool TQGList::operator==( const TQGList &list ) const
+{
+    if ( count() != list.count() )
+	return FALSE;
+
+    if ( count() == 0 )
+	return TRUE;
+
+    TQLNode *n1 = firstNode;
+    TQLNode *n2 = list.firstNode;
+    while ( n1 && n2 ) {
+	// should be mutable
+	if ( ( (TQGList*)this )->compareItems( n1->data, n2->data ) != 0 )
+	    return FALSE;
+	n1 = n1->next;
+	n2 = n2->next;
+    }
+
+    return TRUE;
+}
+
+/*!
+  \fn uint TQGList::count() const
+
+  Returns the number of items in the list.
+*/
+
+
+/*!
+  Returns the node at position \a index.  Sets this node to current.
+*/
+
+TQLNode *TQGList::locate( uint index )
+{
+    if ( index == (uint)curIndex )		// current node ?
+	return curNode;
+    if ( !curNode && firstNode ) {		// set current node
+	curNode	 = firstNode;
+	curIndex = 0;
+    }
+    register TQLNode *node;
+    int	 distance = index - curIndex;		// node distance to cur node
+    bool forward;				// direction to traverse
+
+    if ( index >= numNodes )
+	return 0;
+
+    if ( distance < 0 )
+	distance = -distance;
+    if ( (uint)distance < index && (uint)distance < numNodes - index ) {
+	node =	curNode;			// start from current node
+	forward = index > (uint)curIndex;
+    } else if ( index < numNodes - index ) {	// start from first node
+	node = firstNode;
+	distance = index;
+	forward = TRUE;
+    } else {					// start from last node
+	node = lastNode;
+	distance = numNodes - index - 1;
+	if ( distance < 0 )
+	    distance = 0;
+	forward = FALSE;
+    }
+    if ( forward ) {				// now run through nodes
+	while ( distance-- )
+	    node = node->next;
+    } else {
+	while ( distance-- )
+	    node = node->prev;
+    }
+    curIndex = index;				// must update index
+    return curNode = node;
+}
+
+
+/*!
+  Inserts item \a d at its sorted position in the list.
+*/
+
+void TQGList::inSort( TQPtrCollection::Item d )
+{
+    int index = 0;
+    register TQLNode *n = firstNode;
+    while ( n && compareItems(n->data,d) < 0 ){ // tqfind position in list
+	n = n->next;
+	index++;
+    }
+    insertAt( index, d );
+}
+
+
+/*!
+  Inserts item \a d at the start of the list.
+*/
+
+void TQGList::prepend( TQPtrCollection::Item d )
+{
+    register TQLNode *n = new TQLNode( newItem(d) );
+    TQ_CHECK_PTR( n );
+    n->prev = 0;
+    if ( (n->next = firstNode) )		// list is not empty
+	firstNode->prev = n;
+    else					// initialize list
+	lastNode = n;
+    firstNode = curNode = n;			// curNode affected
+    numNodes++;
+    curIndex = 0;
+}
+
+
+/*!
+  Inserts item \a d at the end of the list.
+*/
+
+void TQGList::append( TQPtrCollection::Item d )
+{
+    register TQLNode *n = new TQLNode( newItem(d) );
+    TQ_CHECK_PTR( n );
+    n->next = 0;
+    if ( (n->prev = lastNode) )			// list is not empty
+	lastNode->next = n;
+    else					// initialize list
+	firstNode = n;
+    lastNode = curNode = n;			// curNode affected
+    curIndex = numNodes;
+    numNodes++;
+}
+
+
+/*!
+  Inserts item \a d at position \a index in the list.
+*/
+
+bool TQGList::insertAt( uint index, TQPtrCollection::Item d )
+{
+    if ( index == 0 ) {
+	prepend( d );
+	return TRUE;
+    } else if ( index == numNodes ) {
+	append( d );
+	return TRUE;
+    }
+    TQLNode *nextNode = locate( index );
+    if ( !nextNode )
+	return FALSE;
+    TQLNode *prevNode = nextNode->prev;
+    register TQLNode *n = new TQLNode( newItem(d) );
+    TQ_CHECK_PTR( n );
+    nextNode->prev = n;
+    prevNode->next = n;
+    n->prev = prevNode;				// link new node into list
+    n->next = nextNode;
+    curNode = n;				// curIndex set by locate()
+    numNodes++;
+    return TRUE;
+}
+
+
+/*!
+  Relinks node \a n and makes it the first node in the list.
+*/
+
+void TQGList::relinkNode( TQLNode *n )
+{
+    if ( n == firstNode )			// already first
+	return;
+    curNode = n;
+    unlink();
+    n->prev = 0;
+    if ( (n->next = firstNode) )		// list is not empty
+	firstNode->prev = n;
+    else					// initialize list
+	lastNode = n;
+    firstNode = curNode = n;			// curNode affected
+    numNodes++;
+    curIndex = 0;
+}
+
+
+/*!
+  Unlinks the current list node and returns a pointer to this node.
+*/
+
+TQLNode *TQGList::unlink()
+{
+    if ( curNode == 0 )				// null current node
+	return 0;
+    register TQLNode *n = curNode;		// unlink this node
+    if ( n == firstNode ) {			// removing first node ?
+	if ( (firstNode = n->next) ) {
+	    firstNode->prev = 0;
+	} else {
+	    lastNode = curNode = 0;		// list becomes empty
+	    curIndex = -1;
+	}
+    } else {
+	if ( n == lastNode ) {			// removing last node ?
+	    lastNode = n->prev;
+	    lastNode->next = 0;
+	} else {				// neither last nor first node
+	    n->prev->next = n->next;
+	    n->next->prev = n->prev;
+	}
+    }
+
+    if ( n->next ) {                            // change current node
+        curNode = n->next;
+    } else if ( n->prev ) {
+        curNode = n->prev;
+        curIndex--;
+    }
+
+    if ( iterators )
+	iterators->notifyRemove( n, curNode );
+    numNodes--;
+    return n;
+}
+
+
+/*!
+  Removes the node \a n from the list.
+*/
+
+bool TQGList::removeNode( TQLNode *n )
+{
+#if defined(TQT_CHECK_NULL)
+    if ( n == 0 || (n->prev && n->prev->next != n) ||
+	 (n->next && n->next->prev != n) ) {
+	qWarning( "TQGList::removeNode: Corrupted node" );
+	return FALSE;
+    }
+#endif
+    curNode = n;
+    unlink();					// unlink node
+    deleteItem( n->data );			// deallocate this node
+    delete n;
+    curNode  = firstNode;
+    curIndex = curNode ? 0 : -1;
+    return TRUE;
+}
+
+/*!
+  Removes the item \a d from the list.	Uses compareItems() to tqfind the item.
+
+  If \a d is 0, removes the current item.
+*/
+
+bool TQGList::remove( TQPtrCollection::Item d )
+{
+    if ( d && tqfind(d) == -1 )
+	return FALSE;
+    TQLNode *n = unlink();
+    if ( !n )
+	return FALSE;
+    deleteItem( n->data );
+    delete n;
+    return TRUE;
+}
+
+/*!
+  Removes the item \a d from the list.
+*/
+
+bool TQGList::removeRef( TQPtrCollection::Item d )
+{
+    if ( tqfindRef(d) == -1 )
+	return FALSE;
+    TQLNode *n = unlink();
+    if ( !n )
+	return FALSE;
+    deleteItem( n->data );
+    delete n;
+    return TRUE;
+}
+
+/*!
+  \fn bool TQGList::removeFirst()
+
+  Removes the first item in the list.
+*/
+
+/*!
+  \fn bool TQGList::removeLast()
+
+  Removes the last item in the list.
+*/
+
+/*!
+  Removes the item at position \a index from the list.
+*/
+
+bool TQGList::removeAt( uint index )
+{
+    if ( !locate(index) )
+	return FALSE;
+    TQLNode *n = unlink();
+    if ( !n )
+	return FALSE;
+    deleteItem( n->data );
+    delete n;
+    return TRUE;
+}
+
+
+/*!
+  Replaces the item at index \a index with \a d.
+*/
+bool TQGList::tqreplaceAt( uint index, TQPtrCollection::Item d )
+{
+    TQLNode *n = locate( index );
+    if ( !n )
+	return FALSE;
+    if ( n->data != d ) {
+	deleteItem( n->data );
+	n->data = newItem( d );
+    }
+    return TRUE;
+}
+
+
+
+/*!
+  Takes the node \a n out of the list.
+*/
+
+TQPtrCollection::Item TQGList::takeNode( TQLNode *n )
+{
+#if defined(TQT_CHECK_NULL)
+    if ( n == 0 || (n->prev && n->prev->next != n) ||
+	 (n->next && n->next->prev != n) ) {
+	qWarning( "TQGList::takeNode: Corrupted node" );
+	return 0;
+    }
+#endif
+    curNode = n;
+    unlink();					// unlink node
+    Item d = n->data;
+    delete n;					// delete the node, not data
+    curNode  = firstNode;
+    curIndex = curNode ? 0 : -1;
+    return d;
+}
+
+/*!
+  Takes the current item out of the list.
+*/
+
+TQPtrCollection::Item TQGList::take()
+{
+    TQLNode *n = unlink();			// unlink node
+    Item d = n ? n->data : 0;
+    delete n;					// delete node, keep contents
+    return d;
+}
+
+/*!
+  Takes the item at position \a index out of the list.
+*/
+
+TQPtrCollection::Item TQGList::takeAt( uint index )
+{
+    if ( !locate(index) )
+	return 0;
+    TQLNode *n = unlink();			// unlink node
+    Item d = n ? n->data : 0;
+    delete n;					// delete node, keep contents
+    return d;
+}
+
+/*!
+  Takes the first item out of the list.
+*/
+
+TQPtrCollection::Item TQGList::takeFirst()
+{
+    first();
+    TQLNode *n = unlink();			// unlink node
+    Item d = n ? n->data : 0;
+    delete n;
+    return d;
+}
+
+/*!
+  Takes the last item out of the list.
+*/
+
+TQPtrCollection::Item TQGList::takeLast()
+{
+    last();
+    TQLNode *n = unlink();			// unlink node
+    Item d = n ? n->data : 0;
+    delete n;
+    return d;
+}
+
+
+/*!
+  Removes all items from the list.
+*/
+
+void TQGList::clear()
+{
+    register TQLNode *n = firstNode;
+
+    firstNode = lastNode = curNode = 0;		// initialize list
+    numNodes = 0;
+    curIndex = -1;
+
+    if ( iterators )
+	iterators->notifyClear( FALSE );
+
+    TQLNode *prevNode;
+    while ( n ) {				// for all nodes ...
+	deleteItem( n->data );			// deallocate data
+	prevNode = n;
+	n = n->next;
+	delete prevNode;			// deallocate node
+    }
+}
+
+
+/*!
+  Finds item \a d in the list. If \a fromStart is TRUE the search
+  begins at the first node; otherwise it begins at the current node.
+*/
+
+int TQGList::tqfindRef( TQPtrCollection::Item d, bool fromStart )
+{
+    register TQLNode *n;
+    int	     index;
+    if ( fromStart ) {				// start from first node
+	n = firstNode;
+	index = 0;
+    } else {					// start from current node
+	n = curNode;
+	index = curIndex;
+    }
+    while ( n && n->data != d ) {		// tqfind exact match
+	n = n->next;
+	index++;
+    }
+    curNode = n;
+    curIndex = n ? index : -1;
+    return curIndex;				// return position of item
+}
+
+/*!
+  Finds item \a d in the list using compareItems(). If \a fromStart is
+  TRUE the search begins at the first node; otherwise it begins at the
+  current node.
+*/
+
+int TQGList::tqfind( TQPtrCollection::Item d, bool fromStart )
+{
+    register TQLNode *n;
+    int	     index;
+    if ( fromStart ) {				// start from first node
+	n = firstNode;
+	index = 0;
+    } else {					// start from current node
+	n = curNode;
+	index = curIndex;
+    }
+    while ( n && compareItems(n->data,d) ){	// tqfind equal match
+	n = n->next;
+	index++;
+    }
+    curNode = n;
+    curIndex = n ? index : -1;
+    return curIndex;				// return position of item
+}
+
+
+/*!
+  Counts the number item \a d occurs in the list.
+*/
+
+uint TQGList::tqcontainsRef( TQPtrCollection::Item d ) const
+{
+    register TQLNode *n = firstNode;
+    uint     count = 0;
+    while ( n ) {				// for all nodes...
+	if ( n->data == d )			// count # exact matches
+	    count++;
+	n = n->next;
+    }
+    return count;
+}
+
+/*!
+  Counts the number of times item \a d occurs in the list. Uses
+  compareItems().
+*/
+
+uint TQGList::tqcontains( TQPtrCollection::Item d ) const
+{
+    register TQLNode *n = firstNode;
+    uint     count = 0;
+    TQGList  *that = (TQGList*)this;		// mutable for compareItems()
+    while ( n ) {				// for all nodes...
+	if ( !that->compareItems(n->data,d) )	// count # equal matches
+	    count++;
+	n = n->next;
+    }
+    return count;
+}
+
+
+/*!
+  \overload TQPtrCollection::Item TQGList::at( uint index )
+
+  Sets the item at position \a index to the current item.
+*/
+
+/*!
+  \fn int TQGList::at() const
+
+  Returns the current index.
+*/
+
+/*!
+  \fn TQLNode *TQGList::currentNode() const
+
+  Returns the current node.
+*/
+
+/*!
+  \fn TQPtrCollection::Item TQGList::get() const
+
+  Returns the current item.
+*/
+
+/*!
+  \fn TQPtrCollection::Item TQGList::cfirst() const
+
+  Returns the first item in the list.
+*/
+
+/*!
+  \fn TQPtrCollection::Item TQGList::clast() const
+
+  Returns the last item in the list.
+*/
+
+
+/*!
+  Returns the first list item.	Sets this to current.
+*/
+
+TQPtrCollection::Item TQGList::first()
+{
+    if ( firstNode ) {
+	curIndex = 0;
+	return (curNode=firstNode)->data;
+    }
+    return 0;
+}
+
+/*!
+  Returns the last list item.  Sets this to current.
+*/
+
+TQPtrCollection::Item TQGList::last()
+{
+    if ( lastNode ) {
+	curIndex = numNodes-1;
+	return (curNode=lastNode)->data;
+    }
+    return 0;
+}
+
+/*!
+  Returns the next list item (after current).  Sets this to current.
+*/
+
+TQPtrCollection::Item TQGList::next()
+{
+    if ( curNode ) {
+	if ( curNode->next ) {
+	    curIndex++;
+	    curNode = curNode->next;
+	    return curNode->data;
+	}
+	curIndex = -1;
+	curNode = 0;
+    }
+    return 0;
+}
+
+/*!
+  Returns the previous list item (before current).  Sets this to current.
+*/
+
+TQPtrCollection::Item TQGList::prev()
+{
+    if ( curNode ) {
+	if ( curNode->prev ) {
+	    curIndex--;
+	    curNode = curNode->prev;
+	    return curNode->data;
+	}
+	curIndex = -1;
+	curNode = 0;
+    }
+    return 0;
+}
+
+
+/*!
+  Converts the list to a vector, \a vector.
+*/
+
+void TQGList::toVector( TQGVector *vector ) const
+{
+    vector->clear();
+    if ( !vector->resize( count() ) )
+	return;
+    register TQLNode *n = firstNode;
+    uint i = 0;
+    while ( n ) {
+	vector->insert( i, n->data );
+	n = n->next;
+	i++;
+    }
+}
+
+void TQGList::heapSortPushDown( TQPtrCollection::Item* heap, int first, int last )
+{
+    int r = first;
+    while( r <= last/2 ) {
+	// Node r has only one child ?
+	if ( last == 2*r ) {
+	    // Need for swapping ?
+	    if ( compareItems( heap[r], heap[ 2*r ] ) > 0 ) {
+		TQPtrCollection::Item tmp = heap[r];
+		heap[ r ] = heap[ 2*r ];
+		heap[ 2*r ] = tmp;
+	    }
+	    // That's it ...
+	    r = last;
+	} else {
+	    // Node has two tqchildren
+	    if ( compareItems( heap[r], heap[ 2*r ] ) > 0 &&
+		 compareItems( heap[ 2*r ], heap[ 2*r+1 ] ) <= 0 ) {
+		// Swap with left child
+		TQPtrCollection::Item tmp = heap[r];
+		heap[ r ] = heap[ 2*r ];
+		heap[ 2*r ] = tmp;
+		r *= 2;
+	    } else if ( compareItems( heap[r], heap[ 2*r+1 ] ) > 0 &&
+			compareItems( heap[ 2*r+1 ], heap[ 2*r ] ) < 0 ) {
+		// Swap with right child
+		TQPtrCollection::Item tmp = heap[r];
+		heap[ r ] = heap[ 2*r+1 ];
+		heap[ 2*r+1 ] = tmp;
+		r = 2*r+1;
+	    } else {
+		// We are done
+		r = last;
+	    }
+	}
+    }
+}
+
+
+/*! Sorts the list by the result of the virtual compareItems() function.
+
+  The Heap-Sort algorithm is used for sorting.  It sorts n items with
+  O(n*log n) compares.  This is the asymptotic optimal solution of the
+  sorting problem.
+*/
+
+void TQGList::sort()
+{
+    uint n = count();
+    if ( n < 2 )
+	return;
+
+    // Create the heap
+    TQPtrCollection::Item* realheap = new TQPtrCollection::Item[ n ];
+    // Wow, what a fake. But I want the heap to be indexed as 1...n
+    TQPtrCollection::Item* heap = realheap - 1;
+    int size = 0;
+    TQLNode* insert = firstNode;
+    for( ; insert != 0; insert = insert->next ) {
+	heap[++size] = insert->data;
+	int i = size;
+	while( i > 1 && compareItems( heap[i], heap[ i / 2 ] ) < 0 ) {
+	    TQPtrCollection::Item tmp = heap[ i ];
+	    heap[ i ] = heap[ i/2 ];
+	    heap[ i/2 ] = tmp;
+	    i /= 2;
+	}
+    }
+
+    insert = firstNode;
+    // Now do the sorting
+    for ( int i = n; i > 0; i-- ) {
+	insert->data = heap[1];
+	insert = insert->next;
+	if ( i > 1 ) {
+	    heap[1] = heap[i];
+	    heapSortPushDown( heap, 1, i - 1 );
+	}
+    }
+
+    delete [] realheap;
+}
+
+
+/*****************************************************************************
+  TQGList stream functions
+ *****************************************************************************/
+
+#ifndef TQT_NO_DATASTREAM
+TQDataStream &operator>>( TQDataStream &s, TQGList &list )
+{						// read list
+    return list.read( s );
+}
+
+TQDataStream &operator<<( TQDataStream &s, const TQGList &list )
+{						// write list
+    return list.write( s );
+}
+
+/*!
+  Reads a list from the stream \a s.
+*/
+
+TQDataStream &TQGList::read( TQDataStream &s )
+{
+    uint num;
+    s >> num;					// read number of items
+    clear();					// clear list
+    while ( num-- ) {				// read all items
+	Item d;
+	read( s, d );
+	TQ_CHECK_PTR( d );
+	if ( !d )				// no memory
+	    break;
+	TQLNode *n = new TQLNode( d );
+	TQ_CHECK_PTR( n );
+	if ( !n )				// no memory
+	    break;
+	n->next = 0;
+	if ( (n->prev = lastNode) )		// list is not empty
+	    lastNode->next = n;
+	else					// initialize list
+	    firstNode = n;
+	lastNode = n;
+	numNodes++;
+    }
+    curNode  = firstNode;
+    curIndex = curNode ? 0 : -1;
+    return s;
+}
+
+/*!
+  Writes the list to the stream \a s.
+*/
+
+TQDataStream &TQGList::write( TQDataStream &s ) const
+{
+    s << count();				// write number of items
+    TQLNode *n = firstNode;
+    while ( n ) {				// write all items
+	write( s, n->data );
+	n = n->next;
+    }
+    return s;
+}
+
+#endif // TQT_NO_DATASTREAM
+
+
+
+/*! \internal
+ */
+TQLNode* TQGList::erase( TQLNode* it )
+{
+    TQLNode* n = it;
+    it = it->next;
+    removeNode( n );
+    return it;
+}
+
+
+/*****************************************************************************
+  TQGListIterator member functions
+ *****************************************************************************/
+
+/*!
+  \class TQGListIterator tqglist.h
+  \reentrant
+  \ingroup collection
+  \brief The TQGListIterator class is an internal class for implementing TQPtrListIterator.
+
+  \internal
+
+  TQGListIterator is a strictly internal class that does the heavy work for
+  TQPtrListIterator.
+*/
+
+/*!
+  \internal
+  Constructs an iterator that operates on the list \a l.
+*/
+
+TQGListIterator::TQGListIterator( const TQGList &l )
+{
+    list = (TQGList *)&l;			// get reference to list
+    curNode = list->firstNode;			// set to first node
+    if ( !list->iterators ) {
+	list->iterators = new TQGListIteratorList;		// create iterator list
+	TQ_CHECK_PTR( list->iterators );
+    }
+    list->iterators->add( this );		// attach iterator to list
+}
+
+/*!
+  \internal
+  Constructs a copy of the iterator \a it.
+*/
+
+TQGListIterator::TQGListIterator( const TQGListIterator &it )
+{
+    list = it.list;
+    curNode = it.curNode;
+    if ( list )
+	list->iterators->add( this );	// attach iterator to list
+}
+
+/*!
+  \internal
+  Assigns a copy of the iterator \a it and returns a reference to this
+  iterator.
+*/
+
+TQGListIterator &TQGListIterator::operator=( const TQGListIterator &it )
+{
+    if ( list )					// detach from old list
+	list->iterators->remove( this );
+    list = it.list;
+    curNode = it.curNode;
+    if ( list )
+	list->iterators->add( this );	// attach to new list
+    return *this;
+}
+
+/*!
+  \internal
+  Destroys the iterator.
+*/
+
+TQGListIterator::~TQGListIterator()
+{
+    if ( list )					// detach iterator from list
+	list->iterators->remove(this);
+}
+
+
+/*!
+  \fn bool TQGListIterator::atFirst() const
+  \internal
+  Returns TRUE if the iterator points to the first item, otherwise FALSE.
+*/
+
+/*!
+  \fn bool TQGListIterator::atLast() const
+  \internal
+  Returns TRUE if the iterator points to the last item, otherwise FALSE.
+*/
+
+
+/*!
+  \internal
+  Sets the list iterator to point to the first item in the list.
+*/
+
+TQPtrCollection::Item TQGListIterator::toFirst()
+{
+    if ( !list ) {
+#if defined(TQT_CHECK_NULL)
+	qWarning( "TQGListIterator::toFirst: List has been deleted" );
+#endif
+	return 0;
+    }
+    return list->firstNode ? (curNode = list->firstNode)->getData() : 0;
+}
+
+/*!
+  \internal
+  Sets the list iterator to point to the last item in the list.
+*/
+
+TQPtrCollection::Item TQGListIterator::toLast()
+{
+    if ( !list ) {
+#if defined(TQT_CHECK_NULL)
+	qWarning( "TQGListIterator::toLast: List has been deleted" );
+#endif
+	return 0;
+    }
+    return list->lastNode ? (curNode = list->lastNode)->getData() : 0;
+}
+
+
+/*!
+  \fn TQPtrCollection::Item TQGListIterator::get() const
+  \internal
+  Returns the iterator item.
+*/
+
+
+/*!
+  \internal
+  Moves to the next item (postfix).
+*/
+
+TQPtrCollection::Item TQGListIterator::operator()()
+{
+    if ( !curNode )
+	return 0;
+    TQPtrCollection::Item d = curNode->getData();
+    curNode = curNode->next;
+    return  d;
+}
+
+/*!
+  \internal
+  Moves to the next item (prefix).
+*/
+
+TQPtrCollection::Item TQGListIterator::operator++()
+{
+    if ( !curNode )
+	return 0;
+    curNode = curNode->next;
+    return curNode ? curNode->getData() : 0;
+}
+
+/*!
+  \internal
+  Moves \a jumps positions forward.
+*/
+
+TQPtrCollection::Item TQGListIterator::operator+=( uint jumps )
+{
+    while ( curNode && jumps-- )
+	curNode = curNode->next;
+    return curNode ? curNode->getData() : 0;
+}
+
+/*!
+  \internal
+  Moves to the previous item (prefix).
+*/
+
+TQPtrCollection::Item TQGListIterator::operator--()
+{
+    if ( !curNode )
+	return 0;
+    curNode = curNode->prev;
+    return curNode ? curNode->getData() : 0;
+}
+
+/*!
+  \internal
+  Moves \a jumps positions backward.
+*/
+
+TQPtrCollection::Item TQGListIterator::operator-=( uint jumps )
+{
+    while ( curNode && jumps-- )
+	curNode = curNode->prev;
+    return curNode ? curNode->getData() : 0;
+}
diff --git a/tqtinterface/qt4/src/tools/tqglist.h b/tqtinterface/qt4/src/tools/tqglist.h
new file mode 100644
index 0000000..4c91453
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqglist.h
@@ -0,0 +1,271 @@
+/****************************************************************************
+**
+** Definition of TQGList and TQGListIterator classes
+**
+** Created : 920624
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQGLIST_H
+#define TQGLIST_H
+
+#ifndef TQT_H
+#include "tqptrcollection.h"
+#endif // TQT_H
+
+class TQ_EXPORT TQLNode
+{
+friend class TQGList;
+friend class TQGListIterator;
+friend class TQGListStdIterator;
+public:
+    TQPtrCollection::Item getData()	{ return data; }
+private:
+    TQPtrCollection::Item data;
+    TQLNode *prev;
+    TQLNode *next;
+    TQLNode( TQPtrCollection::Item d ) { data = d; }
+};
+
+class TQGListIteratorList; // internal helper class
+
+class TQ_EXPORT TQGList : public TQPtrCollection	// doubly linked generic list
+{
+friend class TQGListIterator;
+friend class TQGListIteratorList;
+friend class TQGVector;				// needed by TQGVector::toList
+public:
+    uint  count() const;			// return number of nodes
+
+#ifndef TQT_NO_DATASTREAM
+    TQDataStream &read( TQDataStream & );		// read list from stream
+    TQDataStream &write( TQDataStream & ) const;	// write list to stream
+#endif
+protected:
+    TQGList();					// create empty list
+    TQGList( const TQGList & );			// make copy of other list
+    virtual ~TQGList();
+
+    TQGList &operator=( const TQGList & );	// assign from other list
+    bool operator==( const TQGList& ) const;
+
+    void inSort( TQPtrCollection::Item );		// add item sorted in list
+    void append( TQPtrCollection::Item );		// add item at end of list
+    bool insertAt( uint index, TQPtrCollection::Item ); // add item at i'th position
+    void relinkNode( TQLNode * );		// relink as first item
+    bool removeNode( TQLNode * );		// remove node
+    bool remove( TQPtrCollection::Item = 0 );	// remove item (0=current)
+    bool removeRef( TQPtrCollection::Item = 0 );	// remove item (0=current)
+    bool removeFirst();				// remove first item
+    bool removeLast();				// remove last item
+    bool removeAt( uint );			// remove item at i'th position
+    bool tqreplaceAt( uint, TQPtrCollection::Item ); // tqreplace item at position i with item
+    TQPtrCollection::Item takeNode( TQLNode * );	// take out node
+    TQPtrCollection::Item take();		// take out current item
+    TQPtrCollection::Item takeAt( uint index );	// take out item at i'th pos
+    TQPtrCollection::Item takeFirst();		// take out first item
+    TQPtrCollection::Item takeLast();		// take out last item
+
+    void sort();                        	// sort all items;
+    void clear();				// remove all items
+
+    int	 tqfindRef( TQPtrCollection::Item, bool = TRUE ); // tqfind exact item in list
+    int	 tqfind( TQPtrCollection::Item, bool = TRUE ); // tqfind equal item in list
+
+    uint tqcontainsRef( TQPtrCollection::Item ) const;	// get number of exact matches
+    uint tqcontains( TQPtrCollection::Item ) const;	// get number of equal matches
+
+    TQPtrCollection::Item at( uint index );	// access item at i'th pos
+    int	  at() const;				// get current index
+    TQLNode *currentNode() const;		// get current node
+
+    TQPtrCollection::Item get() const;		// get current item
+
+    TQPtrCollection::Item cfirst() const;	// get ptr to first list item
+    TQPtrCollection::Item clast()  const;	// get ptr to last list item
+    TQPtrCollection::Item first();		// set first item in list curr
+    TQPtrCollection::Item last();		// set last item in list curr
+    TQPtrCollection::Item next();		// set next item in list curr
+    TQPtrCollection::Item prev();		// set prev item in list curr
+
+    void  toVector( TQGVector * ) const;		// put items in vector
+
+    virtual int compareItems( TQPtrCollection::Item, TQPtrCollection::Item );
+
+#ifndef TQT_NO_DATASTREAM
+    virtual TQDataStream &read( TQDataStream &, TQPtrCollection::Item & );
+    virtual TQDataStream &write( TQDataStream &, TQPtrCollection::Item ) const;
+#endif
+
+    TQLNode* begin() const { return firstNode; }
+    TQLNode* end() const { return 0; }
+    TQLNode* erase( TQLNode* it );
+
+private:
+    void  prepend( TQPtrCollection::Item );	// add item at start of list
+
+    void heapSortPushDown( TQPtrCollection::Item* heap, int first, int last );
+
+    TQLNode *firstNode;				// first node
+    TQLNode *lastNode;				// last node
+    TQLNode *curNode;				// current node
+    int curIndex;				// current index
+    uint numNodes;				// number of nodes
+    TQGListIteratorList *iterators; 		// list of iterators
+
+    TQLNode *locate( uint );			// get node at i'th pos
+    TQLNode *unlink();				// unlink node
+};
+
+
+inline uint TQGList::count() const
+{
+    return numNodes;
+}
+
+inline bool TQGList::removeFirst()
+{
+    first();
+    return remove();
+}
+
+inline bool TQGList::removeLast()
+{
+    last();
+    return remove();
+}
+
+inline int TQGList::at() const
+{
+    return curIndex;
+}
+
+inline TQPtrCollection::Item TQGList::at( uint index )
+{
+    TQLNode *n = locate( index );
+    return n ? n->data : 0;
+}
+
+inline TQLNode *TQGList::currentNode() const
+{
+    return curNode;
+}
+
+inline TQPtrCollection::Item TQGList::get() const
+{
+    return curNode ? curNode->data : 0;
+}
+
+inline TQPtrCollection::Item TQGList::cfirst() const
+{
+    return firstNode ? firstNode->data : 0;
+}
+
+inline TQPtrCollection::Item TQGList::clast() const
+{
+    return lastNode ? lastNode->data : 0;
+}
+
+
+/*****************************************************************************
+  TQGList stream functions
+ *****************************************************************************/
+
+#ifndef TQT_NO_DATASTREAM
+TQ_EXPORT TQDataStream &operator>>( TQDataStream &, TQGList & );
+TQ_EXPORT TQDataStream &operator<<( TQDataStream &, const TQGList & );
+#endif
+
+/*****************************************************************************
+  TQGListIterator class
+ *****************************************************************************/
+
+class TQ_EXPORT TQGListIterator			// TQGList iterator
+{
+friend class TQGList;
+friend class TQGListIteratorList;
+protected:
+    TQGListIterator( const TQGList & );
+    TQGListIterator( const TQGListIterator & );
+    TQGListIterator &operator=( const TQGListIterator & );
+   ~TQGListIterator();
+
+    bool  atFirst() const;			// test if at first item
+    bool  atLast()  const;			// test if at last item
+    TQPtrCollection::Item	  toFirst();				// move to first item
+    TQPtrCollection::Item	  toLast();				// move to last item
+
+    TQPtrCollection::Item	  get() const;				// get current item
+    TQPtrCollection::Item	  operator()();				// get current and move to next
+    TQPtrCollection::Item	  operator++();				// move to next item (prefix)
+    TQPtrCollection::Item	  operator+=(uint);			// move n positions forward
+    TQPtrCollection::Item	  operator--();				// move to prev item (prefix)
+    TQPtrCollection::Item	  operator-=(uint);			// move n positions backward
+
+protected:
+    TQGList *list;				// reference to list
+
+private:
+    TQLNode  *curNode;				// current node in list
+};
+
+
+inline bool TQGListIterator::atFirst() const
+{
+    return curNode == list->firstNode;
+}
+
+inline bool TQGListIterator::atLast() const
+{
+    return curNode == list->lastNode;
+}
+
+inline TQPtrCollection::Item TQGListIterator::get() const
+{
+    return curNode ? curNode->data : 0;
+}
+
+class TQ_EXPORT TQGListStdIterator
+{
+public:
+    inline TQGListStdIterator( TQLNode* n ) : node( n ){}
+    inline operator TQLNode* () { return node; }
+protected:
+    inline TQLNode *next() { return node->next; }
+    TQLNode *node;
+};
+
+
+#endif	// TQGLIST_H
diff --git a/tqtinterface/qt4/src/tools/tqglobal.cpp b/tqtinterface/qt4/src/tools/tqglobal.cpp
new file mode 100644
index 0000000..0d548ed
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqglobal.cpp
@@ -0,0 +1,927 @@
+/****************************************************************************
+**
+** Global functions
+**
+** Created : 920604
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "tqplatformdefs.h"
+
+#include "tqasciidict.h"
+#include <limits.h>
+#include <stdio.h>
+#include <limits.h>
+#include <stdarg.h>
+#include <stdlib.h>
+
+#if defined(TQ_CC_MSVC) && !defined(TQ_CC_MSVC_NET) && !defined(TQ_OS_TEMP)
+#include <crtdbg.h>
+#endif
+
+
+/*!
+    \relates TQApplication
+
+    Returns the TQt version number as a string, for example, "2.3.0" or
+    "3.0.5".
+
+    The \c TQT_VERSION define has the numeric value in the form:
+    0xmmiibb (m = major, i = minor, b = bugfix). For example, TQt
+    3.0.5's \c TQT_VERSION is 0x030005.
+*/
+
+const char *qVersion()
+{
+    return TQT_VERSION_STR;
+}
+
+bool qSharedBuild()
+{
+#ifdef TQT_SHARED
+    return TRUE;
+#else
+    return FALSE;
+#endif
+}
+
+/*****************************************************************************
+  System detection routines
+ *****************************************************************************/
+
+static bool si_alreadyDone = FALSE;
+static int  si_wordSize;
+static bool si_bigEndian;
+
+/*!
+    \relates TQApplication
+
+    Obtains information about the system.
+
+    The system's word size in bits (typically 32) is returned in \a
+    *wordSize. The \a *bigEndian is set to TRUE if this is a big-endian
+    machine, or to FALSE if this is a little-endian machine.
+
+    In debug mode, this function calls qFatal() with a message if the
+    computer is truly weird (i.e. different endianness for 16 bit and
+    32 bit integers); in release mode it returns FALSE.
+*/
+
+bool qSysInfo( int *wordSize, bool *bigEndian )
+{
+#if defined(TQT_CHECK_NULL)
+    TQ_ASSERT( wordSize != 0 );
+    TQ_ASSERT( bigEndian != 0 );
+#endif
+
+    if ( si_alreadyDone ) {			// run it only once
+	*wordSize  = si_wordSize;
+	*bigEndian = si_bigEndian;
+	return TRUE;
+    }
+
+    si_wordSize = 0;
+    TQ_ULONG n = (TQ_ULONG)(~0);
+    while ( n ) {				// detect word size
+	si_wordSize++;
+	n /= 2;
+    }
+    *wordSize = si_wordSize;
+
+    if ( *wordSize != 64 &&
+	 *wordSize != 32 &&
+	 *wordSize != 16 ) {			// word size: 16, 32 or 64
+#if defined(TQT_CHECK_RANGE)
+	qFatal( "qSysInfo: Unsupported system word size %d", *wordSize );
+#endif
+	return FALSE;
+    }
+    if ( sizeof(TQ_INT8) != 1 || sizeof(TQ_INT16) != 2 || sizeof(TQ_INT32) != 4 ||
+	 sizeof(TQ_ULONG)*8 != si_wordSize || sizeof(float) != 4 || sizeof(double) != 8 ) {
+#if defined(TQT_CHECK_RANGE)
+	qFatal( "qSysInfo: Unsupported system data type size" );
+#endif
+	return FALSE;
+    }
+
+    bool  be16, be32;				// determine byte ordering
+    short ns = 0x1234;
+    int	  nl = 0x12345678;
+
+    unsigned char *p = (unsigned char *)(&ns);	// 16-bit integer
+    be16 = *p == 0x12;
+
+    p = (unsigned char *)(&nl);			// 32-bit integer
+    if ( p[0] == 0x12 && p[1] == 0x34 && p[2] == 0x56 && p[3] == 0x78 )
+	be32 = TRUE;
+    else
+    if ( p[0] == 0x78 && p[1] == 0x56 && p[2] == 0x34 && p[3] == 0x12 )
+	be32 = FALSE;
+    else
+	be32 = !be16;
+
+    if ( be16 != be32 ) {			// strange machine!
+#if defined(TQT_CHECK_RANGE)
+	qFatal( "qSysInfo: Inconsistent system byte order" );
+#endif
+	return FALSE;
+    }
+
+    *bigEndian = si_bigEndian = be32;
+    si_alreadyDone = TRUE;
+    return TRUE;
+}
+
+#if !defined(TQWS) && defined(TQ_OS_MAC)
+
+#include "tqt_mac.h"
+
+// This function has descended from Apple Source Code (FSpLocationFromFullPath),
+// but changes have been made. [Creates a minimal alias from the full pathname]
+OSErr qt_mac_create_fsspec(const TQString &file, FSSpec *spec)
+{
+    FSRef fref;
+    TQCString utfs = file.utf8();
+    OSErr ret = FSPathMakeRef((const UInt8 *)utfs.data(), &fref, NULL);
+    if(ret == noErr)
+	ret = FSGetCatalogInfo(&fref, kFSCatInfoNone, NULL, NULL, spec, NULL);
+    return ret;
+}
+
+CFStringRef qstring2cfstring(const TQString &str)
+{
+    return CFStringCreateWithCharacters(0, (UniChar *)str.tqunicode(), str.length());
+}
+
+TQString cfstring2qstring(CFStringRef str)
+{
+    if(!str)
+	return TQString();
+
+    CFIndex length = CFStringGetLength(str);
+    if(const UniChar *chars = CFStringGetCharactersPtr(str))
+	return TQString((TQChar *)chars, length);
+    UniChar *buffer = (UniChar*)malloc(length * sizeof(UniChar));
+    CFStringGetCharacters(str, CFRangeMake(0, length), buffer);
+    TQString ret((TQChar *)buffer, length);
+    free(buffer);
+    return ret;
+}
+
+unsigned char *p_str(const TQString &s)
+{
+    CFStringRef cfstr = qstring2cfstring(s);
+    uchar *p = (uchar*)malloc(256);
+    CFStringGetPascalString(cfstr, p, 256, CFStringGetSystemEncoding());
+    CFRelease(cfstr);
+    return p;
+}
+
+TQString p2qstring(const unsigned char *c) {
+    CFStringRef cfstr = CFStringCreateWithPascalString(0, c, CFStringGetSystemEncoding());
+    TQString str = cfstring2qstring(cfstr);
+    CFRelease(cfstr);
+    return str;
+}
+
+int qMacVersion()
+{
+    static int macver = TQt::MV_Unknown;
+    static bool first = TRUE;
+    if(first) {
+	first = FALSE;
+	long gestalt_version;
+	if(Gestalt(gestaltSystemVersion, &gestalt_version) == noErr) {
+            macver = ((gestalt_version & 0x00f0) >> 4) + 2;
+
+	}
+    }
+    return macver;
+}
+TQt::MacintoshVersion qt_macver = (TQt::MacintoshVersion)qMacVersion();
+
+// HFS+ filesystems use decomposing tqunicode for certain layers in tqunicode
+// In general these don't look great as a user visible string.
+// Therefore it is a good idea to normalize them ourselves.
+// These technotes on Apple's website:
+// http://developer.apple.com/qa/qa2001/qa1235.html
+// http://developer.apple.com/qa/qa2001/qa1173.html
+TQString qt_mac_precomposeFileName(const TQString &str)
+{
+    if (str.isEmpty())
+        return str;
+    int strLength = str.length();
+    CFMutableStringRef cfmstr = CFStringCreateMutable(0, strLength);
+    CFStringAppendCharacters(cfmstr, (UniChar *)str.tqunicode(), strLength);
+    CFStringNormalize(cfmstr, kCFStringNormalizationFormC);
+    TQString newStr = cfstring2qstring(cfmstr);
+    CFRelease(cfmstr);
+    return newStr;
+}
+#elif defined(TQ_OS_WIN32) || defined(TQ_OS_CYGWIN) || defined(TQ_OS_TEMP)
+bool qt_wintqunicode;
+# ifdef TQ_OS_TEMP
+  DWORD qt_cever = 0;
+# endif // TQ_OS_TEMP
+
+#include "tqt_windows.h"
+
+int qWinVersion()
+{
+#ifndef VER_PLATFORM_WIN32s
+#define VER_PLATFORM_WIN32s	    0
+#endif
+#ifndef VER_PLATFORM_WIN32_WINDOWS
+#define VER_PLATFORM_WIN32_WINDOWS  1
+#endif
+#ifndef VER_PLATFORM_WIN32_NT
+#define VER_PLATFORM_WIN32_NT	    2
+#endif
+#ifndef VER_PLATFORM_WIN32_CE
+#define VER_PLATFORM_WIN32_CE	    3
+#endif
+
+    static int winver = TQt::WV_NT;
+    static int t=0;
+    if ( !t ) {
+	t=1;
+#ifndef TQ_OS_TEMP
+	OSVERSIONINFOA osver;
+	osver.dwOSVersionInfoSize = sizeof(osver);
+	GetVersionExA( &osver );
+#else
+	OSVERSIONINFOW osver;
+	osver.dwOSVersionInfoSize = sizeof(osver);
+	GetVersionEx( &osver );
+	qt_cever = osver.dwMajorVersion * 100;
+	qt_cever += osver.dwMinorVersion * 10;
+#endif
+	switch ( osver.dwPlatformId ) {
+	case VER_PLATFORM_WIN32s:
+	    winver = TQt::WV_32s;
+	    break;
+	case VER_PLATFORM_WIN32_WINDOWS:
+	    // We treat Windows Me (minor 90) the same as Windows 98
+	    if ( osver.dwMinorVersion == 90 )
+		winver = TQt::WV_Me;
+	    else if ( osver.dwMinorVersion == 10 )
+		winver = TQt::WV_98;
+	    else
+		winver = TQt::WV_95;
+	    break;
+	case VER_PLATFORM_WIN32_CE:
+#ifdef TQ_OS_TEMP
+	    if ( qt_cever >= 400 )
+		winver = TQt::WV_CENET;
+	    else
+#endif
+		winver = TQt::WV_CE;
+	    break;
+	default: // VER_PLATFORM_WIN32_NT
+	    if ( osver.dwMajorVersion < 5 ) {
+		winver = TQt::WV_NT;
+	    } else if (osver.dwMajorVersion == 6) {
+	    winver = TQt::WV_VISTA;
+	    } else if ( osver.dwMinorVersion == 0 ) {
+		winver = TQt::WV_2000;
+	    } else if ( osver.dwMinorVersion == 1 ) {
+		winver = TQt::WV_XP;
+	    } else if ( osver.dwMinorVersion == 2 ) {
+		winver = TQt::WV_2003;
+	    } else {
+		qWarning("Untested Windows version detected!");
+		winver = TQt::WV_NT_based;
+	    }
+	}
+    }
+
+#if defined(UNICODE)
+    if ( winver & TQt::WV_NT_based )
+	qt_wintqunicode = TRUE;
+    else
+#endif
+	qt_wintqunicode = FALSE;
+
+    return winver;
+}
+
+TQt::WindowsVersion qt_winver = (TQt::WindowsVersion)qWinVersion();
+#endif
+
+
+/*****************************************************************************
+  Debug output routines
+ *****************************************************************************/
+
+/*!
+    \fn void qDebug( const char *msg, ... )
+
+    \relates TQApplication
+
+    Prints a debug message \a msg, or calls the message handler (if it
+    has been installed).
+
+    This function takes a format string and a list of arguments,
+    similar to the C printf() function.
+
+    Example:
+    \code
+	qDebug( "my window handle = %x", myWidget->id() );
+    \endcode
+
+    Under X11, the text is printed to stderr. Under Windows, the text
+    is sent to the debugger.
+
+    \warning The internal buffer is limited to 8196 bytes (including
+    the '\0'-terminator).
+
+    \warning Passing (const char *)0 as argument to qDebug might lead
+    to crashes on certain platforms due to the platforms printf implementation.
+
+    \sa qWarning(), qFatal(), tqInstallMsgHandler(),
+	\link debug.html Debugging\endlink
+*/
+
+/*!
+    \fn void qWarning( const char *msg, ... )
+
+    \relates TQApplication
+
+    Prints a warning message \a msg, or calls the message handler (if
+    it has been installed).
+
+    This function takes a format string and a list of arguments,
+    similar to the C printf() function.
+
+    Example:
+    \code
+	void f( int c )
+	{
+	    if ( c > 200 )
+		qWarning( "f: bad argument, c == %d", c );
+	}
+    \endcode
+
+    Under X11, the text is printed to stderr. Under Windows, the text
+    is sent to the debugger.
+
+    \warning The internal buffer is limited to 8196 bytes (including
+    the '\0'-terminator).
+
+    \warning Passing (const char *)0 as argument to qWarning might lead
+    to crashes on certain platforms due to the platforms printf implementation.
+
+    \sa qDebug(), qFatal(), tqInstallMsgHandler(),
+    \link debug.html Debugging\endlink
+*/
+
+/*!
+    \fn void qFatal( const char *msg, ... )
+
+    \relates TQApplication
+
+    Prints a fatal error message \a msg and exits, or calls the
+    message handler (if it has been installed).
+
+    This function takes a format string and a list of arguments,
+    similar to the C printf() function.
+
+    Example:
+    \code
+	int divide( int a, int b )
+	{
+	    if ( b == 0 )				// program error
+		qFatal( "divide: cannot divide by zero" );
+	    return a/b;
+	}
+    \endcode
+
+    Under X11, the text is printed to stderr. Under Windows, the text
+    is sent to the debugger.
+
+    \warning The internal buffer is limited to 8196 bytes (including
+    the '\0'-terminator).
+
+    \warning Passing (const char *)0 as argument to qFatal might lead
+    to crashes on certain platforms due to the platforms printf implementation.
+
+    \sa qDebug(), qWarning(), tqInstallMsgHandler(),
+    \link debug.html Debugging\endlink
+*/
+
+
+static TQtMsgHandler handler = 0;		// pointer to debug handler
+static const int TQT_BUFFER_LENGTH = 8196;	// internal buffer length
+
+
+#ifdef TQ_CC_MWERKS
+
+#include "tqt_mac.h"
+
+extern bool qt_is_gui_used;
+static void mac_default_handler( const char *msg )
+{
+    if ( qt_is_gui_used ) {
+	const unsigned char *p = p_str(msg);
+	DebugStr(p);
+	free((void*)p);
+    } else {
+	fprintf( stderr, msg );
+    }
+}
+
+#endif
+
+
+void qDebug( const char *msg, ... )
+{
+    char buf[TQT_BUFFER_LENGTH];
+    va_list ap;
+    va_start( ap, msg );			// use variable arg list
+#if defined(TQT_VSNPRINTF)
+    TQT_VSNPRINTF( buf, TQT_BUFFER_LENGTH, msg, ap );
+#else
+    vsprintf( buf, msg, ap );
+#endif
+    va_end( ap );
+    if ( handler ) {
+	(*handler)( TQtDebugMsg, buf );
+    } else {
+#if defined(TQ_CC_MWERKS)
+        mac_default_handler(buf);
+#elif defined(TQ_OS_TEMP)
+	TQString fstr( buf );
+	OutputDebugString( (fstr + "\n").ucs2() );
+#else
+	fprintf( stderr, "%s\n", buf );		// add newline
+#endif
+    }
+}
+
+// copied... this looks really bad.
+void debug( const char *msg, ... )
+{
+    char buf[TQT_BUFFER_LENGTH];
+    va_list ap;
+    va_start( ap, msg );			// use variable arg list
+#if defined(TQT_VSNPRINTF)
+    TQT_VSNPRINTF( buf, TQT_BUFFER_LENGTH, msg, ap );
+#else
+    vsprintf( buf, msg, ap );
+#endif
+    va_end( ap );
+    if ( handler ) {
+	(*handler)( TQtDebugMsg, buf );
+    } else {
+#if defined(TQ_CC_MWERKS)
+        mac_default_handler(buf);
+#elif defined(TQ_OS_TEMP)
+	TQString fstr( buf );
+	OutputDebugString( (fstr + "\n").ucs2() );
+#else
+	fprintf( stderr, "%s\n", buf );		// add newline
+#endif
+    }
+}
+
+void qWarning( const char *msg, ... )
+{
+    char buf[TQT_BUFFER_LENGTH];
+    va_list ap;
+    va_start( ap, msg );			// use variable arg list
+#if defined(TQT_VSNPRINTF)
+    TQT_VSNPRINTF( buf, TQT_BUFFER_LENGTH, msg, ap );
+#else
+    vsprintf( buf, msg, ap );
+#endif
+    va_end( ap );
+    if ( handler ) {
+	(*handler)( TQtWarningMsg, buf );
+    } else {
+#if defined(TQ_CC_MWERKS)
+        mac_default_handler(buf);
+#elif defined(TQ_OS_TEMP)
+	TQString fstr( buf );
+	OutputDebugString( (fstr + "\n").ucs2() );
+#else
+	fprintf( stderr, "%s\n", buf );		// add newline
+#endif
+    }
+}
+
+
+// again, copied
+void warning( const char *msg, ... )
+{
+    char buf[TQT_BUFFER_LENGTH];
+    va_list ap;
+    va_start( ap, msg );			// use variable arg list
+#if defined(TQT_VSNPRINTF)
+    TQT_VSNPRINTF( buf, TQT_BUFFER_LENGTH, msg, ap );
+#else
+    vsprintf( buf, msg, ap );
+#endif
+    va_end( ap );
+    if ( handler ) {
+	(*handler)( TQtWarningMsg, buf );
+    } else {
+#if defined(TQ_CC_MWERKS)
+        mac_default_handler(buf);
+#elif defined(TQ_OS_TEMP)
+	TQString fstr( buf );
+	OutputDebugString( (fstr + "\n").ucs2() );
+#else
+	fprintf( stderr, "%s\n", buf );		// add newline
+#endif
+    }
+}
+
+void qFatal( const char *msg, ... )
+{
+    char buf[TQT_BUFFER_LENGTH];
+    va_list ap;
+    va_start( ap, msg );			// use variable arg list
+#if defined(TQT_VSNPRINTF)
+    TQT_VSNPRINTF( buf, TQT_BUFFER_LENGTH, msg, ap );
+#else
+    vsprintf( buf, msg, ap );
+#endif
+    va_end( ap );
+    if ( handler ) {
+	(*handler)( TQtFatalMsg, buf );
+    } else {
+#if defined(TQ_CC_MWERKS)
+        mac_default_handler(buf);
+#else
+	fprintf( stderr, "%s\n", buf );		// add newline
+#endif
+#if defined(TQ_OS_UNIX) && defined(TQT_DEBUG)
+	abort();				// trap; generates core dump
+#elif defined(TQ_OS_TEMP) && defined(TQT_DEBUG)
+	TQString fstr;
+	fstr.sprintf( "%s:%s %s %s\n", __FILE__, __LINE__, TQT_VERSION_STR, buf );
+	OutputDebugString( fstr.ucs2() );
+#elif defined(_CRT_ERROR) && defined(_DEBUG)
+	_CrtDbgReport( _CRT_ERROR, __FILE__, __LINE__, TQT_VERSION_STR, buf );
+#else
+	exit( 1 );				// goodbye cruel world
+#endif
+    }
+}
+
+// yet again, copied
+void fatal( const char *msg, ... )
+{
+    char buf[TQT_BUFFER_LENGTH];
+    va_list ap;
+    va_start( ap, msg );			// use variable arg list
+#if defined(TQT_VSNPRINTF)
+    TQT_VSNPRINTF( buf, TQT_BUFFER_LENGTH, msg, ap );
+#else
+    vsprintf( buf, msg, ap );
+#endif
+    va_end( ap );
+    if ( handler ) {
+	(*handler)( TQtFatalMsg, buf );
+    } else {
+#if defined(TQ_CC_MWERKS)
+        mac_default_handler(buf);
+#else
+	fprintf( stderr, "%s\n", buf );		// add newline
+#endif
+#if defined(TQ_OS_UNIX) && defined(TQT_DEBUG)
+	abort();				// trap; generates core dump
+#elif defined(TQ_OS_TEMP) && defined(TQT_DEBUG)
+	TQString fstr;
+	fstr.sprintf( "%s:%s %s %s\n", __FILE__, __LINE__, TQT_VERSION_STR, buf );
+	OutputDebugString( fstr.ucs2() );
+#elif defined(_CRT_ERROR) && defined(_DEBUG)
+	_CrtDbgReport( _CRT_ERROR, __FILE__, __LINE__, TQT_VERSION_STR, buf );
+#else
+	exit( 1 );				// goodbye cruel world
+#endif
+    }
+}
+
+/*!
+  \relates TQApplication
+
+  Prints the message \a msg and uses \a code to get a system specific
+  error message. When \a code is -1 (the default), the system's last
+  error code will be used if possible. Use this method to handle
+  failures in platform specific API calls.
+
+  This function does nothing when TQt is built with \c TQT_NO_DEBUG
+  defined.
+*/
+void tqSystemWarning( const char* msg, int code )
+{
+#ifndef TQT_NO_DEBUG
+#if defined(TQ_OS_WIN32)
+    if ( code == -1 )
+	code = GetLastError();
+
+    if ( !code )
+	return;
+
+    unsigned short *string;
+    TQT_WA( {
+	FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,
+		       NULL,
+		       code,
+		       MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+		       (LPTSTR)&string,
+		       0,
+		       NULL );
+
+	qWarning( "%s\n\tError code %d - %s", msg, code, TQString::fromUcs2(string).latin1() );
+    }, {
+	FormatMessageA( FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,
+			NULL,
+			code,
+			MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+			(char*)&string,
+			0,
+			NULL );
+
+	qWarning( "%s\n\tError code %d - %s", msg, code, (const char*)string );
+    } );
+    LocalFree( (HLOCAL)string );
+#else
+    if ( code != -1 )
+	qWarning( "%s\n\tError code %d - %s", msg, code, strerror( code ) );
+    else
+	qWarning( "%s", msg );
+#endif
+#else
+    TQ_UNUSED( msg );
+    TQ_UNUSED( code );
+#endif
+}
+
+/*!
+    \fn void TQ_ASSERT( bool test )
+
+    \relates TQApplication
+
+    Prints a warning message containing the source code file name and
+    line number if \a test is FALSE.
+
+    This is really a macro defined in \c tqglobal.h.
+
+    TQ_ASSERT is useful for testing pre- and post-conditions.
+
+    Example:
+    \code
+	//
+	// File: div.cpp
+	//
+
+	#include <tqglobal.h>
+
+	int divide( int a, int b )
+	{
+	    TQ_ASSERT( b != 0 );			// this is line 9
+	    return a/b;
+	}
+    \endcode
+
+    If \c b is zero, the TQ_ASSERT statement will output the following
+    message using the qWarning() function:
+    \code
+	ASSERT: "b != 0" in div.cpp (9)
+    \endcode
+
+    \sa qWarning(), \link debug.html Debugging\endlink
+*/
+
+
+/*!
+    \fn void TQ_CHECK_PTR( void *p )
+
+    \relates TQApplication
+
+    If \a p is 0, prints a warning message containing the source code file
+    name and line number, saying that the program ran out of memory.
+
+    This is really a macro defined in \c tqglobal.h.
+
+    Example:
+    \code
+	int *a;
+
+	TQ_CHECK_PTR( a = new int[80] );  // WRONG!
+
+	a = new (nothrow) int[80];       // Right
+	TQ_CHECK_PTR( a );
+    \endcode
+
+    \sa qWarning(), \link debug.html Debugging\endlink
+*/
+
+
+//
+// The TQ_CHECK_PTR macro calls this function to check if an allocation went ok.
+//
+#if (TQT_VERSION-0 >= 0x040000)
+#if defined(TQ_CC_GNU)
+#warning "Change TQ_CHECK_PTR to '{if ((p)==0) qt_check_pointer(__FILE__,__LINE__);}'"
+#warning "No need for qt_check_pointer() to return a value - make it void!"
+#endif
+#endif
+bool qt_check_pointer( bool c, const char *n, int l )
+{
+    if ( c )
+	qWarning( "In file %s, line %d: Out of memory", n, l );
+    return TRUE;
+}
+
+
+static bool firstObsoleteWarning(const char *obj, const char *oldfunc )
+{
+    static TQAsciiDict<int> *obsoleteDict = 0;
+    if ( !obsoleteDict ) {			// first time func is called
+	obsoleteDict = new TQAsciiDict<int>;
+#if defined(TQT_DEBUG)
+	qDebug(
+      "You are using obsolete functions in the TQt library. Call the function\n"
+      "tqSuppressObsoleteWarnings() to suppress obsolete warnings.\n"
+	     );
+#endif
+    }
+    TQCString s( obj );
+    s += "::";
+    s += oldfunc;
+    if ( obsoleteDict->tqfind(s.data()) == 0 ) {
+	obsoleteDict->insert( s.data(), (int*)1 );	// anything different from 0
+	return TRUE;
+    }
+    return FALSE;
+}
+
+static bool suppressObsolete = FALSE;
+
+void tqSuppressObsoleteWarnings( bool suppress )
+{
+    suppressObsolete = suppress;
+}
+
+void qObsolete(	 const char *obj, const char *oldfunc, const char *newfunc )
+{
+    if ( suppressObsolete )
+	return;
+    if ( !firstObsoleteWarning(obj, oldfunc) )
+	return;
+    if ( obj )
+	qDebug( "%s::%s: This function is obsolete, use %s instead.",
+	       obj, oldfunc, newfunc );
+    else
+	qDebug( "%s: This function is obsolete, use %s instead.",
+	       oldfunc, newfunc );
+}
+
+void qObsolete(	 const char *obj, const char *oldfunc )
+{
+    if ( suppressObsolete )
+	return;
+    if ( !firstObsoleteWarning(obj, oldfunc) )
+	return;
+    if ( obj )
+	qDebug( "%s::%s: This function is obsolete.", obj, oldfunc );
+    else
+	qDebug( "%s: This function is obsolete.", oldfunc );
+}
+
+void qObsolete(	 const char *message )
+{
+    if ( suppressObsolete )
+	return;
+    if ( !firstObsoleteWarning( "TQt", message) )
+	return;
+    qDebug( "%s", message );
+}
+
+
+/*!
+    \relates TQApplication
+
+    Installs a TQt message handler \a h. Returns a pointer to the
+    message handler previously defined.
+
+    The message handler is a function that prints out debug messages,
+    warnings and fatal error messages. The TQt library (debug version)
+    tqcontains hundreds of warning messages that are printed when
+    internal errors (usually invalid function arguments) occur. If you
+    implement your own message handler, you get total control of these
+    messages.
+
+    The default message handler prints the message to the standard
+    output under X11 or to the debugger under Windows. If it is a
+    fatal message, the application aborts immediately.
+
+    Only one message handler can be defined, since this is usually
+    done on an application-wide basis to control debug output.
+
+    To restore the message handler, call \c tqInstallMsgHandler(0).
+
+    Example:
+    \code
+	#include <tqapplication.h>
+	#include <stdio.h>
+	#include <stdlib.h>
+
+	void myMessageOutput( TQtMsgType type, const char *msg )
+	{
+	    switch ( type ) {
+		case TQtDebugMsg:
+		    fprintf( stderr, "Debug: %s\n", msg );
+		    break;
+		case TQtWarningMsg:
+		    fprintf( stderr, "Warning: %s\n", msg );
+		    break;
+		case TQtFatalMsg:
+		    fprintf( stderr, "Fatal: %s\n", msg );
+		    abort();			// deliberately core dump
+	    }
+	}
+
+	int main( int argc, char **argv )
+	{
+	    tqInstallMsgHandler( myMessageOutput );
+	    TQApplication a( argc, argv );
+	    ...
+	    return a.exec();
+	}
+    \endcode
+
+    \sa qDebug(), qWarning(), qFatal(), \link debug.html Debugging\endlink
+*/
+
+TQtMsgHandler tqInstallMsgHandler( TQtMsgHandler h )
+{
+    TQtMsgHandler old = handler;
+    handler = h;
+    return old;
+}
+
+
+/*
+    Dijkstra's bisection algorithm to tqfind the square root as an integer.
+    Deliberately not exported as part of the TQt API, but used in both
+    qsimplerichtext.cpp and qgfxraster_qws.cpp
+*/
+unsigned int qt_int_sqrt( unsigned int n )
+{
+    // n must be in the range 0...UINT_MAX/2-1
+    if ( n >= ( UINT_MAX>>2 ) ) {
+	unsigned int r = 2 * qt_int_sqrt( n / 4 );
+	unsigned int r2 = r + 1;
+	return ( n >= r2 * r2 ) ? r2 : r;
+    }
+    uint h, p= 0, q= 1, r= n;
+    while ( q <= n )
+        q <<= 2;
+    while ( q != 1 ) {
+        q >>= 2;
+        h= p + q;
+        p >>= 1;
+        if ( r >= h ) {
+            p += q;
+            r -= h;
+        }
+    }
+    return p;
+}
+
diff --git a/tqtinterface/qt4/src/tools/tqglobal.h b/tqtinterface/qt4/src/tools/tqglobal.h
new file mode 100644
index 0000000..3fe0fb0
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqglobal.h
@@ -0,0 +1,1135 @@
+/****************************************************************************
+**
+** Global type declarations and definitions
+**
+** Created : 920529
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQGLOBAL_H
+#define TQGLOBAL_H
+
+#define TQT_VERSION_STR   "3.4.0"
+/*
+   TQT_VERSION is (major << 16) + (minor << 8) + patch.
+ */
+#define TQT_VERSION 0x030400
+
+/*
+   The operating system, must be one of: (TQ_OS_x)
+
+     MACX	- Mac OS X
+     MAC9	- Mac OS 9
+     DARWIN     - Darwin OS (Without Mac OS X)
+     MSDOS	- MS-DOS and Windows
+     OS2	- OS/2
+     OS2EMX	- XFree86 on OS/2 (not PM)
+     WIN32	- Win32 (Windows 95/98/ME and Windows NT/2000/XP)
+     CYGWIN	- Cygwin
+     SOLARIS	- Sun Solaris
+     HPUX	- HP-UX
+     ULTRIX	- DEC Ultrix
+     LINUX	- Linux
+     FREEBSD	- FreeBSD
+     NETBSD	- NetBSD
+     OPENBSD	- OpenBSD
+     BSDI	- BSD/OS
+     IRIX	- SGI Irix
+     OSF	- HP Tru64 UNIX
+     SCO	- SCO OpenServer 5
+     UNIXWARE	- UnixWare 7, Open UNIX 8
+     AIX	- AIX
+     HURD	- GNU Hurd
+     DGUX	- DG/UX
+     RELIANT	- Reliant UNIX
+     DYNIX	- DYNIX/ptx
+     TQNX	- TQNX
+     TQNX6	- TQNX RTP 6.1
+     LYNX	- LynxOS
+     BSD4	- Any BSD 4.4 system
+     UNIX	- Any UNIX BSD/SYSV system
+*/
+
+#if defined(__DARWIN_X11__)
+#  define TQ_OS_DARWIN
+#elif defined(__APPLE__) && (defined(__GNUC__) || defined(__xlC__))
+#  define TQ_OS_MACX
+#elif defined(__MACOSX__)
+#  define TQ_OS_MACX
+#elif defined(macintosh)
+#  define TQ_OS_MAC9
+#elif defined(__CYGWIN__)
+#  define TQ_OS_CYGWIN
+#elif defined(MSDOS) || defined(_MSDOS)
+#  define TQ_OS_MSDOS
+#elif defined(__OS2__)
+#  if defined(__EMX__)
+#    define TQ_OS_OS2EMX
+#  else
+#    define TQ_OS_OS2
+#  endif
+#elif !defined(SAG_COM) && (defined(WIN64) || defined(_WIN64) || defined(__WIN64__))
+#  define TQ_OS_WIN32
+#  define TQ_OS_WIN64
+#elif !defined(SAG_COM) && (defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__))
+#  define TQ_OS_WIN32
+#elif defined(__MWERKS__) && defined(__INTEL__)
+#  define TQ_OS_WIN32
+#elif defined(__sun) || defined(sun)
+#  define TQ_OS_SOLARIS
+#elif defined(hpux) || defined(__hpux)
+#  define TQ_OS_HPUX
+#elif defined(__ultrix) || defined(ultrix)
+#  define TQ_OS_ULTRIX
+#elif defined(sinix)
+#  define TQ_OS_RELIANT
+#elif defined(__linux__) || defined(__linux)
+#  define TQ_OS_LINUX
+#elif defined(__FreeBSD__) || defined(__DragonFly__)
+#  define TQ_OS_FREEBSD
+#  define TQ_OS_BSD4
+#elif defined(__NetBSD__)
+#  define TQ_OS_NETBSD
+#  define TQ_OS_BSD4
+#elif defined(__OpenBSD__)
+#  define TQ_OS_OPENBSD
+#  define TQ_OS_BSD4
+#elif defined(__bsdi__)
+#  define TQ_OS_BSDI
+#  define TQ_OS_BSD4
+#elif defined(__sgi)
+#  define TQ_OS_IRIX
+#elif defined(__osf__)
+#  define TQ_OS_OSF
+#elif defined(_AIX)
+#  define TQ_OS_AIX
+#elif defined(__Lynx__)
+#  define TQ_OS_LYNX
+#elif defined(__GNU_HURD__)
+#  define TQ_OS_HURD
+#elif defined(__DGUX__)
+#  define TQ_OS_DGUX
+#elif defined(__TQNXNTO__)
+#  define TQ_OS_TQNX6
+#elif defined(__TQNX__)
+#  define TQ_OS_TQNX
+#elif defined(_SETQUENT_)
+#  define TQ_OS_DYNIX
+#elif defined(_SCO_DS)                   /* SCO OpenServer 5 + GCC */
+#  define TQ_OS_SCO
+#elif defined(__USLC__)                  /* all SCO platforms + UDK or OUDK */
+#  define TQ_OS_UNIXWARE
+#  define TQ_OS_UNIXWARE7
+#elif defined(__svr4__) && defined(i386) /* Open UNIX 8 + GCC */
+#  define TQ_OS_UNIXWARE
+#  define TQ_OS_UNIXWARE7
+#elif defined(__MAKEDEPEND__)
+#else
+#  error "TQt has not been ported to this OS - talk to qt-bugs@trolltech.com"
+#endif
+
+#if defined(TQ_OS_WIN32) || defined(TQ_OS_WIN64)
+#  define TQ_OS_WIN
+#endif
+
+#if defined(TQ_OS_MAC9) || defined(TQ_OS_MACX)
+#  define TQ_OS_MAC
+#endif
+
+#if defined(TQ_OS_MAC9) || defined(TQ_OS_MSDOS) || defined(TQ_OS_OS2) || defined(TQ_OS_WIN)
+#  undef TQ_OS_UNIX
+#elif !defined(TQ_OS_UNIX)
+#  define TQ_OS_UNIX
+#endif
+
+#if defined(TQ_OS_MACX)
+#  ifdef MAC_OS_X_VERSION_MIN_RETQUIRED
+#    undef MAC_OS_X_VERSION_MIN_RETQUIRED
+#  endif
+#  define MAC_OS_X_VERSION_MIN_RETQUIRED MAC_OS_X_VERSION_10_2
+#  include <AvailabilityMacros.h>
+#  if !defined(MAC_OS_X_VERSION_10_3)
+#     define MAC_OS_X_VERSION_10_3 MAC_OS_X_VERSION_10_2 + 1
+#  endif
+#  if !defined(MAC_OS_X_VERSION_10_4)
+#       define MAC_OS_X_VERSION_10_4 MAC_OS_X_VERSION_10_3 + 1
+#  endif
+#  if (MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_4)
+#    error "This version of Mac OS X is unsupported"
+#  endif
+#endif
+
+
+/*
+   The compiler, must be one of: (TQ_CC_x)
+
+     SYM	- Symantec C++ for both PC and Macintosh
+     MPW	- MPW C++
+     MWERKS	- Metrowerks CodeWarrior
+     MSVC	- Microsoft Visual C/C++, Intel C++ for Windows
+     BOR	- Borland/Turbo C++
+     WAT	- Watcom C++
+     GNU	- GNU C++
+     COMEAU	- Comeau C++
+     EDG	- Edison Design Group C++
+     OC		- CenterLine C++
+     SUN	- Sun WorkShop, Forte Developer, or Sun ONE Studio C++
+     MIPS	- MIPSpro C++
+     DEC	- DEC C++
+     HP		- HPUX C++
+     HPACC	- HPUX ANSI C++
+     USLC	- SCO OUDK, UDK, and UnixWare 2.X C++
+     CDS	- Reliant C++
+     KAI	- KAI C++
+     INTEL	- Intel C++ for Linux, Intel C++ for Windows
+     HIGHC	- MetaWare High C/C++
+     PGI	- Portland Group C++
+     GHS	- Green Hills Optimizing C++ Compilers
+
+   Should be sorted most to least authoritative.
+*/
+
+/* Symantec C++ is now Digital Mars */
+#if defined(__DMC__) || defined(__SC__)
+#  define TQ_CC_SYM
+/* "explicit" semantics implemented in 8.1e but keyword recognized since 7.5 */
+#  if defined(__SC__) && __SC__ < 0x750
+#    define TQ_NO_EXPLICIT_KEYWORD
+#  endif
+#  define TQ_NO_USING_KEYWORD
+#  if !defined(_CPPUNWIND)
+#    define TQ_NO_EXCEPTIONS
+#  endif
+
+#elif defined(applec)
+#  define TQ_CC_MPW
+#  define TQ_NO_BOOL_TYPE
+#  define TQ_NO_EXPLICIT_KEYWORD
+#  define TQ_NO_USING_KEYWORD
+
+#elif defined(__MWERKS__)
+#  define TQ_CC_MWERKS
+/* "explicit" recognized since 4.0d1 */
+#  define TQMAC_PASCAL pascal
+
+#elif defined(_MSC_VER)
+#  define TQ_CC_MSVC
+/* proper support of bool for _MSC_VER >= 1100 */
+#  define TQ_CANNOT_DELETE_CONSTANT
+#  define TQ_INLINE_TEMPLATES inline
+/* Visual C++.Net issues for _MSC_VER >= 1300 */
+#  if _MSC_VER >= 1300
+#    define TQ_CC_MSVC_NET
+#    if _MSC_VER < 1310 || (defined(TQ_OS_WIN64) && defined(_M_IA64))
+#      define TQ_TYPENAME
+#    endif
+#  endif
+/* Intel C++ disguising as Visual C++: the `using' keyword avoids warnings */
+#  if defined(__INTEL_COMPILER)
+#    define TQ_CC_INTEL
+#    if !defined(__EXCEPTIONS)
+#      define TQ_NO_EXCEPTIONS
+#    endif
+#  else
+#    define TQ_NO_USING_KEYWORD /* ### check "using" status */
+#  endif
+
+#elif defined(__BORLANDC__) || defined(__TURBOC__)
+#  define TQ_CC_BOR
+#  if __BORLANDC__ < 0x502
+#    define TQ_NO_BOOL_TYPE
+#    define TQ_NO_EXPLICIT_KEYWORD
+#  endif
+#  define TQ_NO_USING_KEYWORD /* ### check "using" status */
+
+#elif defined(__WATCOMC__)
+#  define TQ_CC_WAT
+#  if defined(TQ_OS_TQNX4)
+/* compiler flags */
+#    define TQ_TYPENAME
+#    define TQ_NO_BOOL_TYPE
+#    define TQ_CANNOT_DELETE_CONSTANT
+#    define mutable
+/* ??? */
+#    define TQ_BROKEN_TEMPLATE_SPECIALIZATION
+/* no template classes in TQVariant */
+#    define TQT_NO_TEMPLATE_VARIANT
+/* Wcc does not fill in functions needed by valuelists, maps, and
+   valuestacks implicitly */
+#    define TQ_FULL_TEMPLATE_INSTANTIATION
+/* can we just compare the structures? */
+#    define TQ_FULL_TEMPLATE_INSTANTIATION_MEMCMP
+/* these are not useful to our customers */
+#    define TQT_TQWS_NO_SHM
+#    define TQT_NO_TQWS_MULTIPROCESS
+#    define TQT_NO_SQL
+#    define TQT_NO_TQWS_CURSOR
+#  endif
+
+#elif defined(__GNUC__)
+#  define TQ_CC_GNU
+#  define TQ_C_CALLBACKS
+#  if __GNUC__ == 2 && __GNUC_MINOR__ <= 7
+#    define TQ_FULL_TEMPLATE_INSTANTIATION
+#  endif
+/* GCC 2.95 knows "using" but does not support it correctly */
+#  if __GNUC__ == 2 && __GNUC_MINOR__ <= 95
+#    define TQ_NO_USING_KEYWORD
+#  endif
+/* GCC 3.1 and GCC 3.2 wrongly define _SB_CTYPE_MACROS on HP-UX */
+#  if defined(TQ_OS_HPUX) && __GNUC__ == 3 && __GNUC_MINOR__ >= 1
+#    define TQ_WRONG_SB_CTYPE_MACROS
+#  endif
+
+/* ARM gcc pads structs to 32 bits, even when they contain a single
+   char, or short.  We tell gcc to pack TQChars to 16 bits, to avoid
+   TQString bloat. However, gcc 3.4 doesn't allow us to create references to
+   members of a packed struct. (Pointers are OK, because then you
+   supposedly know what you are doing.) */
+#  if (defined(__arm__) || defined(__ARMEL__)) && !defined(TQT_TQMOC_CPP)
+#    define TQ_PACKED __attribute__ ((packed))
+#    if __GNUC__ == 3 && __GNUC_MINOR__ >= 4
+#      define TQ_NO_PACKED_REFERENCE
+#    endif
+#  endif
+#  if !defined(__EXCEPTIONS)
+#    define TQ_NO_EXCEPTIONS
+#  endif
+
+/* IBM compiler versions are a bit messy. There are actually two products:
+   the C product, and the C++ product. The C++ compiler is always packaged
+   with the latest version of the C compiler. Version numbers do not always
+   match. This little table (I'm not sure it's accurate) should be helpful:
+
+   C++ product                C product
+
+            C Set 3.1         C Compiler 3.0
+                  ...         ...
+   C++ Compiler 3.6.6         C Compiler 4.3
+                  ...         ...
+   Visual Age C++ 4.0         ...
+                  ...         ...
+   Visual Age C++ 5.0         C Compiler 5.0
+                  ...         ...
+   Visual Age C++ 6.0         C Compiler 6.0
+
+   Now:
+   __xlC__    is the version of the C compiler in hexadecimal notation
+              is only an approximation of the C++ compiler version
+   __IBMCPP__ is the version of the C++ compiler in decimal notation
+              but it is not defined on older compilers like C Set 3.1 */
+#elif defined(__xlC__)
+#  define TQ_CC_XLC
+#  define TQ_FULL_TEMPLATE_INSTANTIATION
+#  if __xlC__ < 0x400
+#    define TQ_NO_BOOL_TYPE
+#    define TQ_NO_EXPLICIT_KEYWORD
+#    define TQ_NO_USING_KEYWORD
+#    define TQ_TYPENAME
+#    define TQ_INLINE_TEMPLATES inline
+#    define TQ_BROKEN_TEMPLATE_SPECIALIZATION
+#    define TQ_CANNOT_DELETE_CONSTANT
+#  endif
+
+/* Older versions of DEC C++ do not define __EDG__ or __EDG - observed
+   on DEC C++ V5.5-004. New versions do define  __EDG__ - observed on
+   Compaq C++ V6.3-002.
+   This compiler is different enough from other EDG compilers to handle
+   it separately anyway. */
+#elif defined(__DECCXX) || defined(__DECC)
+#  define TQ_CC_DEC
+/* Compaq C++ V6 compilers are EDG-based but I'm not sure about older
+   DEC C++ V5 compilers. */
+#  if defined(__EDG__)
+#    define TQ_CC_EDG
+#  endif
+/* Compaq have disabled EDG's _BOOL macro and use _BOOL_EXISTS instead
+   - observed on Compaq C++ V6.3-002.
+   In any case versions prior to Compaq C++ V6.0-005 do not have bool. */
+#  if !defined(_BOOL_EXISTS)
+#    define TQ_NO_BOOL_TYPE
+#  endif
+/* Spurious (?) error messages observed on Compaq C++ V6.5-014. */
+#  define TQ_NO_USING_KEYWORD
+/* Apply to all versions prior to Compaq C++ V6.0-000 - observed on
+   DEC C++ V5.5-004. */
+#  if __DECCXX_VER < 60060000
+#    define TQ_TYPENAME
+#    define TQ_BROKEN_TEMPLATE_SPECIALIZATION
+#    define TQ_CANNOT_DELETE_CONSTANT
+#  endif
+/* avoid undefined symbol problems with out-of-line template members */
+#  define TQ_INLINE_TEMPLATES inline
+
+/* Compilers with EDG front end are similar. To detect them we test:
+   __EDG documented by SGI, observed on MIPSpro 7.3.1.1 and KAI C++ 4.0b
+   __EDG__ documented in EDG online docs, observed on Compaq C++ V6.3-002 */
+#elif defined(__EDG) || defined(__EDG__)
+#  define TQ_CC_EDG
+/* From the EDG documentation (does not seem to apply to Compaq 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)
+#    define TQ_NO_BOOL_TYPE
+#  endif
+
+/* The Comeau compiler is based on EDG and does define __EDG__ */
+#  if defined(__COMO__)
+#    define TQ_CC_COMEAU
+#    define TQ_C_CALLBACKS
+
+/* The `using' keyword was introduced to avoid KAI C++ warnings
+   but it's now causing KAI C++ errors instead. The standard is
+   unclear about the use of this keyword, and in practice every
+   compiler is using its own set of rules. Forget it. */
+#  elif defined(__KCC)
+#    define TQ_CC_KAI
+#    if !defined(_EXCEPTIONS)
+#      define TQ_NO_EXCEPTIONS
+#    endif
+#    define TQ_NO_USING_KEYWORD
+
+/* Using the `using' keyword avoids Intel C++ for Linux warnings */
+#  elif defined(__INTEL_COMPILER)
+#    define TQ_CC_INTEL
+#    if !defined(__EXCEPTIONS)
+#      define TQ_NO_EXCEPTIONS
+#    endif
+
+/* The Portland Group compiler is based on EDG and does define __EDG__ */
+#  elif defined(__PGI)
+#    define TQ_CC_PGI
+#    if !defined(__EXCEPTIONS)
+#      define TQ_NO_EXCEPTIONS
+#    endif
+
+/* Never tested! */
+#  elif defined(__ghs)
+#    define TQ_CC_GHS
+
+/* The UnixWare 7 UDK compiler is based on EDG and does define __EDG__ */
+#  elif defined(__USLC__) && defined(__SCO_VERSION__)
+#    define TQ_CC_USLC
+/* The latest UDK 7.1.1b does not need this, but previous versions do */
+#    if !defined(__SCO_VERSION__) || (__SCO_VERSION__ < 302200010)
+#      define TQ_INLINE_TEMPLATES inline
+#    endif
+#    define TQ_NO_USING_KEYWORD /* ### check "using" status */
+
+/* Never tested! */
+#  elif defined(CENTERLINE_CLPP) || defined(OBJECTCENTER)
+#    define TQ_CC_OC
+#    define TQ_NO_USING_KEYWORD
+
+/* CDS++ defines __EDG__ although this is not documented in the Reliant
+   documentation. It also follows conventions like _BOOL and this documented */
+#  elif defined(sinix)
+#    define TQ_CC_CDS
+#    define TQ_NO_USING_KEYWORD
+#    if defined(__cplusplus) && (__cplusplus < 2) /* Cfront C++ mode */
+#      define TQ_NO_EXCEPTIONS
+#    endif
+
+/* The MIPSpro compiler in o32 mode is based on EDG but disables features
+   such as template specialization nevertheless */
+#  elif defined(__sgi)
+#    define TQ_CC_MIPS
+#    if defined(_MIPS_SIM) && (_MIPS_SIM == _ABIO32) /* o32 ABI */
+#      define TQ_TYPENAME
+#      define TQ_BROKEN_TEMPLATE_SPECIALIZATION
+#      define TQ_NO_EXPLICIT_KEYWORD
+#      define TQ_INLINE_TEMPLATES inline
+#    elif defined(_COMPILER_VERSION) && (_COMPILER_VERSION < 730) /* 7.2 */
+#      define TQ_TYPENAME
+#      define TQ_BROKEN_TEMPLATE_SPECIALIZATION
+#    endif
+#    define TQ_NO_USING_KEYWORD /* ### check "using" status */
+#    if defined(_COMPILER_VERSION) && (_COMPILER_VERSION >= 740)
+#      pragma set woff 3624,3625, 3649 /* turn off some harmless warnings */
+#    endif
+#  endif
+
+/* The older UnixWare 2.X compiler? */
+#elif defined(__USLC__)
+#  define TQ_CC_USLC
+#  define TQ_TYPENAME
+#  define TQ_NO_BOOL_TYPE
+#  define TQ_NO_EXPLICIT_KEYWORD
+#  define TQ_NO_USING_KEYWORD
+#  define TQ_INLINE_TEMPLATES inline
+
+/* Never tested! */
+#elif defined(__HIGHC__)
+#  define TQ_CC_HIGHC
+
+#elif defined(__SUNPRO_CC) || defined(__SUNPRO_C)
+#  define TQ_CC_SUN
+/* 5.0 compiler or better
+    'bool' is enabled by default but can be disabled using -features=nobool
+    in which case _BOOL is not defined
+        this is the default in 4.2 compatibility mode triggered by -compat=4 */
+#  if __SUNPRO_CC >= 0x500
+#    if !defined(_BOOL)
+#      define TQ_NO_BOOL_TYPE
+#    endif
+#    if defined(__SUNPRO_CC_COMPAT) && (__SUNPRO_CC_COMPAT <= 4)
+#      define TQ_NO_USING_KEYWORD
+#    endif
+#    define TQ_C_CALLBACKS
+/* 4.2 compiler or older */
+#  else
+#    define TQ_NO_BOOL_TYPE
+#    define TQ_NO_EXPLICIT_KEYWORD
+#    define TQ_NO_USING_KEYWORD
+#  endif
+
+/* CDS++ does not seem to define __EDG__ or __EDG according to Reliant
+   documentation but nevertheless uses EDG conventions like _BOOL */
+#elif defined(sinix)
+#  define TQ_CC_EDG
+#  define TQ_CC_CDS
+#  if !defined(_BOOL)
+#    define TQ_NO_BOOL_TYPE
+#  endif
+#  define TQ_BROKEN_TEMPLATE_SPECIALIZATION
+
+#elif defined(TQ_OS_HPUX)
+/* __HP_aCC was not defined in first aCC releases */
+#  if defined(__HP_aCC) || __cplusplus >= 199707L
+#    define TQ_CC_HPACC
+#  else
+#    define TQ_CC_HP
+#    define TQ_NO_BOOL_TYPE
+#    define TQ_FULL_TEMPLATE_INSTANTIATION
+#    define TQ_BROKEN_TEMPLATE_SPECIALIZATION
+#    define TQ_NO_EXPLICIT_KEYWORD
+#  endif
+#  define TQ_NO_USING_KEYWORD /* ### check "using" status */
+
+#else
+#  error "TQt has not been tested with this compiler - talk to qt-bugs@trolltech.com"
+#endif
+
+#ifndef TQ_PACKED
+#  define TQ_PACKED
+#endif
+
+
+/*
+   The window system, must be one of: (TQ_WS_x)
+
+     MACX	- Mac OS X
+     MAC9	- Mac OS 9
+     TQWS	- TQt/Embedded
+     WIN32	- Windows
+     X11	- X Window System
+     PM		- unsupported
+     WIN16	- unsupported
+*/
+
+#if defined(TQ_OS_MAC9)
+#  define TQ_WS_MAC9
+#elif defined(TQ_OS_MSDOS)
+#  define TQ_WS_WIN16
+#  error "TQt requires Win32 and does not work with Windows 3.x"
+#elif defined(_WIN32_X11_)
+#  define TQ_WS_X11
+#elif defined(TQ_OS_WIN32)
+#  define TQ_WS_WIN32
+#  if defined(TQ_OS_WIN64)
+#    define TQ_WS_WIN64
+#  endif
+#elif defined(TQ_OS_OS2)
+#  define TQ_WS_PM
+#  error "TQt does not work with OS/2 Presentation Manager or Workplace Shell"
+#elif defined(TQ_OS_UNIX)
+#  if defined(TQWS)
+#    define TQ_WS_TQWS
+#    define TQT_NO_TQWS_IM
+#  elif defined(TQ_OS_MACX)
+#    define TQ_WS_MACX
+#  else
+#    define TQ_WS_X11
+#  endif
+#endif
+#if defined(TQ_OS_MAC) && !defined(TQMAC_PASCAL)
+#  define TQMAC_PASCAL
+#endif
+
+#if defined(TQ_WS_WIN16) || defined(TQ_WS_WIN32)
+#  define TQ_WS_WIN
+#endif
+
+#if (defined(TQ_WS_MAC9) || defined(TQ_WS_MACX)) && !defined(TQ_WS_TQWS) && !defined(TQ_WS_X11)
+#  define TQ_WS_MAC
+#endif
+
+
+/*
+   Some classes do not permit copies to be made of an object.
+   These classes tqcontains a private copy constructor and operator=
+   to disable copying (the compiler gives an error message).
+   Undefine TQ_DISABLE_COPY to turn off this checking.
+*/
+
+#define TQ_DISABLE_COPY
+
+#if defined(__cplusplus)
+
+
+//
+// Useful type definitions for TQt
+//
+
+#if defined(TQ_NO_BOOL_TYPE)
+#if defined(TQ_CC_HP)
+// bool is an unsupported reserved keyword in later versions
+#define bool int
+#else
+typedef int bool;
+#endif
+#endif
+
+typedef unsigned char   uchar;
+typedef unsigned short  ushort;
+typedef unsigned	uint;
+typedef unsigned long   ulong;
+typedef char	       *pchar;
+typedef uchar	       *puchar;
+typedef const char     *pcchar;
+
+
+//
+// Constant bool values
+//
+
+#ifndef TRUE
+const bool FALSE = 0;
+const bool TRUE = !0;
+#endif
+#if defined(__WATCOMC__)
+#  if defined(TQ_OS_TQNX4)
+const bool false = FALSE;
+const bool true = TRUE;
+#  endif
+#endif
+
+//
+// Proper for-scoping
+// ### turn on in 4.0
+
+#if 0 && defined(TQ_CC_MSVC) && !defined(TQ_CC_MSVC_NET)
+#  define for if(0){}else for
+#endif
+
+//
+// Use the "explicit" keyword on platforms that support it.
+//
+
+#if !defined(TQ_NO_EXPLICIT_KEYWORD)
+#  define TQ_EXPLICIT explicit
+#else
+#  define TQ_EXPLICIT
+#endif
+
+
+//
+// Workaround for static const members on MSVC++.
+//
+
+#if defined(TQ_CC_MSVC)
+#  define TQT_STATIC_CONST static
+#  define TQT_STATIC_CONST_IMPL
+#else
+#  define TQT_STATIC_CONST static const
+#  define TQT_STATIC_CONST_IMPL const
+#endif
+
+
+//
+// Utility macros and inline functions
+//
+
+#define TQMAX(a, b)	((b) < (a) ? (a) : (b))
+#define TQMIN(a, b)	((a) < (b) ? (a) : (b))
+#define TQABS(a)	((a) >= 0  ? (a) : -(a))
+
+inline int tqRound( double d )
+{
+    return d >= 0.0 ? int(d + 0.5) : int( d - ((int)d-1) + 0.5 ) + ((int)d-1);
+}
+
+
+//
+// Size-dependent types (architechture-dependent byte order)
+//
+
+#if !defined(TQT_CLEAN_NAMESPACE)
+// source compatibility with TQt 1.x
+typedef signed char		INT8;		// 8 bit signed
+typedef unsigned char		UINT8;		// 8 bit unsigned
+typedef short			INT16;		// 16 bit signed
+typedef unsigned short		UINT16;		// 16 bit unsigned
+// typedef int			INT32;		// 32 bit signed	// [FIXME] Conflicts with Xorg headers
+typedef unsigned int		UINT32;		// 32 bit unsigned
+#endif
+
+typedef signed char		TQ_INT8;		// 8 bit signed
+typedef unsigned char		TQ_UINT8;	// 8 bit unsigned
+typedef short			TQ_INT16;	// 16 bit signed
+typedef unsigned short		TQ_UINT16;	// 16 bit unsigned
+typedef int			TQ_INT32;	// 32 bit signed
+typedef unsigned int		TQ_UINT32;	// 32 bit unsigned
+#if defined(TQ_OS_WIN64)
+typedef __int64			TQ_LONG;		// word up to 64 bit signed
+typedef unsigned __int64	TQ_ULONG;	// word up to 64 bit unsigned
+#else
+typedef long			TQ_LONG;		// word up to 64 bit signed
+typedef unsigned long		TQ_ULONG;	// word up to 64 bit unsigned
+#endif
+#if defined(TQ_OS_WIN) && !defined(TQ_CC_GNU)
+#  define TQ_INT64_C(c) 		c ## i64	// signed 64 bit constant
+#  define TQ_UINT64_C(c)		c ## ui64	// unsigned 64 bit constant
+typedef __int64			TQ_INT64;	// 64 bit signed
+typedef unsigned __int64	TQ_UINT64;	// 64 bit unsigned
+#else
+#  define TQ_INT64_C(c) 		c ## LL		// signed 64 bit constant
+#  define TQ_UINT64_C(c)		c ## ULL	// unsigned 64 bit constant
+typedef long long		TQ_INT64;	// 64 bit signed
+typedef unsigned long long	TQ_UINT64;	// 64 bit unsigned
+#endif
+typedef TQ_INT64			TQ_LLONG;	// signed long long
+typedef TQ_UINT64		TQ_ULLONG;	// unsigned long long
+
+#if defined(TQ_OS_MACX) && !defined(TQT_LARGEFILE_SUPPORT)
+#  define TQT_LARGEFILE_SUPPORT 64
+#endif
+#if defined(TQT_LARGEFILE_SUPPORT)
+    typedef TQ_ULLONG TQtOffset;
+#else
+    typedef TQ_ULONG TQtOffset;
+#endif
+
+
+//
+// Data stream functions is provided by many classes (defined in tqdatastream.h)
+//
+
+class TQDataStream;
+
+
+//
+// Feature subsetting
+//
+// Note that disabling some features will produce a libtqt that is not
+// compatible with other libtqt builds. Such modifications are only
+// supported on TQt/Embedded where reducing the library size is important
+// and where the application-suite is often a fixed set.
+//
+
+#if !defined(TQT_TQMOC)
+#if defined(TQCONFIG_LOCAL)
+#include "tqconfig-local.h"
+#elif defined(TQCONFIG_MINIMAL)
+#include "tqconfig-minimal.h"
+#elif defined(TQCONFIG_SMALL)
+#include "tqconfig-small.h"
+#elif defined(TQCONFIG_MEDIUM)
+#include "tqconfig-medium.h"
+#elif defined(TQCONFIG_LARGE)
+#include "tqconfig-large.h"
+#else // everything...
+#include "tqconfig.h"
+#endif
+#endif
+
+
+#ifndef TQT_BUILD_KEY
+#define TQT_BUILD_KEY "unspecified"
+#endif
+
+// prune to local config
+#include "tqmodules.h"
+#ifndef TQT_MODULE_DIALOGS
+# define TQT_NO_DIALOG
+#endif
+#ifndef TQT_MODULE_ICONVIEW
+# define TQT_NO_ICONVIEW
+#endif
+#ifndef TQT_MODULE_WORKSPACE
+# define TQT_NO_WORKSPACE
+#endif
+#ifndef TQT_MODULE_NETWORK
+#define TQT_NO_NETWORK
+#endif
+#ifndef TQT_MODULE_CANVAS
+# define TQT_NO_CANVAS
+#endif
+#ifndef TQT_MODULE_TABLE
+#define TQT_NO_TABLE
+#endif
+#ifndef TQT_MODULE_XML
+# define TQT_NO_XML
+#endif
+#ifndef TQT_MODULE_OPENGL
+# define TQT_NO_OPENGL
+#endif
+#if !defined(TQT_MODULE_SQL)
+# define TQT_NO_SQL
+#endif
+
+#if defined(TQ_WS_MAC9)
+//No need for menu merging
+#  ifndef TQMAC_TQMENUBAR_NO_MERGE
+#    define TQMAC_TQMENUBAR_NO_MERGE
+#  endif
+//Mac9 does not use quartz
+#  ifndef TQMAC_NO_TQUARTZ
+#    define TQMAC_NO_TQUARTZ
+#  endif
+#  ifndef TQMAC_TQMENUBAR_NO_EVENT
+#    define TQMAC_TQMENUBAR_NO_EVENT
+#  endif
+#endif
+#if defined(TQ_WS_MACX) //for no nobody uses quartz, just putting in first level hooks
+#  ifndef TQMAC_NO_TQUARTZ
+#    define TQMAC_NO_TQUARTZ
+#  endif
+#  ifndef TQMAC_TQMENUBAR_NO_EVENT
+#    define TQMAC_TQMENUBAR_NO_EVENT
+#  endif
+#endif
+
+#if !defined(TQ_WS_TQWS) && !defined(TQT_NO_COP)
+#  define TQT_NO_COP
+#endif
+
+#ifndef TQT_H
+#include "tqfeatures.h"
+#endif /* TQT_H */
+
+
+//
+// Create TQt DLL if TQT_DLL is defined (Windows only)
+// or TQT_SHARED is defined (Kylix only)
+//
+
+#if defined(TQ_OS_WIN)
+#  if defined(TQT_NODLL)
+#    undef TQT_MAKEDLL
+#    undef TQT_DLL
+#  elif defined(TQT_MAKEDLL)	/* create a TQt DLL library */
+#    if defined(TQT_DLL)
+#      undef TQT_DLL
+#    endif
+#    define TQ_EXPORT  __declspec(dllexport)
+#    define TQ_TEMPLATEDLL
+#    define TQ_TEMPLATE_EXTERN
+#    undef  TQ_DISABLE_COPY	/* avoid unresolved externals */
+#  elif defined(TQT_DLL)		/* use a TQt DLL library */
+#    define TQ_EXPORT  __declspec(dllimport)
+#    define TQ_TEMPLATEDLL
+#    ifndef TQ_TEMPLATE_EXTERN
+#      if defined(TQ_CC_MSVC_NET)
+#        define TQ_TEMPLATE_EXTERN extern
+#      else
+#        define TQ_TEMPLATE_EXTERN
+#      endif
+#    endif
+#    undef  TQ_DISABLE_COPY	/* avoid unresolved externals */
+#  endif
+#elif defined(TQ_OS_LINUX) && defined(TQ_CC_BOR)
+#  if defined(TQT_SHARED)	/* create a TQt shared library */
+#    define TQ_EXPORT  __declspec(dllexport)
+#    define TQ_TEMPLATEDLL
+#    define TQ_TEMPLATE_EXTERN
+#    undef  TQ_DISABLE_COPY	/* avoid unresolved externals */
+#  else
+#    define TQ_TEMPLATEDLL
+#    define TQ_TEMPLATE_EXTERN
+#    undef  TQ_DISABLE_COPY 	/* avoid unresolved externals */
+#  endif
+#else
+#  undef TQT_MAKEDLL		/* ignore these for other platforms */
+#  undef TQT_DLL
+#endif
+
+#ifndef TQ_EXPORT
+#  define TQ_EXPORT
+#endif
+
+
+//
+// Some platform specific stuff
+//
+
+#if defined(TQ_WS_WIN)
+extern TQ_EXPORT bool qt_wintqunicode;
+#endif
+
+
+//
+// System information
+//
+
+TQ_EXPORT const char *qVersion();
+TQ_EXPORT bool qSysInfo( int *wordSize, bool *bigEndian );
+TQ_EXPORT bool qSharedBuild();
+#if defined(TQ_OS_MAC)
+int qMacVersion();
+#elif defined(TQ_WS_WIN)
+TQ_EXPORT int qWinVersion();
+#if defined(UNICODE)
+#define TQT_WA( uni, ansi ) if ( qt_wintqunicode ) { uni } else { ansi }
+#define TQT_WA_INLINE( uni, ansi ) ( qt_wintqunicode ? uni : ansi )
+#else
+#define TQT_WA( uni, ansi ) ansi
+#define TQT_WA_INLINE( uni, ansi ) ansi
+#endif
+#endif
+
+#ifdef TQ_OS_TEMP
+#ifdef TQT_WA
+#undef TQT_WA
+#undef TQT_WA_INLINE
+#endif
+#define TQT_WA( uni, ansi ) uni
+#define TQT_WA_INLINE( uni, ansi ) ( uni )
+#endif
+
+#ifndef TQ_INLINE_TEMPLATES
+#  define TQ_INLINE_TEMPLATES
+#endif
+
+#ifndef TQ_TYPENAME
+#  define TQ_TYPENAME typename
+#endif
+
+//
+// Use to avoid "unused parameter" warnings
+//
+#define TQ_UNUSED(x) (void)x;
+
+//
+// Debugging and error handling
+//
+
+#if !defined(TQT_NO_CHECK)
+#  define TQT_CHECK_STATE			// check state of objects etc.
+#  define TQT_CHECK_RANGE			// check range of indexes etc.
+#  define TQT_CHECK_NULL				// check null pointers
+#  define TQT_CHECK_MATH				// check math functions
+#endif
+
+#if !defined(TQT_NO_DEBUG) && !defined(TQT_DEBUG)
+#  define TQT_DEBUG				// display debug messages
+#  if !defined(TQT_NO_COMPAT)			// compatibility with TQt 2
+#    if !defined(NO_DEBUG) && !defined(DEBUG)
+#      if !defined(TQ_OS_MACX)			// clash with MacOS X headers
+#        define DEBUG
+#      endif
+#    endif
+#  endif
+#endif
+
+
+TQ_EXPORT void qDebug( const char *, ... )	// print debug message
+#if defined(TQ_CC_GNU) && !defined(__INSURE__)
+    __attribute__ ((format (printf, 1, 2)))
+#endif
+;
+
+TQ_EXPORT void qWarning( const char *, ... )	// print warning message
+#if defined(TQ_CC_GNU) && !defined(__INSURE__)
+    __attribute__ ((format (printf, 1, 2)))
+#endif
+;
+
+TQ_EXPORT void qFatal( const char *, ... )	// print fatal message and exit
+#if defined(TQ_CC_GNU)
+    __attribute__ ((format (printf, 1, 2)))
+#endif
+;
+
+TQ_EXPORT void tqSystemWarning( const char *, int code = -1 );
+
+#if !defined(TQT_CLEAN_NAMESPACE) 		// compatibility with TQt 1
+
+TQ_EXPORT void debug( const char *, ... )	// print debug message
+#if defined(TQ_CC_GNU) && !defined(__INSURE__)
+    __attribute__ ((format (printf, 1, 2)))
+#endif
+;
+
+TQ_EXPORT void warning( const char *, ... )	// print warning message
+#if defined(TQ_CC_GNU) && !defined(__INSURE__)
+    __attribute__ ((format (printf, 1, 2)))
+#endif
+;
+
+TQ_EXPORT void fatal( const char *, ... )	// print fatal message and exit
+#if defined(TQ_CC_GNU) && !defined(__INSURE__)
+    __attribute__ ((format (printf, 1, 2)))
+#endif
+;
+
+#endif // TQT_CLEAN_NAMESPACE
+
+
+#if !defined(TQ_ASSERT)
+#  if defined(TQT_CHECK_STATE)
+#    if defined(TQT_FATAL_ASSERT)
+#      define TQ_ASSERT(x)  ((x) ? (void)0 : qFatal("ASSERT: \"%s\" in %s (%d)",#x,__FILE__,__LINE__))
+#    else
+#      define TQ_ASSERT(x)  ((x) ? (void)0 : qWarning("ASSERT: \"%s\" in %s (%d)",#x,__FILE__,__LINE__))
+#    endif
+#  else
+#    define TQ_ASSERT(x)
+#  endif
+#endif
+
+#if !defined(TQT_NO_COMPAT)			// compatibility with TQt 2
+#  if !defined(ASSERT)
+#    if !defined(TQ_OS_TEMP)
+#      define ASSERT(x) TQ_ASSERT(x)
+#    endif
+#  endif
+#endif // TQT_NO_COMPAT
+
+
+TQ_EXPORT bool qt_check_pointer( bool c, const char *, int );
+
+#if defined(TQT_CHECK_NULL)
+#  define TQ_CHECK_PTR(p) (qt_check_pointer((p)==0,__FILE__,__LINE__))
+#else
+#  define TQ_CHECK_PTR(p)
+#endif
+
+#if !defined(TQT_NO_COMPAT)			// compatibility with TQt 2
+#  if !defined(CHECK_PTR)
+#    define CHECK_PTR(x) TQ_CHECK_PTR(x)
+#  endif
+#endif // TQT_NO_COMPAT
+
+enum TQtMsgType { TQtDebugMsg, TQtWarningMsg, TQtFatalMsg };
+
+typedef void (*TQtMsgHandler)(TQtMsgType, const char *);
+TQ_EXPORT TQtMsgHandler tqInstallMsgHandler( TQtMsgHandler );
+
+#if !defined(TQT_NO_COMPAT)			// compatibility with TQt 2
+typedef TQtMsgHandler msg_handler;
+#endif // TQT_NO_COMPAT
+
+TQ_EXPORT void tqSuppressObsoleteWarnings( bool = TRUE );
+
+TQ_EXPORT void qObsolete( const char *obj, const char *oldfunc,
+		   const char *newfunc );
+TQ_EXPORT void qObsolete( const char *obj, const char *oldfunc );
+TQ_EXPORT void qObsolete( const char *message );
+
+
+//
+// Install paths from configure
+//
+
+TQ_EXPORT const char *qInstallPath();
+TQ_EXPORT const char *qInstallPathDocs();
+TQ_EXPORT const char *qInstallPathHeaders();
+TQ_EXPORT const char *qInstallPathLibs();
+TQ_EXPORT const char *qInstallPathBins();
+TQ_EXPORT const char *qInstallPathPlugins();
+TQ_EXPORT const char *qInstallPathData();
+TQ_EXPORT const char *qInstallPathTranslations();
+TQ_EXPORT const char *qInstallPathSysconf();
+
+#endif /* __cplusplus */
+
+/*
+ compilers which follow outdated template instantiation rules
+ require a class to have a comparison operator to exist when
+ a TQValueList of this type is instantiated. It's not actually
+ used in the list, though. Hence the dummy implementation.
+ Just in case other code relies on it we better trigger a warning
+ mandating a real implementation.
+*/
+#ifdef TQ_FULL_TEMPLATE_INSTANTIATION
+#  define TQ_DUMMY_COMPARISON_OPERATOR(C) \
+    bool operator==( const C& ) const { \
+        qWarning( #C"::operator==( const "#C"& ) got called." ); \
+        return FALSE; \
+    }
+#else
+#  define TQ_DUMMY_COMPARISON_OPERATOR(C)
+#endif
+
+#endif /* TQGLOBAL_H */
+
+/*
+ Avoid some particularly useless warnings from some stupid compilers.
+ To get ALL C++ compiler warnings, define TQT_CC_WARNINGS or comment out
+ the line "#define TQT_NO_WARNINGS"
+*/
+
+#if !defined(TQT_CC_WARNINGS)
+#  define TQT_NO_WARNINGS
+#endif
+#if defined(TQT_NO_WARNINGS)
+#  if defined(TQ_CC_MSVC)
+#    pragma warning(disable: 4244) // 'conversion' conversion from 'type1' to 'type2', possible loss of data
+#    pragma warning(disable: 4275) // non - DLL-interface classkey 'identifier' used as base for DLL-interface classkey 'identifier'
+#    pragma warning(disable: 4514) // unreferenced inline/local function has been removed
+#    pragma warning(disable: 4800) // 'type' : forcing value to bool 'true' or 'false' (performance warning)
+#    pragma warning(disable: 4097) // typedef-name 'identifier1' used as synonym for class-name 'identifier2'
+#    pragma warning(disable: 4706) // assignment within conditional expression
+#    pragma warning(disable: 4786) // truncating debug info after 255 characters
+#    pragma warning(disable: 4660) // template-class specialization 'identifier' is already instantiated
+#    pragma warning(disable: 4355) // 'this' : used in base member initializer list
+#    pragma warning(disable: 4231) // nonstandard extension used : 'extern' before template explicit instantiation
+#    pragma warning(disable: 4710) // function not inlined
+#  elif defined(TQ_CC_BOR)
+#    pragma option -w-inl
+#    pragma option -w-aus
+#    pragma warn -inl
+#    pragma warn -pia
+#    pragma warn -ccc
+#    pragma warn -rch
+#    pragma warn -sig
+#  endif
+#endif
+
diff --git a/tqtinterface/qt4/src/tools/tqgpluginmanager.cpp b/tqtinterface/qt4/src/tools/tqgpluginmanager.cpp
new file mode 100644
index 0000000..ef0ab02
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqgpluginmanager.cpp
@@ -0,0 +1,550 @@
+/****************************************************************************
+**
+** Implementation of TQGPluginManager class
+**
+** Copyright (C) 2000-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "tqgpluginmanager_p.h"
+#ifndef TQT_NO_COMPONENT
+#include "tqcomlibrary_p.h"
+#include "tqmap.h"
+#include "tqdir.h"
+
+/*
+  The following co-occurrence code is borrowed from TQt Linguist.
+
+  How similar are two texts? The approach used here relies on
+  co-occurrence matrices and is very efficient.
+
+  Let's see with an example: how similar are "here" and "hither"?  The
+  co-occurrence matrix M for "here" is M[h,e] = 1, M[e,r] = 1,
+  M[r,e] = 1 and 0 elsewhere; the matrix N for "hither" is N[h,i] = 1,
+  N[i,t] = 1, ..., N[h,e] = 1, N[e,r] = 1 and 0 elsewhere.  The union
+  U of both matrices is the matrix U[i,j] = max { M[i,j], N[i,j] },
+  and the intersection V is V[i,j] = min { M[i,j], N[i,j] }. The score
+  for a pair of texts is
+
+      score = (sum of V[i,j] over all i, j) / (sum of U[i,j] over all i, j),
+
+  a formula suggested by Arnt Gulbrandsen. Here we have
+
+      score = 2 / 6,
+
+  or one third.
+
+  The implementation differs from this in a few details.  Most
+  importantly, repetitions are ignored; for input "xxx", M[x,x] equals
+  1, not 2.
+*/
+
+/*
+  Every character is assigned to one of 20 buckets so that the
+  co-occurrence matrix requires only 20 * 20 = 400 bits, not
+  256 * 256 = 65536 bits or even more if we want the whole Unicode.
+  Which character falls in which bucket is arbitrary.
+
+  The second half of the table is a replica of the first half, because of
+  laziness.
+*/
+static const char indexOf[256] = {
+    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,  2,  6,  7,  10, 12, 15, 19, 2,  6,  7,  10, 12, 15, 19, 0,
+//  0   1   2   3   4   5   6   7   8   9   :   ;   <   =   >   ?
+    1,  3,  4,  5,  8,  9,  11, 13, 14, 16, 2,  6,  7,  10, 12, 15,
+//  @   A   B   C   D   E   F   G   H   I   J   K   L   M   N   O
+    0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  6,  10, 11, 12, 13, 14,
+//  P   Q   R   S   T   U   V   W   X   Y   Z   [   \   ]   ^   _
+    15, 12, 16, 17, 18, 19, 2,  10, 15, 7,  19, 2,  6,  7,  10, 0,
+//  `   a   b   c   d   e   f   g   h   i   j   k   l   m   n   o
+    0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  6,  10, 11, 12, 13, 14,
+//  p   q   r   s   t   u   v   w   x   y   z   {   |   }   ~
+    15, 12, 16, 17, 18, 19, 2,  10, 15, 7,  19, 2,  6,  7,  10, 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,  2,  6,  7,  10, 12, 15, 19, 2,  6,  7,  10, 12, 15, 19, 0,
+    1,  3,  4,  5,  8,  9,  11, 13, 14, 16, 2,  6,  7,  10, 12, 15,
+    0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  6,  10, 11, 12, 13, 14,
+    15, 12, 16, 17, 18, 19, 2,  10, 15, 7,  19, 2,  6,  7,  10, 0,
+    0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  6,  10, 11, 12, 13, 14,
+    15, 12, 16, 17, 18, 19, 2,  10, 15, 7,  19, 2,  6,  7,  10, 0
+};
+
+/*
+  The entry bitCount[i] (for i between 0 and 255) is the number of
+  bits used to represent i in binary.
+*/
+static const char bitCount[256] = {
+    0,  1,  1,  2,  1,  2,  2,  3,  1,  2,  2,  3,  2,  3,  3,  4,
+    1,  2,  2,  3,  2,  3,  3,  4,  2,  3,  3,  4,  3,  4,  4,  5,
+    1,  2,  2,  3,  2,  3,  3,  4,  2,  3,  3,  4,  3,  4,  4,  5,
+    2,  3,  3,  4,  3,  4,  4,  5,  3,  4,  4,  5,  4,  5,  5,  6,
+    1,  2,  2,  3,  2,  3,  3,  4,  2,  3,  3,  4,  3,  4,  4,  5,
+    2,  3,  3,  4,  3,  4,  4,  5,  3,  4,  4,  5,  4,  5,  5,  6,
+    2,  3,  3,  4,  3,  4,  4,  5,  3,  4,  4,  5,  4,  5,  5,  6,
+    3,  4,  4,  5,  4,  5,  5,  6,  4,  5,  5,  6,  5,  6,  6,  7,
+    1,  2,  2,  3,  2,  3,  3,  4,  2,  3,  3,  4,  3,  4,  4,  5,
+    2,  3,  3,  4,  3,  4,  4,  5,  3,  4,  4,  5,  4,  5,  5,  6,
+    2,  3,  3,  4,  3,  4,  4,  5,  3,  4,  4,  5,  4,  5,  5,  6,
+    3,  4,  4,  5,  4,  5,  5,  6,  4,  5,  5,  6,  5,  6,  6,  7,
+    2,  3,  3,  4,  3,  4,  4,  5,  3,  4,  4,  5,  4,  5,  5,  6,
+    3,  4,  4,  5,  4,  5,  5,  6,  4,  5,  5,  6,  5,  6,  6,  7,
+    3,  4,  4,  5,  4,  5,  5,  6,  4,  5,  5,  6,  5,  6,  6,  7,
+    4,  5,  5,  6,  5,  6,  6,  7,  5,  6,  6,  7,  6,  7,  7,  8
+};
+
+class TQCoMatrix
+{
+public:
+    /*
+      The matrix has 20 * 20 = 400 entries. This requires 50 bytes, or
+      13 words. Some operations are performed on words for more
+      efficiency.
+    */
+    union {
+	TQ_UINT8 b[52];
+	TQ_UINT32 w[13];
+    };
+
+    TQCoMatrix() { memset( b, 0, 52 ); }
+    TQCoMatrix( const char *text ) {
+	char c = '\0', d;
+	memset( b, 0, 52 );
+	while ( (d = *text) != '\0' ) {
+	    setCoocc( c, d );
+	    if ( (c = *++text) != '\0' ) {
+		setCoocc( d, c );
+		text++;
+	    }
+	}
+    }
+
+    void setCoocc( char c, char d ) {
+	int k = indexOf[(uchar) c] + 20 * indexOf[(uchar) d];
+	b[k >> 3] |= k & 0x7;
+    }
+
+    int worth() const {
+	int result = 0;
+	for ( int i = 0; i < 50; i++ )
+	    result += bitCount[b[i]];
+	return result;
+    }
+
+    static TQCoMatrix reunion( const TQCoMatrix& m, const TQCoMatrix& n )
+    {
+	TQCoMatrix p;
+	for ( int i = 0; i < 13; i++ )
+	    p.w[i] = m.w[i] | n.w[i];
+	return p;
+    }
+    static TQCoMatrix intersection( const TQCoMatrix& m, const TQCoMatrix& n )
+    {
+	TQCoMatrix p;
+	for ( int i = 0; i < 13; i++ )
+	    p.w[i] = m.w[i] & n.w[i];
+	return p;
+    }
+};
+
+/*
+  Returns an integer between 0 (dissimilar) and 15 (very similar)
+  depending on  how similar the string is to \a target.
+
+  This function is efficient, but its results might change in future
+  versions of TQt as the algorithm evolves.
+
+  \code
+    TQString s( "color" );
+    a = similarity( s, "color" );  // a == 15
+    a = similarity( s, "colour" ); // a == 8
+    a = similarity( s, "flavor" ); // a == 4
+    a = similarity( s, "dahlia" ); // a == 0
+  \endcode
+*/
+static int similarity( const TQString& s1, const TQString& s2 )
+{
+    TQCoMatrix m1( s1 );
+    TQCoMatrix m2( s2 );
+    return ( 15 * (TQCoMatrix::intersection(m1, m2).worth() + 1) ) /
+	   ( TQCoMatrix::reunion(m1, m2).worth() + 1 );
+}
+
+/*!
+  \class TQPluginManager qpluginmanager.h
+  \reentrant
+  \brief The TQPluginManager class provides basic functions to access a certain kind of functionality in libraries.
+  \ingroup componentmodel
+
+  \internal
+
+  A common usage of components is to extend the existing functionality in an application using plugins. The application
+  defines interfaces that abstract a certain group of functionality, and a plugin provides a specialized implementation
+  of one or more of those interfaces.
+
+  The TQPluginManager template has to be instantiated with an interface definition and the IID for this interface.
+
+  \code
+  TQPluginManager<MyPluginInterface> *manager = new TQPluginManager<MyPluginInterface>( IID_MyPluginInterface );
+  \endcode
+
+  It searches a specified directory for all shared libraries, queries for components that implement the specific interface and
+  reads information about the features the plugin wants to add to the application. The component can provide the set of features
+  provided by implementing either the TQFeatureListInterface or the TQComponentInformationInterface. The strings returned by the implementations
+  of
+
+  \code
+  TQStringList TQFeatureListInterface::featureList() const
+  \endcode
+
+  or
+
+  \code
+  TQString TQComponentInformationInterface::name() const
+  \endcode
+
+  respectively, can then be used to access the component that provides the requested feature:
+
+  \code
+  MyPluginInterface *iface;
+  manager->queryInterface( "feature", &iface );
+  if ( iface )
+      iface->execute( "feature" );
+  \endcode
+
+  The application can use a TQPluginManager instance to create parts of the user interface based on the list of features
+  found in plugins:
+
+  \code
+  TQPluginManager<MyPluginInterface> *manager = new TQPluginManager<MyPluginInterface>( IID_ImageFilterInterface );
+  manager->addLibraryPath(...);
+
+  TQStringList features = manager->featureList();
+  for ( TQStringList::Iterator it = features.begin(); it != features.end(); ++it ) {
+      MyPluginInterface *iface;
+      manager->queryInterface( *it, &iface );
+
+      // use TQAction to provide toolbuttons and menuitems for each feature...
+  }
+  \endcode
+*/
+
+/*!
+  \fn TQPluginManager::TQPluginManager( const TQUuid& id, const TQStringList& paths = TQString::null, const TQString &suffix = TQString::null, bool cs = TRUE )
+
+  Creates an TQPluginManager for interfaces \a id that will load all shared library files in the \a paths + \a suffix.
+  If \a cs is FALSE the manager will handle feature strings case insensitive.
+
+  \warning
+  Setting the cs flag to FALSE requires that components also convert to lower case when comparing with passed strings, so this has
+  to be handled with care and documented very well.
+
+  \sa TQApplication::libraryPaths()
+*/
+
+
+/*!
+  \fn TQRESULT TQPluginManager::queryInterface(const TQString& feature, Type** iface) const
+
+  Sets \a iface to point to the interface providing \a feature.
+
+  \sa featureList(), library()
+*/
+
+
+
+#include <tqptrlist.h>
+
+TQGPluginManager::TQGPluginManager( const TQUuid& id, const TQStringList& paths, const TQString &suffix, bool cs )
+    : interfaceId( id ), plugDict( 17, cs ), casesens( cs ), autounload( TRUE )
+{
+    // Every TQLibrary object is destroyed on destruction of the manager
+    libDict.setAutoDelete( TRUE );
+    for ( TQStringList::ConstIterator it = paths.begin(); it != paths.end(); ++it ) {
+	TQString path = *it;
+	addLibraryPath( path + suffix );
+    }
+}
+
+TQGPluginManager::~TQGPluginManager()
+{
+    if ( !autounload ) {
+	TQDictIterator<TQLibrary> it( libDict );
+	while ( it.current() ) {
+	    TQLibrary *lib = it.current();
+	    ++it;
+	    lib->setAutoUnload( FALSE );
+	}
+    }
+}
+
+void TQGPluginManager::addLibraryPath( const TQString& path )
+{
+    if ( !enabled() || !TQDir( path ).exists( ".", TRUE ) )
+	return;
+
+#if defined(TQ_OS_WIN32)
+    TQString filter = "*.dll";
+#elif defined(TQ_OS_MACX)
+    TQString filter = "*.dylib; *.so; *.bundle";
+#elif defined(TQ_OS_HPUX)
+    TQString filter = "*.sl";
+#elif defined(TQ_OS_UNIX)
+    TQString filter = "*.so";
+#endif
+
+    TQStringList plugins = TQDir(path).entryList( filter );
+    for ( TQStringList::Iterator p = plugins.begin(); p != plugins.end(); ++p ) {
+	TQString lib = TQDir::cleanDirPath( path + "/" + *p );
+	if ( libList.tqcontains( lib ) )
+	    continue;
+	libList.append( lib );
+    }
+}
+
+const TQLibrary* TQGPluginManager::library( const TQString& feature ) const
+{
+    if ( !enabled() || feature.isEmpty() )
+	return 0;
+
+    // We already have a TQLibrary object for this feature
+    TQLibrary *library = 0;
+    if ( ( library = plugDict[feature] ) )
+	return library;
+
+    // Find the filename that matches the feature request best
+    TQMap<int, TQStringList> map;
+    TQStringList::ConstIterator it = libList.begin();
+    int best = 0;
+    int worst = 15;
+    while ( it != libList.end() ) {
+	if ( (*it).isEmpty() || libDict[*it] ) {
+	    ++it;
+	    continue;
+	}
+	TQString basename = TQFileInfo(*it).baseName();
+	int s = similarity( feature, basename );
+	if ( s < worst )
+	    worst = s;
+	if ( s > best )
+	    best = s;
+	map[s].append( basename + TQChar(0xfffd) + *it );
+	++it;
+    }
+
+    if ( map.isEmpty() )
+	return 0; // no libraries to add
+
+    // Start with the best match to get the library object
+    TQGPluginManager *that = (TQGPluginManager*)this;
+    for ( int s = best; s >= worst; --s ) {
+	TQStringList group = map[s];
+	group.sort(); // sort according to the base name
+	TQStringList::ConstIterator git = group.begin();
+	while ( git != group.end() ) {
+	    TQString lib = (*git).mid( (*git).tqfind( TQChar(0xfffd) ) + 1 );
+	    TQString basename = (*git).left( (*git).tqfind( TQChar(0xfffd) ) );
+	    ++git;
+
+	    TQStringList sameBasename;
+	    while( git != group.end() &&
+		   basename == (*git).left( (*git).tqfind( TQChar(0xfffd) ) )  ) {
+		sameBasename << (*git).mid( (*git).tqfind( TQChar(0xfffd) ) + 1 );
+		++git;
+	    }
+
+	    if ( sameBasename.isEmpty() ) {
+		that->addLibrary( new TQComLibrary( lib ) );
+	    } else {
+		TQPtrList<TQComLibrary> same;
+		same.setAutoDelete( TRUE );
+		same.append( new TQComLibrary( lib ) );
+		for ( TQStringList::ConstIterator bit = sameBasename.begin();
+		      bit != sameBasename.end(); ++bit )
+		    same.append( new TQComLibrary( *bit ) );
+		TQComLibrary* bestMatch = 0;
+		for ( TQComLibrary* candidate = same.first(); candidate; candidate = same.next() )
+		    if ( candidate->qtVersion() && candidate->qtVersion() <= TQT_VERSION
+			 && ( !bestMatch || candidate->qtVersion() > bestMatch->qtVersion() ) )
+			bestMatch = candidate;
+		if ( bestMatch ) {
+		    same.tqfind( bestMatch );
+		    that->addLibrary( same.take() );
+		}
+	    }
+
+	    if ( ( library = that->plugDict[feature] ) )
+		return library;
+	}
+    }
+    return 0;
+}
+
+TQStringList TQGPluginManager::featureList() const
+{
+    TQStringList features;
+
+    if ( !enabled() )
+	return features;
+
+    TQGPluginManager *that = (TQGPluginManager*)this;
+    TQStringList theLibs = libList;
+    TQStringList phase2Libs;
+    TQStringList phase2Deny;
+
+    /* In order to get the feature list we need to add all interesting
+      libraries. If there are libraries with the same base name, we
+      prioritze the one that fits our TQt version number and ignore the
+      others  */
+    TQStringList::Iterator it;
+    for ( it = theLibs.begin(); it != theLibs.end(); ++it  ) {
+	if ( (*it).isEmpty() || libDict[*it] )
+	    continue;
+	TQComLibrary* library = new TQComLibrary( *it );
+	if ( library->qtVersion() == TQT_VERSION ) {
+	    that->addLibrary( library );
+	    phase2Deny << TQFileInfo( *it ).baseName();
+	} else {
+	    delete library;
+	    phase2Libs << *it;
+	}
+    }
+    for ( it = phase2Libs.begin(); it != phase2Libs.end(); ++it  )
+	if ( !phase2Deny.tqcontains( TQFileInfo( *it ).baseName() ) )
+	    that->addLibrary( new TQComLibrary( *it ) );
+
+    for ( TQDictIterator<TQLibrary> pit( plugDict ); pit.current(); ++pit )
+	features << pit.currentKey();
+
+    return features;
+}
+
+bool TQGPluginManager::addLibrary( TQLibrary* lib )
+{
+    if ( !enabled() || !lib )
+	return FALSE;
+
+    TQComLibrary* plugin = (TQComLibrary*)lib;
+    bool useful = FALSE;
+
+    TQUnknownInterface* iFace = 0;
+    plugin->queryInterface( interfaceId, &iFace );
+    if ( iFace ) {
+	TQFeatureListInterface *fliFace = 0;
+	TQComponentInformationInterface *cpiFace = 0;
+	iFace->queryInterface( IID_TQFeatureList, (TQUnknownInterface**)&fliFace );
+	if ( !fliFace )
+	    plugin->queryInterface( IID_TQFeatureList, (TQUnknownInterface**)&fliFace );
+	if ( !fliFace ) {
+	    iFace->queryInterface( IID_TQComponentInformation, (TQUnknownInterface**)&cpiFace );
+	    if ( !cpiFace )
+		plugin->queryInterface( IID_TQComponentInformation, (TQUnknownInterface**)&cpiFace );
+	}
+	TQStringList fl;
+	if ( fliFace )
+	    // Map all found features to the library
+	    fl = fliFace->featureList();
+	else if ( cpiFace )
+	    fl << cpiFace->name();
+
+	for ( TQStringList::Iterator f = fl.begin(); f != fl.end(); ++f ) {
+	    TQLibrary *old = plugDict[*f];
+	    if ( !old ) {
+		useful = TRUE;
+		plugDict.tqreplace( *f, plugin );
+	    } else {
+		// we have old *and* plugin, which one to pick?
+		TQComLibrary* first = (TQComLibrary*)old;
+		TQComLibrary* second = (TQComLibrary*)plugin;
+		bool takeFirst = TRUE;
+		if ( first->qtVersion() != TQT_VERSION ) {
+		    if ( second->qtVersion() == TQT_VERSION )
+			takeFirst = FALSE;
+		    else if ( second->qtVersion() < TQT_VERSION &&
+			      first->qtVersion() > TQT_VERSION )
+			takeFirst = FALSE;
+		}
+		if ( !takeFirst ) {
+		    useful = TRUE;
+		    plugDict.tqreplace( *f, plugin );
+		    qWarning("%s: Discarding feature %s in %s!",
+			     (const char*) TQFile::encodeName( plugin->library()),
+			     (*f).latin1(),
+			     (const char*) TQFile::encodeName( old->library() ) );
+		} else {
+		    qWarning("%s: Feature %s already defined in %s!",
+			     (const char*) TQFile::encodeName( old->library() ),
+			     (*f).latin1(),
+			     (const char*) TQFile::encodeName( plugin->library() ) );
+		}
+	    }
+	}
+	if ( fliFace )
+	    fliFace->release();
+	if ( cpiFace )
+	    cpiFace->release();
+	iFace->release();
+    }
+
+    if ( useful ) {
+	libDict.tqreplace( plugin->library(), plugin );
+	if ( !libList.tqcontains( plugin->library() ) )
+	    libList.append( plugin->library() );
+	return TRUE;
+    }
+    delete plugin;
+    return FALSE;
+}
+
+
+bool TQGPluginManager::enabled() const
+{
+#ifdef TQT_SHARED
+    return TRUE;
+#else
+    return FALSE;
+#endif
+}
+
+TQRESULT TQGPluginManager::queryUnknownInterface(const TQString& feature, TQUnknownInterface** iface) const
+{
+    TQComLibrary* plugin = 0;
+    plugin = (TQComLibrary*)library( feature );
+    return plugin ? plugin->queryInterface( interfaceId, (TQUnknownInterface**)iface ) : TQE_NOINTERFACE;
+}
+
+#endif //TQT_NO_COMPONENT
diff --git a/tqtinterface/qt4/src/tools/tqgpluginmanager_p.h b/tqtinterface/qt4/src/tools/tqgpluginmanager_p.h
new file mode 100644
index 0000000..dd4709d
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqgpluginmanager_p.h
@@ -0,0 +1,108 @@
+/**********************************************************************
+**
+** Definition of TQGPluginManager class
+**
+** Copyright (C) 2000-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQGPLUGINMANAGER_P_H
+#define TQGPLUGINMANAGER_P_H
+
+#include "tqdict.h"
+#include "tqlibrary.h"
+#include "tquuid.h"
+#include "tqstringlist.h"
+#include "tqcom_p.h"
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the TQt API.  It exists for the convenience
+// of a number of TQt sources files.  This header file may change from
+// version to version without notice, or even be removed.
+//
+// We mean it.
+//
+//
+
+#ifndef TQT_NO_COMPONENT
+
+#if defined(TQ_TEMPLATEDLL)
+// TQMOC_SKIP_BEGIN
+//TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQDict<TQLibrary>;
+// TQMOC_SKIP_END
+#endif
+
+class TQ_EXPORT TQGPluginManager
+{
+public:
+    TQGPluginManager( const TQUuid& id, const TQStringList& paths = TQString(), const TQString &suffix = TQString::null, bool cs = TRUE );
+    ~TQGPluginManager();
+
+    void addLibraryPath( const TQString& path );
+    const TQLibrary* library( const TQString& feature ) const;
+    TQStringList featureList() const;
+
+    bool autoUnload() const;
+    void setAutoUnload( bool );
+
+protected:
+    bool enabled() const;
+    bool addLibrary( TQLibrary* plugin );
+
+    TQRESULT queryUnknownInterface(const TQString& feature, TQUnknownInterface** iface) const;
+
+    TQUuid interfaceId;
+    TQDict<TQLibrary> plugDict;	    // Dict to match feature with library
+    TQDict<TQLibrary> libDict;	    // Dict to match library file with library
+    TQStringList libList;
+
+    uint casesens : 1;
+    uint autounload : 1;
+};
+
+inline void TQGPluginManager::setAutoUnload( bool unload )
+{
+    autounload = unload;
+}
+
+inline bool TQGPluginManager::autoUnload() const
+{
+    return autounload;
+}
+
+#endif
+
+#endif //TQGPLUGINMANAGER_P_H
diff --git a/tqtinterface/qt4/src/tools/tqgvector.cpp b/tqtinterface/qt4/src/tools/tqgvector.cpp
new file mode 100644
index 0000000..e30c172
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqgvector.cpp
@@ -0,0 +1,598 @@
+/****************************************************************************
+**
+** Implementation of TQGVector class
+**
+** Created : 930907
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "tqglobal.h"
+#if defined(TQ_CC_BOR)
+// needed for qsort() because of a std namespace problem on Borland
+#include "tqplatformdefs.h"
+#endif
+
+#define	 TQGVECTOR_CPP
+#include "tqgvector.h"
+#include "tqglist.h"
+#include "tqstring.h"
+#include "tqdatastream.h"
+#include <stdlib.h>
+
+#ifdef TQT_THREAD_SUPPORT
+#  include <private/tqmutexpool_p.h>
+#endif // TQT_THREAD_SUPPORT
+
+#define USE_MALLOC				// comment to use new/delete
+
+#undef NEW
+#undef DELETE
+
+#if defined(USE_MALLOC)
+#define NEW(type,size)	((type*)malloc(size*sizeof(type)))
+#define DELETE(array)	(free((char*)array))
+#else
+#define NEW(type,size)	(new type[size])
+#define DELETE(array)	(delete[] array)
+#define DONT_USE_REALLOC			// comment to use realloc()
+#endif
+
+/*!
+  \class TQGVector
+  \reentrant
+  \ingroup collection
+
+  \brief The TQGVector class is an internal class for implementing TQt
+  collection classes.
+
+  \internal
+
+  TQGVector is an internal class that acts as a base class for the
+  TQPtrVector collection class.
+
+  TQGVector has some virtual functions that may be reimplemented in
+  subclasses to customize behavior.
+
+  \list
+  \i compareItems() compares two collection/vector items.
+  \i read() reads a collection/vector item from a TQDataStream.
+  \i write() writes a collection/vector item to a TQDataStream.
+  \endlist
+*/
+
+/*****************************************************************************
+  Default implementation of virtual functions
+ *****************************************************************************/
+
+/*!
+  This virtual function compares two list items.
+
+  Returns:
+  <ul>
+  <li> 0 if \a d1 == \a d2
+  <li> non-zero if \a d1 != \a d2
+  </ul>
+
+  This function returns \e int rather than \e bool so that
+  reimplementations can return one of three values and use it to sort
+  by:
+  <ul>
+  <li> 0 if \a d1 == \a d2
+  <li> \> 0 (positive integer) if \a d1 \> \a d2
+  <li> \< 0 (negative integer) if \a d1 \< \a d2
+  </ul>
+
+  The TQPtrVector::sort() and TQPtrVector::bsearch() functions require that
+  compareItems() is implemented as described here.
+
+  This function should not modify the vector because some const
+  functions call compareItems().
+*/
+
+int TQGVector::compareItems( Item d1, Item d2 )
+{
+    return d1 != d2;				// compare pointers
+}
+
+#ifndef TQT_NO_DATASTREAM
+/*!
+  Reads a collection/vector item from the stream \a s and returns a reference
+  to the stream.
+
+  The default implementation sets \a d to 0.
+
+  \sa write()
+*/
+
+TQDataStream &TQGVector::read( TQDataStream &s, Item &d )
+{						// read item from stream
+    d = 0;
+    return s;
+}
+
+/*!
+  Writes a collection/vector item to the stream \a s and returns a reference
+  to the stream.
+
+  The default implementation does nothing.
+
+  \sa read()
+*/
+
+TQDataStream &TQGVector::write( TQDataStream &s, Item ) const
+{						// write item to stream
+    return s;
+}
+#endif // TQT_NO_DATASTREAM
+
+/*****************************************************************************
+  TQGVector member functions
+ *****************************************************************************/
+
+TQGVector::TQGVector()				// create empty vector
+{
+    vec = 0;
+    len = numItems = 0;
+}
+
+TQGVector::TQGVector( uint size )			// create vectors with nullptrs
+{
+    len = size;
+    numItems = 0;
+    if ( len == 0 ) {				// zero length
+	vec = 0;
+	return;
+    }
+    vec = NEW(Item,len);
+    TQ_CHECK_PTR( vec );
+    memset( (void*)vec, 0, len*sizeof(Item) );	// fill with nulls
+}
+
+TQGVector::TQGVector( const TQGVector &a )		// make copy of other vector
+    : TQPtrCollection( a )
+{
+    len = a.len;
+    numItems = a.numItems;
+    if ( len == 0 ) {
+	vec = 0;
+	return;
+    }
+    vec = NEW( Item, len );
+    TQ_CHECK_PTR( vec );
+    for ( uint i = 0; i < len; i++ ) {
+	if ( a.vec[i] ) {
+	    vec[i] = newItem( a.vec[i] );
+	    TQ_CHECK_PTR( vec[i] );
+	} else {
+	    vec[i] = 0;
+	}
+    }
+}
+
+TQGVector::~TQGVector()
+{
+    clear();
+}
+
+TQGVector& TQGVector::operator=( const TQGVector &v )
+{
+    if ( &v == this )
+	return *this;
+
+    clear();
+    len = v.len;
+    numItems = v.numItems;
+    if ( len == 0 ) {
+	vec = 0;
+	return *this;
+    }
+    vec = NEW( Item, len );
+    TQ_CHECK_PTR( vec );
+    for ( uint i = 0; i < len; i++ ) {
+	if ( v.vec[i] ) {
+	    vec[i] = newItem( v.vec[i] );
+	    TQ_CHECK_PTR( vec[i] );
+	} else {
+	    vec[i] = 0;
+	}
+    }
+    return *this;
+}
+
+
+bool TQGVector::insert( uint index, Item d )	// insert item at index
+{
+#if defined(TQT_CHECK_RANGE)
+    if ( index >= len ) {			// range error
+	qWarning( "TQGVector::insert: Index %d out of range", index );
+	return FALSE;
+    }
+#endif
+    if ( vec[index] ) {				// remove old item
+	deleteItem( vec[index] );
+	numItems--;
+    }
+    if ( d ) {
+	vec[index] = newItem( d );
+	TQ_CHECK_PTR( vec[index] );
+	numItems++;
+	return vec[index] != 0;
+    } else {
+	vec[index] = 0;				// reset item
+    }
+    return TRUE;
+}
+
+bool TQGVector::remove( uint index )		// remove item at index
+{
+#if defined(TQT_CHECK_RANGE)
+    if ( index >= len ) {			// range error
+	qWarning( "TQGVector::remove: Index %d out of range", index );
+	return FALSE;
+    }
+#endif
+    if ( vec[index] ) {				// valid item
+	deleteItem( vec[index] );		// delete it
+	vec[index] = 0;				// reset pointer
+	numItems--;
+    }
+    return TRUE;
+}
+
+TQPtrCollection::Item TQGVector::take( uint index )		// take out item
+{
+#if defined(TQT_CHECK_RANGE)
+    if ( index >= len ) {			// range error
+	qWarning( "TQGVector::take: Index %d out of range", index );
+	return 0;
+    }
+#endif
+    Item d = vec[index];				// don't delete item
+    if ( d )
+	numItems--;
+    vec[index] = 0;
+    return d;
+}
+
+void TQGVector::clear()				// clear vector
+{
+    if ( vec ) {
+	for ( uint i=0; i<len; i++ ) {		// delete each item
+	    if ( vec[i] )
+		deleteItem( vec[i] );
+	}
+	DELETE(vec);
+	vec = 0;
+	len = numItems = 0;
+    }
+}
+
+bool TQGVector::resize( uint newsize )		// resize array
+{
+    if ( newsize == len )			// nothing to do
+	return TRUE;
+    if ( vec ) {				// existing data
+	if ( newsize < len ) {			// shrink vector
+	    uint i = newsize;
+	    while ( i < len ) {			// delete lost items
+		if ( vec[i] ) {
+		    deleteItem( vec[i] );
+		    numItems--;
+		}
+		i++;
+	    }
+	}
+	if ( newsize == 0 ) {			// vector becomes empty
+	    DELETE(vec);
+	    vec = 0;
+	    len = numItems = 0;
+	    return TRUE;
+	}
+#if defined(DONT_USE_REALLOC)
+	if ( newsize == 0 ) {
+	    DELETE(vec);
+	    vec = 0;
+	    return FALSE;
+	}
+	Item *newvec = NEW(Item,newsize);		// manual realloc
+        if (!newvec)
+            return FALSE;
+	memcpy( newvec, vec, (len < newsize ? len : newsize)*sizeof(Item) );
+	DELETE(vec);
+	vec = newvec;
+#else
+	Item *newvec = (Item*)realloc( (char *)vec, newsize*sizeof(Item) );
+        if (!newvec)
+            return FALSE;
+        vec = newvec;
+#endif
+    } else {					// create new vector
+	vec = NEW(Item,newsize);
+        if (!vec)
+            return FALSE;
+	len = numItems = 0;
+    }
+    if ( newsize > len )			// init extra space added
+	memset( (void*)&vec[len], 0, (newsize-len)*sizeof(Item) );
+    len = newsize;
+    return TRUE;
+}
+
+
+bool TQGVector::fill( Item d, int flen )		// resize and fill vector
+{
+    if ( flen < 0 )
+	flen = len;				// default: use vector length
+    else if ( !resize( flen ) )
+	return FALSE;
+    for ( uint i=0; i<(uint)flen; i++ )		// insert d at every index
+	insert( i, d );
+    return TRUE;
+}
+
+
+static TQGVector *sort_vec=0;			// current sort vector
+
+
+#if defined(TQ_C_CALLBACKS)
+extern "C" {
+#endif
+
+#ifdef TQ_OS_TEMP
+static int _cdecl cmp_vec( const void *n1, const void *n2 )
+#else
+static int cmp_vec( const void *n1, const void *n2 )
+#endif
+{
+    return sort_vec->compareItems( *((TQPtrCollection::Item*)n1), *((TQPtrCollection::Item*)n2) );
+}
+
+#if defined(TQ_C_CALLBACKS)
+}
+#endif
+
+
+void TQGVector::sort()				// sort vector
+{
+    if ( count() == 0 )				// no elements
+	return;
+    register Item *start = &vec[0];
+    register Item *end	= &vec[len-1];
+    Item tmp;
+    for (;;) {				// put all zero elements behind
+	while ( start < end && *start != 0 )
+	    start++;
+	while ( end > start && *end == 0 )
+	    end--;
+	if ( start < end ) {
+	    tmp = *start;
+	    *start = *end;
+	    *end = tmp;
+	} else {
+	    break;
+	}
+    }
+
+#ifdef TQT_THREAD_SUPPORT
+    TQMutexLocker locker( tqt_global_mutexpool ?
+			 tqt_global_mutexpool->get( &sort_vec ) : 0 );
+#endif // TQT_THREAD_SUPPORT
+
+    sort_vec = (TQGVector*)this;
+    qsort( vec, count(), sizeof(Item), cmp_vec );
+    sort_vec = 0;
+}
+
+int TQGVector::bsearch( Item d ) const		// binary search; when sorted
+{
+    if ( !len )
+	return -1;
+    if ( !d ) {
+#if defined(TQT_CHECK_NULL)
+	qWarning( "TQGVector::bsearch: Cannot search for null object" );
+#endif
+	return -1;
+    }
+    int n1 = 0;
+    int n2 = len - 1;
+    int mid = 0;
+    bool found = FALSE;
+    while ( n1 <= n2 ) {
+	int  res;
+	mid = (n1 + n2)/2;
+	if ( vec[mid] == 0 )			// null item greater
+	    res = -1;
+	else
+	    res = ((TQGVector*)this)->compareItems( d, vec[mid] );
+	if ( res < 0 )
+	    n2 = mid - 1;
+	else if ( res > 0 )
+	    n1 = mid + 1;
+	else {					// found it
+	    found = TRUE;
+	    break;
+	}
+    }
+    if ( !found )
+	return -1;
+    // search to first of equal items
+    while ( (mid - 1 >= 0) && !((TQGVector*)this)->compareItems(d, vec[mid-1]) )
+	mid--;
+    return mid;
+}
+
+int TQGVector::tqfindRef( Item d, uint index) const // tqfind exact item in vector
+{
+#if defined(TQT_CHECK_RANGE)
+    if ( index > len ) {			// range error
+	qWarning( "TQGVector::tqfindRef: Index %d out of range", index );
+	return -1;
+    }
+#endif
+    for ( uint i=index; i<len; i++ ) {
+	if ( vec[i] == d )
+	    return i;
+    }
+    return -1;
+}
+
+int TQGVector::tqfind( Item d, uint index ) const	// tqfind equal item in vector
+{
+#if defined(TQT_CHECK_RANGE)
+    if ( index >= len ) {			// range error
+	qWarning( "TQGVector::tqfind: Index %d out of range", index );
+	return -1;
+    }
+#endif
+    for ( uint i=index; i<len; i++ ) {
+	if ( vec[i] == 0 && d == 0 )		// found null item
+	    return i;
+	if ( vec[i] && ((TQGVector*)this)->compareItems( vec[i], d ) == 0 )
+	    return i;
+    }
+    return -1;
+}
+
+uint TQGVector::tqcontainsRef( Item d ) const	// get number of exact matches
+{
+    uint count = 0;
+    for ( uint i=0; i<len; i++ ) {
+	if ( vec[i] == d )
+	    count++;
+    }
+    return count;
+}
+
+uint TQGVector::tqcontains( Item d ) const		// get number of equal matches
+{
+    uint count = 0;
+    for ( uint i=0; i<len; i++ ) {
+	if ( vec[i] == 0 && d == 0 )		// count null items
+	    count++;
+	if ( vec[i] && ((TQGVector*)this)->compareItems( vec[i], d ) == 0 )
+	    count++;
+    }
+    return count;
+}
+
+bool TQGVector::insertExpand( uint index, Item d )// insert and grow if necessary
+{
+    if ( index >= len ) {
+	if ( !resize( index+1 ) )		// no memory
+	    return FALSE;
+    }
+    insert( index, d );
+    return TRUE;
+}
+
+void TQGVector::toList( TQGList *list ) const	// store items in list
+{
+    list->clear();
+    for ( uint i=0; i<len; i++ ) {
+	if ( vec[i] )
+	    list->append( vec[i] );
+    }
+}
+
+
+void TQGVector::warningIndexRange( uint i )
+{
+#if defined(TQT_CHECK_RANGE)
+    qWarning( "TQGVector::operator[]: Index %d out of range", i );
+#else
+    TQ_UNUSED( i )
+#endif
+}
+
+
+/*****************************************************************************
+  TQGVector stream functions
+ *****************************************************************************/
+#ifndef TQT_NO_DATASTREAM
+TQDataStream &operator>>( TQDataStream &s, TQGVector &vec )
+{						// read vector
+    return vec.read( s );
+}
+
+TQDataStream &operator<<( TQDataStream &s, const TQGVector &vec )
+{						// write vector
+    return vec.write( s );
+}
+
+TQDataStream &TQGVector::read( TQDataStream &s )	// read vector from stream
+{
+    uint num;
+    s >> num;					// read number of items
+    clear();					// clear vector
+    resize( num );
+    for (uint i=0; i<num; i++) {		// read all items
+	Item d;
+	read( s, d );
+	TQ_CHECK_PTR( d );
+	if ( !d )				// no memory
+	    break;
+	vec[i] = d;
+    }
+    return s;
+}
+
+TQDataStream &TQGVector::write( TQDataStream &s ) const
+{						// write vector to stream
+    uint num = count();
+    s << num;					// number of items to write
+    num = size();
+    for (uint i=0; i<num; i++) {		// write non-null items
+	if ( vec[i] )
+	    write( s, vec[i] );
+    }
+    return s;
+}
+
+/* Returns whether v equals this vector or not */
+
+bool TQGVector::operator==( const TQGVector &v ) const
+{
+    if ( size() != v.size() )
+	return FALSE;
+    if ( count() != v.count() )
+	return FALSE;
+    for ( int i = 0; i < (int)size(); ++i ) {
+	if ( ( (TQGVector*)this )->compareItems( at( i ), v.at( i ) ) != 0 )
+	    return FALSE;
+    }
+    return TRUE;
+}
+
+#endif // TQT_NO_DATASTREAM
diff --git a/tqtinterface/qt4/src/tools/tqgvector.h b/tqtinterface/qt4/src/tools/tqgvector.h
new file mode 100644
index 0000000..1cc5937
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqgvector.h
@@ -0,0 +1,124 @@
+/****************************************************************************
+**
+** Definition of TQGVector class
+**
+** Created : 930907
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQGVECTOR_H
+#define TQGVECTOR_H
+
+#ifndef TQT_H
+#include "tqptrcollection.h"
+#endif // TQT_H
+
+
+class TQ_EXPORT TQGVector : public TQPtrCollection	// generic vector
+{
+friend class TQGList;				// needed by TQGList::toVector
+public:
+#ifndef TQT_NO_DATASTREAM
+    TQDataStream &read( TQDataStream & );		// read vector from stream
+    TQDataStream &write( TQDataStream & ) const;	// write vector to stream
+#endif
+    virtual int compareItems( Item, Item );
+
+protected:
+    TQGVector();					// create empty vector
+    TQGVector( uint size );			// create vector with nullptrs
+    TQGVector( const TQGVector &v );		// make copy of other vector
+   ~TQGVector();
+
+    TQGVector &operator=( const TQGVector &v );	// assign from other vector
+    bool operator==( const TQGVector &v ) const;
+
+    Item	 *data()    const	{ return vec; }
+    uint  size()    const	{ return len; }
+    uint  count()   const	{ return numItems; }
+
+    bool  insert( uint index, Item );		// insert item at index
+    bool  remove( uint index );			// remove item
+    Item	  take( uint index );			// take out item
+
+    void  clear();				// clear vector
+    bool  resize( uint newsize );		// resize vector
+
+    bool  fill( Item, int flen );		// resize and fill vector
+
+    void  sort();				// sort vector
+    int	  bsearch( Item ) const;			// binary search (when sorted)
+
+    int	  tqfindRef( Item, uint index ) const;	// tqfind exact item in vector
+    int	  tqfind( Item, uint index ) const;	// tqfind equal item in vector
+    uint  tqcontainsRef( Item ) const;		// get number of exact matches
+    uint  tqcontains( Item ) const;		// get number of equal matches
+
+    Item	  at( uint index ) const		// return indexed item
+    {
+#if defined(TQT_CHECK_RANGE)
+	if ( index >= len )
+	    warningIndexRange( index );
+#endif
+	return vec[index];
+    }
+
+    bool insertExpand( uint index, Item );	// insert, expand if necessary
+
+    void toList( TQGList * ) const;		// put items in list
+
+#ifndef TQT_NO_DATASTREAM
+    virtual TQDataStream &read( TQDataStream &, Item & );
+    virtual TQDataStream &write( TQDataStream &, Item ) const;
+#endif
+private:
+    Item	 *vec;
+    uint  len;
+    uint  numItems;
+
+    static void warningIndexRange( uint );
+};
+
+
+/*****************************************************************************
+  TQGVector stream functions
+ *****************************************************************************/
+
+#ifndef TQT_NO_DATASTREAM
+TQ_EXPORT TQDataStream &operator>>( TQDataStream &, TQGVector & );
+TQ_EXPORT TQDataStream &operator<<( TQDataStream &, const TQGVector & );
+#endif
+
+#endif // TQGVECTOR_H
diff --git a/tqtinterface/qt4/src/tools/tqintcache.h b/tqtinterface/qt4/src/tools/tqintcache.h
new file mode 100644
index 0000000..ed48fc3
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqintcache.h
@@ -0,0 +1,124 @@
+/****************************************************************************
+**
+** Definition of TQIntCache template class
+**
+** Created : 950209
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQINTCACHE_H
+#define TQINTCACHE_H
+
+#ifndef TQT_H
+#include "tqgcache.h"
+#endif // TQT_H
+
+
+template<class type> 
+class TQIntCache
+#ifdef TQ_TQDOC
+	: public TQPtrCollection
+#else
+	: public TQGCache
+#endif
+{
+public:
+    TQIntCache( const TQIntCache<type> &c ) : TQGCache(c) {}
+    TQIntCache( int maxCost=100, int size=17 )
+	: TQGCache( maxCost, size, IntKey, FALSE, FALSE ) {}
+   ~TQIntCache()		{ clear(); }
+    TQIntCache<type> &operator=( const TQIntCache<type> &c )
+			{ return (TQIntCache<type>&)TQGCache::operator=(c); }
+    int	  maxCost()   const	{ return TQGCache::maxCost(); }
+    int	  totalCost() const	{ return TQGCache::totalCost(); }
+    void  setMaxCost( int m)	{ TQGCache::setMaxCost(m); }
+    uint  count()     const	{ return TQGCache::count(); }
+    uint  size()      const	{ return TQGCache::size(); }
+    bool  isEmpty()   const	{ return TQGCache::count() == 0; }
+    bool  insert( long k, const type *d, int c=1, int p=0 )
+		{ return TQGCache::insert_other((const char*)k,(Item)d,c,p); }
+    bool  remove( long k )
+		{ return TQGCache::remove_other((const char*)k); }
+    type *take( long k )
+		{ return (type *)TQGCache::take_other((const char*)k);}
+    void  clear()		{ TQGCache::clear(); }
+    type *tqfind( long k, bool ref=TRUE ) const
+		{ return (type *)TQGCache::tqfind_other( (const char*)k,ref);}
+    type *operator[]( long k ) const
+		{ return (type *)TQGCache::tqfind_other( (const char*)k); }
+    void  statistics() const { TQGCache::statistics(); }
+private:
+	void  deleteItem( Item d );
+};
+
+#if !defined(TQ_BROKEN_TEMPLATE_SPECIALIZATION)
+template<> inline void TQIntCache<void>::deleteItem( TQPtrCollection::Item )
+{
+}
+#endif
+
+template<class type> inline void TQIntCache<type>::deleteItem( TQPtrCollection::Item d )
+{
+    if ( del_item ) delete (type *)d;
+}
+
+template<class type> 
+class TQIntCacheIterator : public TQGCacheIterator
+{
+public:
+    TQIntCacheIterator( const TQIntCache<type> &c )
+	: TQGCacheIterator( (TQGCache &)c ) {}
+    TQIntCacheIterator( const TQIntCacheIterator<type> &ci )
+			      : TQGCacheIterator((TQGCacheIterator &)ci) {}
+    TQIntCacheIterator<type> &operator=( const TQIntCacheIterator<type>&ci )
+	{ return ( TQIntCacheIterator<type>&)TQGCacheIterator::operator=( ci );}
+    uint  count()   const     { return TQGCacheIterator::count(); }
+    bool  isEmpty() const     { return TQGCacheIterator::count() == 0; }
+    bool  atFirst() const     { return TQGCacheIterator::atFirst(); }
+    bool  atLast()  const     { return TQGCacheIterator::atLast(); }
+    type *toFirst()	      { return (type *)TQGCacheIterator::toFirst(); }
+    type *toLast()	      { return (type *)TQGCacheIterator::toLast(); }
+    operator type *()  const  { return (type *)TQGCacheIterator::get(); }
+    type *current()    const  { return (type *)TQGCacheIterator::get(); }
+    long  currentKey() const  { return (long)TQGCacheIterator::getKeyInt();}
+    type *operator()()	      { return (type *)TQGCacheIterator::operator()();}
+    type *operator++()	      { return (type *)TQGCacheIterator::operator++(); }
+    type *operator+=(uint j)  { return (type *)TQGCacheIterator::operator+=(j);}
+    type *operator--()	      { return (type *)TQGCacheIterator::operator--(); }
+    type *operator-=(uint j)  { return (type *)TQGCacheIterator::operator-=(j);}
+};
+
+
+#endif // TQINTCACHE_H
diff --git a/tqtinterface/qt4/src/tools/tqintdict.h b/tqtinterface/qt4/src/tools/tqintdict.h
new file mode 100644
index 0000000..dc6cc2e
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqintdict.h
@@ -0,0 +1,119 @@
+/****************************************************************************
+**
+** Definition of TQIntDict template class
+**
+** Created : 940624
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQINTDICT_H
+#define TQINTDICT_H
+
+#ifndef TQT_H
+#include "tqgdict.h"
+#endif // TQT_H
+
+template<class type>
+class TQIntDict
+#ifdef TQ_TQDOC
+	: public TQPtrCollection
+#else
+	: public TQGDict
+#endif
+{
+public:
+    TQIntDict(int size=17) : TQGDict(size,IntKey,0,0) {}
+    TQIntDict( const TQIntDict<type> &d ) : TQGDict(d) {}
+   ~TQIntDict()				{ clear(); }
+    TQIntDict<type> &operator=(const TQIntDict<type> &d)
+			{ return (TQIntDict<type>&)TQGDict::operator=(d); }
+    uint  count()   const		{ return TQGDict::count(); }
+    uint  size()    const		{ return TQGDict::size(); }
+    bool  isEmpty() const		{ return TQGDict::count() == 0; }
+    void  insert( long k, const type *d )
+					{ TQGDict::look_int(k,(Item)d,1); }
+    void  tqreplace( long k, const type *d )
+					{ TQGDict::look_int(k,(Item)d,2); }
+    bool  remove( long k )		{ return TQGDict::remove_int(k); }
+    type *take( long k )		{ return (type*)TQGDict::take_int(k); }
+    type *tqfind( long k ) const
+		{ return (type *)((TQGDict*)this)->TQGDict::look_int(k,0,0); }
+    type *operator[]( long k ) const
+		{ return (type *)((TQGDict*)this)->TQGDict::look_int(k,0,0); }
+    void  clear()			{ TQGDict::clear(); }
+    void  resize( uint n )		{ TQGDict::resize(n); }
+    void  statistics() const		{ TQGDict::statistics(); }
+
+#ifdef TQ_TQDOC
+protected:
+    virtual TQDataStream& read( TQDataStream &, TQPtrCollection::Item & );
+    virtual TQDataStream& write( TQDataStream &, TQPtrCollection::Item ) const;
+#endif
+
+private:
+    void  deleteItem( Item d );
+};
+
+#if !defined(TQ_BROKEN_TEMPLATE_SPECIALIZATION)
+template<> inline void TQIntDict<void>::deleteItem( TQPtrCollection::Item )
+{
+}
+#endif
+
+template<class type> inline void TQIntDict<type>::deleteItem( TQPtrCollection::Item d )
+{
+    if ( del_item ) delete (type*)d;
+}
+
+template<class type> 
+class TQIntDictIterator : public TQGDictIterator
+{
+public:
+    TQIntDictIterator(const TQIntDict<type> &d) :TQGDictIterator((TQGDict &)d) {}
+   ~TQIntDictIterator()	      {}
+    uint  count()   const     { return dict->count(); }
+    bool  isEmpty() const     { return dict->count() == 0; }
+    type *toFirst()	      { return (type *)TQGDictIterator::toFirst(); }
+    operator type *()  const  { return (type *)TQGDictIterator::get(); }
+    type *current()    const  { return (type *)TQGDictIterator::get(); }
+    long  currentKey() const  { return TQGDictIterator::getKeyInt(); }
+    type *operator()()	      { return (type *)TQGDictIterator::operator()(); }
+    type *operator++()	      { return (type *)TQGDictIterator::operator++(); }
+    type *operator+=(uint j)  { return (type *)TQGDictIterator::operator+=(j);}
+};
+
+#define TQ_DEFINED_TQINTDICT
+#include "tqwinexport.h"
+#endif // TQINTDICT_H
diff --git a/tqtinterface/qt4/src/tools/tqiodevice.cpp b/tqtinterface/qt4/src/tools/tqiodevice.cpp
new file mode 100644
index 0000000..299d949
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqiodevice.cpp
@@ -0,0 +1,769 @@
+/****************************************************************************
+**
+** Implementation of TQIODevice class
+**
+** Created : 940913
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "tqiodevice.h"
+
+#ifdef USE_QT4
+
+#else // USE_QT4
+
+/*!
+    \class TQIODevice tqiodevice.h
+    \reentrant
+
+    \brief The TQIODevice class is the base class of I/O tqdevices.
+
+    \ingroup io
+
+    An I/O tqdevice represents a medium that one can read bytes from
+    and/or write bytes to. The TQIODevice class is the abstract
+    superclass of all such tqdevices; classes such as TQFile, TQBuffer and
+    TQSocket inherit TQIODevice and implement virtual functions such as
+    write() appropriately.
+
+    Although applications sometimes use TQIODevice directly, it is
+    usually better to use TQTextStream and TQDataStream, which provide
+    stream operations on any TQIODevice subclass. TQTextStream provides
+    text-oriented stream functionality (for human-readable ASCII
+    files, for example), whereas TQDataStream deals with binary data in
+    a totally platform-independent manner.
+
+    The public member functions in TQIODevice roughly fall into two
+    groups: the action functions and the state access functions. The
+    most important action functions are:
+
+    \list
+
+    \i  open() opens a tqdevice for reading and/or writing, depending on
+    the mode argument.
+
+    \i  close() closes the tqdevice and tidies up (e.g. flushes buffered
+    data)
+
+    \i  readBlock() reads a block of data from the tqdevice.
+
+    \i  writeBlock() writes a block of data to the tqdevice.
+
+    \i  readLine() reads a line (of text, usually) from the tqdevice.
+
+    \i  flush() ensures that all buffered data are written to the real tqdevice.
+
+    \endlist
+
+    There are also some other, less used, action functions:
+
+    \list
+
+    \i  getch() reads a single character.
+
+    \i  ungetch() forgets the last call to getch(), if possible.
+
+    \i  putch() writes a single character.
+
+    \i  size() returns the size of the tqdevice, if there is one.
+
+    \i  at() returns the current read/write pointer's position, if there
+    is one for this tqdevice, or it moves the pointer if given an offset.
+
+    \i  atEnd() indicates whether there is more to read, if this is
+    meaningful for this tqdevice.
+
+    \i  reset() moves the read/write pointer to the start of the
+    tqdevice, if that is possible for this tqdevice.
+
+    \endlist
+
+    The state access are all "get" functions. The TQIODevice subclass
+    calls setState() to update the state, and simple access functions
+    tell the user of the tqdevice what the tqdevice's state is. Here are
+    the settings, and their associated access functions:
+
+    \list
+
+    \i  Access type. Some tqdevices are direct access (it is possible
+    to read/write anywhere), whereas others are sequential. TQIODevice
+    provides the access functions (isDirectAccess(),
+    isSequentialAccess(), and isCombinedAccess()) to tell users what a
+    given I/O tqdevice supports.
+
+    \i  Buffering. Some tqdevices are accessed in raw mode, whereas
+    others are buffered. Buffering usually provides greater
+    efficiency, particularly for small read/write operations.
+    isBuffered() tells the user whether a given tqdevice is buffered.
+    (This can often be set by the application in the call to open().)
+
+    \i  Synchronicity. Synchronous tqdevices work immediately (for
+    example, files). When you read from a file, the file delivers its
+    data straight away. Other kinds of tqdevice, such as a socket
+    connected to a HTTP server, may not deliver the data until seconds
+    after you ask to read it. isSynchronous() and isAsynchronous()
+    tell the user how this tqdevice operates.
+
+    \i  CR/LF translation. For simplicity, applications often like to
+    see just a single CR/LF style, and TQIODevice subclasses can
+    provide this. isTranslated() returns TRUE if this object
+    translates CR/LF to just LF. (This can often be set by the
+    application in the call to open().)
+
+    \i  Permissions. Some files cannot be written. For example,
+    isReadable(), isWritable() and isReadWrite() tell the application
+    whether it can read from and write to a given tqdevice. (This can
+    often be set by the application in the call to open().)
+
+    \i  Finally, isOpen() returns TRUE if the tqdevice is open, i.e.
+    after an open() call.
+
+    \endlist
+
+    TQIODevice provides numerous pure virtual functions that you need
+    to implement when subclassing it. Here is a skeleton subclass with
+    all the members you are sure to need and some that you will
+    probably need:
+
+    \code
+    class MyDevice : public TQIODevice
+    {
+    public:
+	MyDevice();
+	~MyDevice();
+
+	bool open( int mode );
+	void close();
+	void flush();
+
+	uint size() const;
+	int  at() const;	// non-pure virtual
+	bool at( int );		// non-pure virtual
+	bool atEnd() const;	// non-pure virtual
+
+	int readBlock( char *data, uint maxlen );
+	int writeBlock( const char *data, uint len );
+	int readLine( char *data, uint maxlen );
+
+	int getch();
+	int putch( int );
+	int ungetch( int );
+    };
+    \endcode
+
+    The three non-pure virtual functions need not be reimplemented for
+    sequential tqdevices.
+
+    \sa TQDataStream, TQTextStream
+*/
+
+/*!
+    \enum TQIODevice::Offset
+
+    The offset within the tqdevice.
+*/
+
+
+/*!
+    Constructs an I/O tqdevice.
+*/
+
+TQIODevice::TQIODevice()
+{
+    ioMode = 0;					// initial mode
+    ioSt = IO_Ok;
+    ioIndex = 0;
+}
+
+/*!
+    Destroys the I/O tqdevice.
+*/
+
+TQIODevice::~TQIODevice()
+{
+}
+
+
+/*!
+    \fn int TQIODevice::flags() const
+
+    Returns the current I/O tqdevice flags setting.
+
+    Flags consists of mode flags and state flags.
+
+    \sa mode(), state()
+*/
+
+/*!
+    \fn int TQIODevice::mode() const
+
+    Returns bits OR'ed together that specify the current operation
+    mode.
+
+    These are the flags that were given to the open() function.
+
+    The flags are \c IO_ReadOnly, \c IO_WriteOnly, \c IO_ReadWrite,
+    \c IO_Append, \c IO_Truncate and \c IO_Translate.
+*/
+
+/*!
+    \fn int TQIODevice::state() const
+
+    Returns bits OR'ed together that specify the current state.
+
+    The flags are: \c IO_Open.
+
+    Subclasses may define additional flags.
+*/
+
+/*!
+    \fn bool TQIODevice::isDirectAccess() const
+
+    Returns TRUE if the I/O tqdevice is a direct access tqdevice;
+    otherwise returns FALSE, i.e. if the tqdevice is a sequential access
+    tqdevice.
+
+    \sa isSequentialAccess()
+*/
+
+/*!
+    \fn bool TQIODevice::isSequentialAccess() const
+
+    Returns TRUE if the tqdevice is a sequential access tqdevice;
+    otherwise returns FALSE, i.e. if the tqdevice is a direct access
+    tqdevice.
+
+    Operations involving size() and at(int) are not valid on
+    sequential tqdevices.
+
+    \sa isDirectAccess()
+*/
+
+/*!
+    \fn bool TQIODevice::isCombinedAccess() const
+
+    Returns TRUE if the I/O tqdevice is a combined access (both direct
+    and sequential) tqdevice; otherwise returns FALSE.
+
+    This access method is currently not in use.
+*/
+
+/*!
+    \fn bool TQIODevice::isBuffered() const
+
+    Returns TRUE if the I/O tqdevice is a buffered tqdevice; otherwise
+    returns FALSE, i.e. the tqdevice is a raw tqdevice.
+
+    \sa isRaw()
+*/
+
+/*!
+    \fn bool TQIODevice::isRaw() const
+
+    Returns TRUE if the tqdevice is a raw tqdevice; otherwise returns
+    FALSE, i.e. if the tqdevice is a buffered tqdevice.
+
+    \sa isBuffered()
+*/
+
+/*!
+    \fn bool TQIODevice::isSynchronous() const
+
+    Returns TRUE if the I/O tqdevice is a synchronous tqdevice; otherwise
+    returns FALSE, i.e. the tqdevice is an asynchronous tqdevice.
+
+    \sa isAsynchronous()
+*/
+
+/*!
+    \fn bool TQIODevice::isAsynchronous() const
+
+    Returns TRUE if the tqdevice is an asynchronous tqdevice; otherwise
+    returns FALSE, i.e. if the tqdevice is a synchronous tqdevice.
+
+    This mode is currently not in use.
+
+    \sa isSynchronous()
+*/
+
+/*!
+    \fn bool TQIODevice::isTranslated() const
+
+    Returns TRUE if the I/O tqdevice translates carriage-return and
+    linefeed characters; otherwise returns FALSE.
+
+    A TQFile is translated if it is opened with the \c IO_Translate
+    mode flag.
+*/
+
+/*!
+    \fn bool TQIODevice::isReadable() const
+
+    Returns TRUE if the I/O tqdevice was opened using \c IO_ReadOnly or
+    \c IO_ReadWrite mode; otherwise returns FALSE.
+
+    \sa isWritable(), isReadWrite()
+*/
+
+/*!
+    \fn bool TQIODevice::isWritable() const
+
+    Returns TRUE if the I/O tqdevice was opened using \c IO_WriteOnly or
+    \c IO_ReadWrite mode; otherwise returns FALSE.
+
+    \sa isReadable(), isReadWrite()
+*/
+
+/*!
+    \fn bool TQIODevice::isReadWrite() const
+
+    Returns TRUE if the I/O tqdevice was opened using \c IO_ReadWrite
+    mode; otherwise returns FALSE.
+
+    \sa isReadable(), isWritable()
+*/
+
+/*!
+    \fn bool TQIODevice::isInactive() const
+
+    Returns TRUE if the I/O tqdevice state is 0, i.e. the tqdevice is not
+    open; otherwise returns FALSE.
+
+    \sa isOpen()
+*/
+
+/*!
+    \fn bool TQIODevice::isOpen() const
+
+    Returns TRUE if the I/O tqdevice has been opened; otherwise returns
+    FALSE.
+
+    \sa isInactive()
+*/
+
+
+/*!
+    \fn int TQIODevice::status() const
+
+    Returns the I/O tqdevice status.
+
+    The I/O tqdevice status returns an error code. If open() returns
+    FALSE or readBlock() or writeBlock() return -1, this function can
+    be called to tqfind out the reason why the operation failed.
+
+    \keyword IO_Ok
+    \keyword IO_ReadError
+    \keyword IO_WriteError
+    \keyword IO_FatalError
+    \keyword IO_OpenError
+    \keyword IO_ConnectError
+    \keyword IO_AbortError
+    \keyword IO_TimeOutError
+    \keyword IO_UnspecifiedError
+
+    The status codes are:
+    \table
+    \header \i tqStatus code \i Meaning
+    \row \i \c IO_Ok \i The operation was successful.
+    \row \i \c IO_ReadError \i Could not read from the tqdevice.
+    \row \i \c IO_WriteError \i Could not write to the tqdevice.
+    \row \i \c IO_FatalError \i A fatal unrecoverable error occurred.
+    \row \i \c IO_OpenError \i Could not open the tqdevice.
+    \row \i \c IO_ConnectError \i Could not connect to the tqdevice.
+    \row \i \c IO_AbortError \i The operation was unexpectedly aborted.
+    \row \i \c IO_TimeOutError \i The operation timed out.
+    \row \i \c IO_UnspecifiedError \i An unspecified error happened on close.
+    \endtable
+
+    \sa resetqStatus()
+*/
+
+/*!
+    \fn void TQIODevice::resetqStatus()
+
+    Sets the I/O tqdevice status to \c IO_Ok.
+
+    \sa status()
+*/
+
+
+/*!
+  \fn void TQIODevice::setFlags( int flags )
+
+  Used by subclasses to set the tqdevice flags to the \a flags specified.
+*/
+
+/*!
+  \fn void TQIODevice::setType( int type )
+
+  Used by subclasses to set the tqdevice type to the \a type specified.
+*/
+
+void TQIODevice::setType( int t )
+{
+#if defined(TQT_CHECK_RANGE)
+    if ( (t & IO_TypeMask) != t )
+	qWarning( "TQIODevice::setType: Specified type out of range" );
+#endif
+    ioMode &= ~IO_TypeMask;			// reset type bits
+    ioMode |= t;
+}
+
+/*!
+  \fn void TQIODevice::setMode( int mode )
+
+  Used by subclasses to set the tqdevice mode to the \a mode specified.
+*/
+
+void TQIODevice::setMode( int m )
+{
+#if defined(TQT_CHECK_RANGE)
+    if ( (m & IO_ModeMask) != m )
+	qWarning( "TQIODevice::setMode: Specified mode out of range" );
+#endif
+    ioMode &= ~IO_ModeMask;			// reset mode bits
+    ioMode |= m;
+}
+
+/*!
+  \fn void TQIODevice::setState( int state )
+
+  Used by subclasses to set the tqdevice state to the \a state specified.
+*/
+
+void TQIODevice::setState( int s )
+{
+#if defined(TQT_CHECK_RANGE)
+    if ( ((uint)s & IO_StateMask) != (uint)s )
+	qWarning( "TQIODevice::setState: Specified state out of range" );
+#endif
+    ioMode &= ~IO_StateMask;			// reset state bits
+    ioMode |= (uint)s;
+}
+
+/*!
+  Used by subclasses to set the tqdevice status (not state) to \a s.
+*/
+
+void TQIODevice::setqStatus( int s )
+{
+    ioSt = s;
+}
+
+
+/*!
+    \fn bool TQIODevice::open( int mode )
+
+    Opens the I/O tqdevice using the specified \a mode. Returns TRUE if
+    the tqdevice was successfully opened; otherwise returns FALSE.
+
+    The mode parameter \a mode must be an OR'ed combination of the
+    following flags.
+    \table
+    \header \i Mode flags \i Meaning
+    \row \i \c IO_Raw \i specifies raw (unbuffered) file access.
+    \row \i \c IO_ReadOnly \i opens a file in read-only mode.
+    \row \i \c IO_WriteOnly \i opens a file in write-only mode.
+    \row \i \c IO_ReadWrite \i opens a file in read/write mode.
+    \row \i \c IO_Append \i sets the file index to the end of the file.
+    \row \i \c IO_Truncate \i truncates the file.
+    \row \i \c IO_Translate \i enables carriage returns and linefeed
+    translation for text files under MS-DOS, Windows and Macintosh. On
+    Unix systems this flag has no effect. Use with caution as it will
+    also transform every linefeed written to the file into a CRLF
+    pair. This is likely to corrupt your file if you write write
+    binary data. Cannot be combined with \c IO_Raw.
+    \endtable
+
+    This virtual function must be reimplemented by all subclasses.
+
+    \sa close()
+*/
+
+/*!
+    \fn void TQIODevice::close()
+
+    Closes the I/O tqdevice.
+
+    This virtual function must be reimplemented by all subclasses.
+
+    \sa open()
+*/
+
+/*!
+    \fn void TQIODevice::flush()
+
+    Flushes an open I/O tqdevice.
+
+    This virtual function must be reimplemented by all subclasses.
+*/
+
+
+/*!
+    \fn TQIODevice::Offset TQIODevice::size() const
+
+    Virtual function that returns the size of the I/O tqdevice.
+
+    \sa at()
+*/
+
+/*!
+    Virtual function that returns the current I/O tqdevice position.
+
+    This is the position of the data read/write head of the I/O
+    tqdevice.
+
+    \sa size()
+*/
+
+TQIODevice::Offset TQIODevice::at() const
+{
+    return ioIndex;
+}
+
+
+/*
+    The following is a "bad" overload, since it does "not behave essentially
+    the same" like the above. So don't use  \overload in the documentation of
+    this function and we have to live with the qdoc warning which is generated
+    for this.
+*/
+/*!
+    Virtual function that sets the I/O tqdevice position to \a pos.
+    Returns TRUE if the position was successfully set, i.e. \a pos is
+    within range and the seek was successful; otherwise returns FALSE.
+
+    \sa size()
+*/
+
+bool TQIODevice::at( Offset pos )
+{
+#if defined(TQT_CHECK_RANGE)
+    if ( pos > size() ) {
+#if defined(TQT_ABI_QT4)
+	qWarning( "TQIODevice::at: Index %lld out of range", pos );
+#else
+	qWarning( "TQIODevice::at: Index %lu out of range", pos );
+#endif
+	return FALSE;
+    }
+#endif
+    ioIndex = pos;
+    return TRUE;
+}
+
+/*!
+    Virtual function that returns TRUE if the I/O tqdevice position is
+    at the end of the input; otherwise returns FALSE.
+*/
+
+bool TQIODevice::atEnd() const
+{
+    if ( isSequentialAccess() || isTranslated() ) {
+	TQIODevice* that = (TQIODevice*)this;
+        const int oldtqStatus = ioSt;
+	int c = that->getch();
+	bool result = c < 0;
+	that->ungetch(c);
+        if (ioSt != oldtqStatus)
+            that->ioSt = oldtqStatus;
+	return result;
+    } else {
+	return at() == size();
+    }
+}
+
+/*!
+    \fn bool TQIODevice::reset()
+
+    Sets the tqdevice index position to 0.
+
+    \sa at()
+*/
+
+
+/*!
+    \fn int TQIODevice::readBlock( char *data, TQ_ULONG maxlen )
+
+    Reads at most \a maxlen bytes from the I/O tqdevice into \a data and
+    returns the number of bytes actually read.
+
+    This function should return -1 if a fatal error occurs and should
+    return 0 if there are no bytes to read.
+
+    The tqdevice must be opened for reading, and \a data must not be 0.
+
+    This virtual function must be reimplemented by all subclasses.
+
+    \sa writeBlock() isOpen() isReadable()
+*/
+
+/*!
+    This convenience function returns all of the remaining data in the
+    tqdevice.
+*/
+TQByteArray TQIODevice::readAll()
+{
+    if ( isDirectAccess() ) {
+	// we know the size
+	int n = size()-at(); // ### fix for 64-bit or large files?
+	int totalRead = 0;
+	TQByteArray ba( n );
+	char* c = ba.data();
+	while ( n ) {
+	    int r = readBlock( c, n );
+	    if ( r < 0 )
+		return TQByteArray();
+	    n -= r;
+	    c += r;
+	    totalRead += r;
+	    // If we have a translated file, then it is possible that
+	    // we read less bytes than size() reports
+	    if ( atEnd() ) {
+		ba.resize( totalRead );
+		break;
+	    }
+	}
+	return ba;
+    } else {
+	// read until we reach the end
+	const int blocksize = 512;
+	int nread = 0;
+	TQByteArray ba;
+	while ( !atEnd() ) {
+	    ba.resize( nread + blocksize );
+	    int r = readBlock( ba.data()+nread, blocksize );
+	    if ( r < 0 )
+		return TQByteArray();
+	    nread += r;
+	}
+	ba.resize( nread );
+	return ba;
+    }
+}
+
+/*!
+    \fn int TQIODevice::writeBlock( const char *data, TQ_ULONG len )
+
+    Writes \a len bytes from \a data to the I/O tqdevice and returns the
+    number of bytes actually written.
+
+    This function should return -1 if a fatal error occurs.
+
+    This virtual function must be reimplemented by all subclasses.
+
+    \sa readBlock()
+*/
+
+/*!
+    \overload
+
+    This convenience function is the same as calling writeBlock(
+    data.data(), data.size() ).
+*/
+TQ_LONG TQIODevice::writeBlock( const TQByteArray& data )
+{
+    return writeBlock( data.data(), data.size() );
+}
+
+/*!
+    Reads a line of text, (or up to \a maxlen bytes if a newline isn't
+    encountered) plus a terminating '\0' into \a data. If there is a
+    newline at the end if the line, it is not stripped.
+
+    Returns the number of bytes read including the terminating '\0',
+    or -1 if an error occurred.
+
+    This virtual function can be reimplemented much more efficiently
+    by the most subclasses.
+
+    \sa readBlock(), TQTextStream::readLine()
+*/
+
+TQ_LONG TQIODevice::readLine( char *data, TQ_ULONG maxlen )
+{
+    if ( maxlen == 0 )				// application bug?
+	return 0;
+    char *p = data;
+    while ( --maxlen && (readBlock(p,1)>0) ) {	// read one byte at a time
+	if ( *p++ == '\n' )			// end of line
+	    break;
+    }
+    *p++ = '\0';
+    return p - data;
+}
+
+
+/*!
+    \fn int TQIODevice::getch()
+
+    Reads a single byte/character from the I/O tqdevice.
+
+    Returns the byte/character read, or -1 if the end of the I/O
+    tqdevice has been reached.
+
+    This virtual function must be reimplemented by all subclasses.
+
+    \sa putch(), ungetch()
+*/
+
+/*!
+    \fn int TQIODevice::putch( int ch )
+
+    Writes the character \a ch to the I/O tqdevice.
+
+    Returns \a ch, or -1 if an error occurred.
+
+    This virtual function must be reimplemented by all subclasses.
+
+    \sa getch(), ungetch()
+*/
+
+/*!
+    \fn int TQIODevice::ungetch( int ch )
+
+    Puts the character \a ch back into the I/O tqdevice and decrements
+    the index position if it is not zero.
+
+    This function is normally called to "undo" a getch() operation.
+
+    Returns \a ch, or -1 if an error occurred.
+
+    This virtual function must be reimplemented by all subclasses.
+
+    \sa getch(), putch()
+*/
+
+#endif // USE_QT4
diff --git a/tqtinterface/qt4/src/tools/tqiodevice.h b/tqtinterface/qt4/src/tools/tqiodevice.h
new file mode 100644
index 0000000..6fccc9d
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqiodevice.h
@@ -0,0 +1,311 @@
+/****************************************************************************
+**
+** Definition of TQIODevice class
+**
+** Created : 940913
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQIODEVICE_H
+#define TQIODEVICE_H
+
+#include "tqtglobaldefines.h"
+
+#ifndef TQT_H
+#include "tqglobal.h"
+#include "tqcstring.h"
+#endif // TQT_H
+
+#ifdef USE_QT4
+
+#include <Qt/qiodevice.h>
+#include <Qt/qfile.h>
+#include <iostream>
+
+#endif // USE_QT4
+
+#ifdef USE_QT4
+
+#define IO_Direct		0x0100		// direct access tqdevice
+#define IO_Sequential		0x0200		// sequential access tqdevice
+#define IO_Combined		0x0300		// combined direct/sequential
+#define IO_TypeMask		0x0f00
+
+// IO handling modes
+
+#define IO_Raw			0x0040		// raw access (not buffered)
+#define IO_Async		0x0080		// asynchronous mode
+
+// IO tqdevice open modes
+
+#define IO_ReadOnly		(QIODevice::OpenModeFlag)0x0001		// readable tqdevice
+#define IO_WriteOnly		(QIODevice::OpenModeFlag)0x0002		// writable tqdevice
+#define IO_ReadWrite		(QIODevice::OpenModeFlag)0x0003		// read+write tqdevice
+#define IO_Append		(QIODevice::OpenModeFlag)0x0004		// append
+#define IO_Truncate		(QIODevice::OpenModeFlag)0x0008		// truncate tqdevice
+#define IO_Translate		(QIODevice::OpenModeFlag)0x0010		// translate CR+LF
+#define IO_ModeMask		(QIODevice::OpenModeFlag)0x00ff
+
+// IO tqdevice state
+
+#define IO_Open			0x1000		// tqdevice is open
+#define IO_StateMask		0xf000
+
+// IO tqdevice status
+
+#define IO_Ok			0
+#define IO_ReadError		1		// read error
+#define IO_WriteError		2		// write error
+#define IO_FatalError		3		// fatal unrecoverable error
+#define IO_ResourceError	4		// resource limitation
+#define IO_OpenError		5		// cannot open tqdevice
+#define IO_ConnectError		5		// cannot connect to tqdevice
+#define IO_AbortError		6		// abort error
+#define IO_TimeOutError		7		// time out
+#define IO_UnspecifiedError	8		// unspecified error
+
+class TQ_EXPORT TQIODevice : public QIODevice
+{
+public:
+#if defined(TQT_ABI_QT4)
+    typedef TQ_LLONG Offset;
+#else
+    typedef TQ_ULONG Offset;
+#endif
+
+	TQIODevice() : QIODevice() {}
+
+	inline int state() const { return isOpen() ? 0x1000 : 0; }
+	inline int mode() const { return (int) openMode(); }
+	inline int flags() const { return (int) openMode(); }
+	inline bool tqopen( int mode ) { return open((OpenModeFlag)mode); }
+
+	inline Offset at() const { return pos(); }
+	inline bool at(Offset offset) { return seek(offset); }
+	inline Offset tqat() const { return pos(); }
+	inline bool tqat(Offset offset) { return seek(offset); }
+
+// 	virtual inline qint64 readBlock(char *data, quint64 maxlen) { return read(data, maxlen); }
+// 	virtual inline qint64 writeBlock(const char *data, quint64 len) { return write(data, len); }
+// 	virtual inline qint64 writeBlock(const QByteArray &data) { return write(data); }
+	inline qint64 readBlock(char *data, quint64 maxlen) { return read(data, maxlen); }
+	inline qint64 writeBlock(const char *data, quint64 len) { return write(data, len); }
+	inline qint64 writeBlock(const QByteArray &data) { return write(data); }
+
+// 	virtual inline qint64 readData ( char * data, qint64 maxSize ) { return readBlock(data, maxSize); }
+// 	virtual inline qint64 writeData ( const char * data, qint64 maxSize ) { return writeBlock(data, maxSize); }
+
+	inline int getch() { char c; return getChar(&c) ? int(uchar(c)) : -1; }
+	inline int putch(int c) { return putChar(char(c)) ? int(uchar(c)) : -1; }
+	inline int ungetch(int c) { ungetChar(uchar(c)); return c; }
+	virtual void flush() = 0;
+
+	inline bool isDirectAccess() const { return !isSequential(); }
+	inline bool isSequentialAccess() const { return isSequential(); }
+	inline bool isCombinedAccess() const { return false; }
+	inline bool isBuffered() const { return true; }
+	inline bool isRaw() const { return false; }
+	inline bool isSynchronous() const { return true; }
+	inline bool isAsynchronous() const { return false; }
+	inline bool isTranslated() const { return (openMode() & Text) != 0; }
+	inline bool isInactive() const { return !isOpen(); }
+
+// 	inline bool open( int mode ) = 0;
+
+protected:
+	void setFlags( int f ) { setOpenMode((QIODevice::OpenModeFlag)f); }
+	void setType( int ) { printf("[WARNING] TQIODevice::setType() unimplemented\n\r"); }
+	void setMode( int f ) { setOpenMode((QIODevice::OpenModeFlag)f); }
+	void setState( int state ) {
+		switch (state) {
+			case (IO_Open):
+				QIODevice::open(openMode());
+				break;
+		}
+	}
+
+public:
+	typedef int Status;
+	Status status() const {
+#if !defined(QT_NO_QOBJECT)
+		const QFile *f = qobject_cast<const QFile *>(this);
+		if (f) return (int) f->error();
+#endif
+		return isOpen() ? 0 /* IO_Ok */ : 8 /* IO_UnspecifiedError */;
+	}
+	void resetStatus() {
+#if !defined(QT_NO_QOBJECT)
+		QFile *f = qobject_cast<QFile *>(this);
+		if (f) f->unsetError();
+#endif
+	}
+
+	void setqStatus( int ) { std::cout << "[WARNING] TQIODevice::setqStatus() UNIMPLEMENTED\n\r"; }
+	void resetqStatus() { resetStatus(); }
+
+protected:
+	friend class TQFile;
+	friend class TQIODeviceSource;
+	friend class TQImageIO;
+	friend class TQBuffer;
+
+public:
+	// Interoperability
+	static TQIODevice& convertFromQIODevice( QIODevice& qiod );
+};
+
+// Interoperability
+inline static TQIODevice& convertFromQIODevice( QIODevice& qiod ) {
+	return (*static_cast<TQIODevice*>(&qiod));
+}
+
+#else // USE_QT4
+
+// IO tqdevice access types
+
+#define IO_Direct		0x0100		// direct access tqdevice
+#define IO_Sequential		0x0200		// sequential access tqdevice
+#define IO_Combined		0x0300		// combined direct/sequential
+#define IO_TypeMask		0x0f00
+
+// IO handling modes
+
+#define IO_Raw			0x0040		// raw access (not buffered)
+#define IO_Async		0x0080		// asynchronous mode
+
+// IO tqdevice open modes
+
+#define IO_ReadOnly		0x0001		// readable tqdevice
+#define IO_WriteOnly		0x0002		// writable tqdevice
+#define IO_ReadWrite		0x0003		// read+write tqdevice
+#define IO_Append		0x0004		// append
+#define IO_Truncate		0x0008		// truncate tqdevice
+#define IO_Translate		0x0010		// translate CR+LF
+#define IO_ModeMask		0x00ff
+
+// IO tqdevice state
+
+#define IO_Open			0x1000		// tqdevice is open
+#define IO_StateMask		0xf000
+
+// IO tqdevice status
+
+#define IO_Ok			0
+#define IO_ReadError		1		// read error
+#define IO_WriteError		2		// write error
+#define IO_FatalError		3		// fatal unrecoverable error
+#define IO_ResourceError	4		// resource limitation
+#define IO_OpenError		5		// cannot open tqdevice
+#define IO_ConnectError		5		// cannot connect to tqdevice
+#define IO_AbortError		6		// abort error
+#define IO_TimeOutError		7		// time out
+#define IO_UnspecifiedError	8		// unspecified error
+
+
+class TQ_EXPORT TQIODevice
+{
+public:
+#if defined(TQT_ABI_QT4)
+    typedef TQ_LLONG Offset;
+#else
+    typedef TQ_ULONG Offset;
+#endif
+
+    TQIODevice();
+    virtual ~TQIODevice();
+
+    int		 flags()  const { return ioMode; }
+    int		 mode()	  const { return ioMode & IO_ModeMask; }
+    int		 state()  const { return ioMode & IO_StateMask; }
+
+    bool	 isDirectAccess()     const { return ((ioMode & IO_Direct)     == IO_Direct); }
+    bool	 isSequentialAccess() const { return ((ioMode & IO_Sequential) == IO_Sequential); }
+    bool	 isCombinedAccess()   const { return ((ioMode & IO_Combined)   == IO_Combined); }
+    bool	 isBuffered()	      const { return ((ioMode & IO_Raw)        != IO_Raw); }
+    bool	 isRaw()	      const { return ((ioMode & IO_Raw)        == IO_Raw); }
+    bool	 isSynchronous()      const { return ((ioMode & IO_Async)      != IO_Async); }
+    bool	 isAsynchronous()     const { return ((ioMode & IO_Async)      == IO_Async); }
+    bool	 isTranslated()	      const { return ((ioMode & IO_Translate)  == IO_Translate); }
+    bool	 isReadable()	      const { return ((ioMode & IO_ReadOnly)   == IO_ReadOnly); }
+    bool	 isWritable()	      const { return ((ioMode & IO_WriteOnly)  == IO_WriteOnly); }
+    bool	 isReadWrite()	      const { return ((ioMode & IO_ReadWrite)  == IO_ReadWrite); }
+    bool	 isInactive()	      const { return state() == 0; }
+    bool	 isOpen()	      const { return state() == IO_Open; }
+
+    int		 status() const { return ioSt; }
+    void	 resetqStatus()	{ ioSt = IO_Ok; }
+
+    virtual bool open( int mode ) = 0;
+    virtual void close() = 0;
+    virtual void flush() = 0;
+
+    virtual Offset size()  const = 0;
+    virtual Offset at()  const;
+    virtual bool at( Offset );
+    virtual bool atEnd()  const;
+    bool	 reset() { return at(0); }
+
+    virtual TQ_LONG readBlock( char *data, TQ_ULONG maxlen ) = 0;
+    virtual TQ_LONG writeBlock( const char *data, TQ_ULONG len ) = 0;
+    virtual TQ_LONG readLine( char *data, TQ_ULONG maxlen );
+    TQ_LONG writeBlock( const TQByteArray& data );
+    virtual TQByteArray readAll();
+
+    virtual int	 getch() = 0;
+    virtual int	 putch( int ) = 0;
+    virtual int	 ungetch( int ) = 0;
+
+protected:
+    void	 setFlags( int f ) { ioMode = f; }
+    void	 setType( int );
+    void	 setMode( int );
+    void	 setState( int );
+    void	 setqStatus( int );
+    Offset	 ioIndex;
+
+private:
+    int		 ioMode;
+    int		 ioSt;
+
+private:	// Disabled copy constructor and operator=
+#if defined(TQ_DISABLE_COPY)
+    TQIODevice( const TQIODevice & );
+    TQIODevice &operator=( const TQIODevice & );
+#endif
+};
+
+#endif // USE_QT4
+
+#endif // TQIODEVICE_H
diff --git a/tqtinterface/qt4/src/tools/tqiodevice.h~ b/tqtinterface/qt4/src/tools/tqiodevice.h~
new file mode 100644
index 0000000..e34b65d
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqiodevice.h~
@@ -0,0 +1,310 @@
+/****************************************************************************
+**
+** Definition of TQIODevice class
+**
+** Created : 940913
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQIODEVICE_H
+#define TQIODEVICE_H
+
+#include "tqtglobaldefines.h"
+
+#ifndef TQT_H
+#include "tqglobal.h"
+#include "tqcstring.h"
+#endif // TQT_H
+
+#ifdef USE_QT4
+
+#include <Qt/qiodevice.h>
+#include <Qt/qfile.h>
+#include <iostream>
+
+#endif // USE_QT4
+
+#ifdef USE_QT4
+
+#define IO_Direct		0x0100		// direct access tqdevice
+#define IO_Sequential		0x0200		// sequential access tqdevice
+#define IO_Combined		0x0300		// combined direct/sequential
+#define IO_TypeMask		0x0f00
+
+// IO handling modes
+
+#define IO_Raw			0x0040		// raw access (not buffered)
+#define IO_Async		0x0080		// asynchronous mode
+
+// IO tqdevice open modes
+
+#define IO_ReadOnly		(QIODevice::OpenModeFlag)0x0001		// readable tqdevice
+#define IO_WriteOnly		(QIODevice::OpenModeFlag)0x0002		// writable tqdevice
+#define IO_ReadWrite		(QIODevice::OpenModeFlag)0x0003		// read+write tqdevice
+#define IO_Append		(QIODevice::OpenModeFlag)0x0004		// append
+#define IO_Truncate		(QIODevice::OpenModeFlag)0x0008		// truncate tqdevice
+#define IO_Translate		(QIODevice::OpenModeFlag)0x0010		// translate CR+LF
+#define IO_ModeMask		(QIODevice::OpenModeFlag)0x00ff
+
+// IO tqdevice state
+
+#define IO_Open			0x1000		// tqdevice is open
+#define IO_StateMask		0xf000
+
+// IO tqdevice status
+
+#define IO_Ok			0
+#define IO_ReadError		1		// read error
+#define IO_WriteError		2		// write error
+#define IO_FatalError		3		// fatal unrecoverable error
+#define IO_ResourceError	4		// resource limitation
+#define IO_OpenError		5		// cannot open tqdevice
+#define IO_ConnectError		5		// cannot connect to tqdevice
+#define IO_AbortError		6		// abort error
+#define IO_TimeOutError		7		// time out
+#define IO_UnspecifiedError	8		// unspecified error
+
+class TQ_EXPORT TQIODevice : public QIODevice
+{
+public:
+#if defined(TQT_ABI_QT4)
+    typedef TQ_LLONG Offset;
+#else
+    typedef TQ_ULONG Offset;
+#endif
+
+	TQIODevice() : QIODevice() {}
+
+	inline int state() const { return isOpen() ? 0x1000 : 0; }
+	inline int mode() const { return (int) openMode(); }
+	inline int flags() const { return (int) openMode(); }
+	inline bool tqopen( int mode ) { return open((OpenModeFlag)mode); }
+
+	inline Offset at() const { return pos(); }
+	inline bool at(Offset offset) { return seek(offset); }
+	inline Offset tqat() const { return pos(); }
+	inline bool tqat(Offset offset) { return seek(offset); }
+
+// 	virtual inline qint64 readBlock(char *data, quint64 maxlen) { return read(data, maxlen); }
+// 	virtual inline qint64 writeBlock(const char *data, quint64 len) { return write(data, len); }
+// 	virtual inline qint64 writeBlock(const QByteArray &data) { return write(data); }
+	inline qint64 readBlock(char *data, quint64 maxlen) { return read(data, maxlen); }
+	inline qint64 writeBlock(const char *data, quint64 len) { return write(data, len); }
+	inline qint64 writeBlock(const QByteArray &data) { return write(data); }
+
+// 	virtual inline qint64 readData ( char * data, qint64 maxSize ) { return readBlock(data, maxSize); }
+// 	virtual inline qint64 writeData ( const char * data, qint64 maxSize ) { return writeBlock(data, maxSize); }
+
+	inline int getch() { char c; return getChar(&c) ? int(uchar(c)) : -1; }
+	inline int putch(int c) { return putChar(char(c)) ? int(uchar(c)) : -1; }
+	inline int ungetch(int c) { ungetChar(uchar(c)); return c; }
+	virtual void flush() = 0;
+
+	inline bool isDirectAccess() const { return !isSequential(); }
+	inline bool isSequentialAccess() const { return isSequential(); }
+	inline bool isCombinedAccess() const { return false; }
+	inline bool isBuffered() const { return true; }
+	inline bool isRaw() const { return false; }
+	inline bool isSynchronous() const { return true; }
+	inline bool isAsynchronous() const { return false; }
+	inline bool isTranslated() const { return (openMode() & Text) != 0; }
+	inline bool isInactive() const { return !isOpen(); }
+
+// 	inline bool open( int mode ) = 0;
+
+protected:
+	void setFlags( int f ) { setOpenMode((QIODevice::OpenModeFlag)f); }
+	void setType( int ) { printf("[WARNING] TQIODevice::setType() unimplemented\n\r"); }
+	void setMode( int f ) { setOpenMode((QIODevice::OpenModeFlag)f); }
+	void setState( int state ) {
+		switch (state) {
+			case (IO_Open):
+				QIODevice::open(openMode());
+				break;
+		}
+	}
+
+public:
+	typedef int Status;
+	Status status() const {
+#if !defined(QT_NO_QOBJECT)
+		const QFile *f = qobject_cast<const QFile *>(this);
+		if (f) return (int) f->error();
+#endif
+		return isOpen() ? 0 /* IO_Ok */ : 8 /* IO_UnspecifiedError */;
+	}
+	void resetStatus() {
+#if !defined(QT_NO_QOBJECT)
+		QFile *f = qobject_cast<QFile *>(this);
+		if (f) f->unsetError();
+#endif
+	}
+
+protected:
+	void setqStatus( int ) { std::cout << "[WARNING] TQIODevice::setqStatus() UNIMPLEMENTED\n\r"; }
+	void resetqStatus() { resetStatus(); }
+
+	friend class TQFile;
+	friend class TQIODeviceSource;
+	friend class TQImageIO;
+
+public:
+	// Interoperability
+	static TQIODevice& convertFromQIODevice( QIODevice& qiod );
+};
+
+// Interoperability
+inline static TQIODevice& convertFromQIODevice( QIODevice& qiod ) {
+	return (*static_cast<TQIODevice*>(&qiod));
+}
+
+#else // USE_QT4
+
+// IO tqdevice access types
+
+#define IO_Direct		0x0100		// direct access tqdevice
+#define IO_Sequential		0x0200		// sequential access tqdevice
+#define IO_Combined		0x0300		// combined direct/sequential
+#define IO_TypeMask		0x0f00
+
+// IO handling modes
+
+#define IO_Raw			0x0040		// raw access (not buffered)
+#define IO_Async		0x0080		// asynchronous mode
+
+// IO tqdevice open modes
+
+#define IO_ReadOnly		0x0001		// readable tqdevice
+#define IO_WriteOnly		0x0002		// writable tqdevice
+#define IO_ReadWrite		0x0003		// read+write tqdevice
+#define IO_Append		0x0004		// append
+#define IO_Truncate		0x0008		// truncate tqdevice
+#define IO_Translate		0x0010		// translate CR+LF
+#define IO_ModeMask		0x00ff
+
+// IO tqdevice state
+
+#define IO_Open			0x1000		// tqdevice is open
+#define IO_StateMask		0xf000
+
+// IO tqdevice status
+
+#define IO_Ok			0
+#define IO_ReadError		1		// read error
+#define IO_WriteError		2		// write error
+#define IO_FatalError		3		// fatal unrecoverable error
+#define IO_ResourceError	4		// resource limitation
+#define IO_OpenError		5		// cannot open tqdevice
+#define IO_ConnectError		5		// cannot connect to tqdevice
+#define IO_AbortError		6		// abort error
+#define IO_TimeOutError		7		// time out
+#define IO_UnspecifiedError	8		// unspecified error
+
+
+class TQ_EXPORT TQIODevice
+{
+public:
+#if defined(TQT_ABI_QT4)
+    typedef TQ_LLONG Offset;
+#else
+    typedef TQ_ULONG Offset;
+#endif
+
+    TQIODevice();
+    virtual ~TQIODevice();
+
+    int		 flags()  const { return ioMode; }
+    int		 mode()	  const { return ioMode & IO_ModeMask; }
+    int		 state()  const { return ioMode & IO_StateMask; }
+
+    bool	 isDirectAccess()     const { return ((ioMode & IO_Direct)     == IO_Direct); }
+    bool	 isSequentialAccess() const { return ((ioMode & IO_Sequential) == IO_Sequential); }
+    bool	 isCombinedAccess()   const { return ((ioMode & IO_Combined)   == IO_Combined); }
+    bool	 isBuffered()	      const { return ((ioMode & IO_Raw)        != IO_Raw); }
+    bool	 isRaw()	      const { return ((ioMode & IO_Raw)        == IO_Raw); }
+    bool	 isSynchronous()      const { return ((ioMode & IO_Async)      != IO_Async); }
+    bool	 isAsynchronous()     const { return ((ioMode & IO_Async)      == IO_Async); }
+    bool	 isTranslated()	      const { return ((ioMode & IO_Translate)  == IO_Translate); }
+    bool	 isReadable()	      const { return ((ioMode & IO_ReadOnly)   == IO_ReadOnly); }
+    bool	 isWritable()	      const { return ((ioMode & IO_WriteOnly)  == IO_WriteOnly); }
+    bool	 isReadWrite()	      const { return ((ioMode & IO_ReadWrite)  == IO_ReadWrite); }
+    bool	 isInactive()	      const { return state() == 0; }
+    bool	 isOpen()	      const { return state() == IO_Open; }
+
+    int		 status() const { return ioSt; }
+    void	 resetqStatus()	{ ioSt = IO_Ok; }
+
+    virtual bool open( int mode ) = 0;
+    virtual void close() = 0;
+    virtual void flush() = 0;
+
+    virtual Offset size()  const = 0;
+    virtual Offset at()  const;
+    virtual bool at( Offset );
+    virtual bool atEnd()  const;
+    bool	 reset() { return at(0); }
+
+    virtual TQ_LONG readBlock( char *data, TQ_ULONG maxlen ) = 0;
+    virtual TQ_LONG writeBlock( const char *data, TQ_ULONG len ) = 0;
+    virtual TQ_LONG readLine( char *data, TQ_ULONG maxlen );
+    TQ_LONG writeBlock( const TQByteArray& data );
+    virtual TQByteArray readAll();
+
+    virtual int	 getch() = 0;
+    virtual int	 putch( int ) = 0;
+    virtual int	 ungetch( int ) = 0;
+
+protected:
+    void	 setFlags( int f ) { ioMode = f; }
+    void	 setType( int );
+    void	 setMode( int );
+    void	 setState( int );
+    void	 setqStatus( int );
+    Offset	 ioIndex;
+
+private:
+    int		 ioMode;
+    int		 ioSt;
+
+private:	// Disabled copy constructor and operator=
+#if defined(TQ_DISABLE_COPY)
+    TQIODevice( const TQIODevice & );
+    TQIODevice &operator=( const TQIODevice & );
+#endif
+};
+
+#endif // USE_QT4
+
+#endif // TQIODEVICE_H
diff --git a/tqtinterface/qt4/src/tools/tqlibrary.cpp b/tqtinterface/qt4/src/tools/tqlibrary.cpp
new file mode 100644
index 0000000..140e017
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqlibrary.cpp
@@ -0,0 +1,442 @@
+/****************************************************************************
+**
+** Implementation of TQLibrary class
+**
+** Created : 000101
+**
+** Copyright (C) 2000-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "tqplatformdefs.h"
+#include <private/tqlibrary_p.h>
+#include <tqstringlist.h>
+#include <tqfile.h>
+
+#ifndef TQT_NO_LIBRARY
+
+// uncomment this to get error messages
+//#define TQT_DEBUG_COMPONENT 1
+// uncomment this to get error and success messages
+//#define TQT_DEBUG_COMPONENT 2
+
+#ifndef TQT_DEBUG_COMPONENT
+# if defined(TQT_DEBUG)
+#  define TQT_DEBUG_COMPONENT 1
+# endif
+#endif
+
+#if (defined(TQ_WS_WIN) && !defined(TQT_MAKEDLL)) \
+    || (defined(TQ_OS_FREEBSD) && defined(TQ_CC_INTEL)) \
+    || (defined(TQ_OS_IRIX) && defined(TQ_CC_GNU))
+#define TQT_NO_LIBRARY_UNLOAD
+#endif
+
+TQLibraryPrivate::TQLibraryPrivate( TQLibrary *lib )
+    : pHnd( 0 ), library( lib )
+{
+}
+
+
+/*!
+    \class TQLibrary tqlibrary.h
+    \reentrant
+    \brief The TQLibrary class provides a wrapper for handling shared libraries.
+
+    \mainclass
+    \ingroup plugins
+
+    An instance of a TQLibrary object can handle a single shared
+    library and provide access to the functionality in the library in
+    a platform independent way. If the library is a component server,
+    TQLibrary provides access to the exported component and can
+    directly query this component for interfaces.
+
+    TQLibrary ensures that the shared library is loaded and stays in
+    memory whilst it is in use. TQLibrary can also unload the library
+    on destruction and release unused resources.
+
+    A typical use of TQLibrary is to resolve an exported symbol in a
+    shared object, and to call the function that this symbol
+    represents. This is called "explicit linking" in contrast to
+    "implicit linking", which is done by the link step in the build
+    process when linking an executable against a library.
+
+    The following code snippet loads a library, resolves the symbol
+    "mysymbol", and calls the function if everything succeeded. If
+    something went wrong, e.g. the library file does not exist or the
+    symbol is not defined, the function pointer will be 0 and won't be
+    called. When the TQLibrary object is destroyed the library will be
+    unloaded, making all references to memory allocated in the library
+    invalid.
+
+    \code
+    typedef void (*MyPrototype)();
+    MyPrototype myFunction;
+
+    TQLibrary myLib( "mylib" );
+    myFunction = (MyPrototype) myLib.resolve( "mysymbol" );
+    if ( myFunction ) {
+	myFunction();
+    }
+    \endcode
+*/
+
+/*!
+    Creates a TQLibrary object for the shared library \a filename. The
+    library will be unloaded in the destructor.
+
+    Note that \a filename does not need to include the (platform specific)
+    file extension, so calling
+    \code
+    TQLibrary lib( "mylib" );
+    \endcode
+    is equivalent to calling
+    \code
+    TQLibrary lib( "mylib.dll" );
+    \endcode
+    on Windows, and
+    \code
+    TQLibrary lib( "libmylib.so" );
+    \endcode
+    on Unix. Specifying the extension is not recommended, since
+    doing so introduces a platform dependency.
+
+    If \a filename does not include a path, the library loader will
+    look for the file in the platform specific search paths.
+
+    \sa load() unload(), setAutoUnload()
+*/
+TQLibrary::TQLibrary( const TQString& filename )
+    : libfile( filename ), aunload( TRUE )
+{
+    libfile.tqreplace( '\\', '/' );
+    d = new TQLibraryPrivate( this );
+}
+
+/*!
+    Deletes the TQLibrary object.
+
+    The library will be unloaded if autoUnload() is TRUE (the
+    default), otherwise it stays in memory until the application
+    exits.
+
+    \sa unload(), setAutoUnload()
+*/
+TQLibrary::~TQLibrary()
+{
+    if ( autoUnload() )
+	unload();
+
+    delete d;
+}
+
+/*!
+    Returns the address of the exported symbol \a symb. The library is
+    loaded if necessary. The function returns 0 if the symbol could
+    not be resolved or the library could not be loaded.
+
+    \code
+    typedef int (*avgProc)( int, int );
+
+    avgProc avg = (avgProc) library->resolve( "avg" );
+    if ( avg )
+	return avg( 5, 8 );
+    else
+	return -1;
+    \endcode
+
+    The symbol must be exported as a C-function from the library. This
+    requires the \c {extern "C"} notation if the library is compiled
+    with a C++ compiler. On Windows you also have to explicitly export
+    the function from the DLL using the \c {__declspec(dllexport)}
+    compiler directive.
+
+    \code
+    extern "C" MY_EXPORT_MACRO int avg(int a, int b)
+    {
+	return (a + b) / 2;
+    }
+    \endcode
+
+    with \c MY_EXPORT defined as
+
+    \code
+    #ifdef TQ_WS_WIN
+    # define MY_EXPORT __declspec(dllexport)
+    #else
+    # define MY_EXPORT
+    #endif
+    \endcode
+
+    On Darwin and Mac OS X this function uses code from dlcompat, part of the
+    OpenDarwin project.
+
+    \legalese
+
+    Copyright (c) 2002 Jorge Acereda and Peter O'Gorman
+
+    Permission is hereby granted, free of charge, to any person obtaining
+    a copy of this software and associated documentation files (the
+    "Software"), to deal in the Software without restriction, including
+    without limitation the rights to use, copy, modify, merge, publish,
+    distribute, sublicense, and/or sell copies of the Software, and to
+    permit persons to whom the Software is furnished to do so, subject to
+    the following conditions:
+
+    The above copyright notice and this permission notice shall be
+    included in all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+    LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+    OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+    WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+void *TQLibrary::resolve( const char* symb )
+{
+    if ( !d->pHnd )
+	load();
+    if ( !d->pHnd )
+	return 0;
+
+    void *address = d->resolveSymbol( symb );
+
+    return address;
+}
+
+/*!
+    \overload
+
+    Loads the library \a filename and returns the address of the
+    exported symbol \a symb. Note that like the constructor, \a
+    filename does not need to include the (platform specific) file
+    extension. The library remains loaded until the process exits.
+
+    The function returns 0 if the symbol could not be resolved or the
+    library could not be loaded.
+
+    This function is useful only if you want to resolve a single
+    symbol, e.g. a function pointer from a specific library once:
+
+    \code
+    typedef void (*FunctionType)();
+    static FunctionType *ptrFunction = 0;
+    static bool triedResolve = FALSE;
+    if ( !ptrFunction && !triedResolve )
+	ptrFunction = TQLibrary::resolve( "mylib", "mysymb" );
+
+    if ( ptrFunction )
+	ptrFunction();
+    else
+	...
+    \endcode
+
+    If you want to resolve multiple symbols, use a TQLibrary object and
+    call the non-static version of resolve().
+
+    \sa resolve()
+*/
+void *TQLibrary::resolve( const TQString &filename, const char *symb )
+{
+    TQLibrary lib( filename );
+    lib.setAutoUnload( FALSE );
+    return lib.resolve( symb );
+}
+
+/*!
+    Returns TRUE if the library is loaded; otherwise returns FALSE.
+
+    \sa unload()
+*/
+bool TQLibrary::isLoaded() const
+{
+    return d->pHnd != 0;
+}
+
+/*!
+    Loads the library. Since resolve() always calls this function
+    before resolving any symbols it is not necessary to call it
+    explicitly. In some situations you might want the library loaded
+    in advance, in which case you would use this function.
+
+    On Darwin and Mac OS X this function uses code from dlcompat, part of the
+    OpenDarwin project.
+
+    \legalese
+
+    Copyright (c) 2002 Jorge Acereda and Peter O'Gorman
+
+    Permission is hereby granted, free of charge, to any person obtaining
+    a copy of this software and associated documentation files (the
+    "Software"), to deal in the Software without restriction, including
+    without limitation the rights to use, copy, modify, merge, publish,
+    distribute, sublicense, and/or sell copies of the Software, and to
+    permit persons to whom the Software is furnished to do so, subject to
+    the following conditions:
+
+    The above copyright notice and this permission notice shall be
+    included in all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+    LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+    OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+    WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+bool TQLibrary::load()
+{
+    if (libfile.isEmpty())
+        return FALSE;
+    return d->loadLibrary();
+}
+
+/*!
+    Unloads the library and returns TRUE if the library could be
+    unloaded; otherwise returns FALSE.
+
+    This function is called by the destructor if autoUnload() is
+    enabled.
+
+    \sa resolve()
+*/
+bool TQLibrary::unload()
+{
+    if ( !d->pHnd )
+	return TRUE;
+
+#if !defined(TQT_NO_LIBRARY_UNLOAD)
+    if ( !d->freeLibrary() ) {
+# if defined(TQT_DEBUG_COMPONENT)
+	qWarning( "%s could not be unloaded", (const char*) TQFile::encodeName(library()) );
+# endif
+	return FALSE;
+    }
+
+# if defined(TQT_DEBUG_COMPONENT) && TQT_DEBUG_COMPONENT == 2
+    qWarning( "%s has been unloaded", (const char*) TQFile::encodeName(library()) );
+# endif
+    d->pHnd = 0;
+#endif
+    return TRUE;
+}
+
+/*!
+    Returns TRUE if the library will be automatically unloaded when
+    this wrapper object is destructed; otherwise returns FALSE. The
+    default is TRUE.
+
+    \sa setAutoUnload()
+*/
+bool TQLibrary::autoUnload() const
+{
+    return (bool)aunload;
+}
+
+/*!
+    If \a enabled is TRUE (the default), the wrapper object is set to
+    automatically unload the library upon destruction. If \a enabled
+    is FALSE, the wrapper object is not unloaded unless you explicitly
+    call unload().
+
+    \sa autoUnload()
+*/
+void TQLibrary::setAutoUnload( bool enabled )
+{
+    aunload = enabled;
+}
+
+/*!
+    Returns the filename of the shared library this TQLibrary object
+    handles, including the platform specific file extension.
+
+    For example:
+    \code
+    TQLibrary lib( "mylib" );
+    TQString str = lib.library();
+    \endcode
+    will set \e str to "mylib.dll" on Windows, and "libmylib.so" on Linux.
+*/
+TQString TQLibrary::library() const
+{
+    if ( libfile.isEmpty() )
+	return libfile;
+
+    TQString filename = libfile;
+
+#if defined(TQ_WS_WIN)
+    if ( filename.tqfindRev( '.' ) <= filename.tqfindRev( '/' ) )
+	filename += ".dll";
+#else
+    TQStringList filters = "";
+#ifdef TQ_OS_MACX
+    filters << ".so";
+    filters << ".bundle";
+    filters << ".dylib"; //the last one is also the default one..
+#elif defined(TQ_OS_HPUX)
+    filters << ".sl";
+#else
+    filters << ".so";
+#endif
+    for(TQStringList::Iterator it = filters.begin(); TRUE; ) {
+	TQString filter = (*it);
+	++it;
+
+	if(TQFile::exists(filename + filter)) {
+	    filename += filter;
+	    break;
+	} else if(!filter.isEmpty()) {
+	    TQString tmpfilename = filename;
+	    const int x = tmpfilename.tqfindRev( "/" );
+	    if ( x != -1 ) {
+		TQString path = tmpfilename.left( x + 1 );
+		TQString file = tmpfilename.right( tmpfilename.length() - x - 1 );
+		tmpfilename = TQString( "%1lib%2" ).arg( path ).arg( file );
+	    } else {
+		tmpfilename = TQString( "lib%1" ).arg( filename );
+	    }
+	    tmpfilename += filter;
+	    if(TQFile::exists(tmpfilename) || it == filters.end()) {
+		filename = tmpfilename;
+		break;
+	    }
+	}
+    }
+#endif
+    return filename;
+}
+#endif //TQT_NO_LIBRARY
diff --git a/tqtinterface/qt4/src/tools/tqlibrary.h b/tqtinterface/qt4/src/tools/tqlibrary.h
new file mode 100644
index 0000000..7d3f05a
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqlibrary.h
@@ -0,0 +1,86 @@
+/****************************************************************************
+**
+** Definition of TQLibrary class
+**
+** Created : 000101
+**
+** Copyright (C) 2000-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQLIBRARY_H
+#define TQLIBRARY_H
+
+#ifndef TQT_H
+#include "tqstring.h"
+#endif // TQT_H
+
+#ifndef TQT_NO_LIBRARY
+
+class TQLibraryPrivate;
+
+class TQ_EXPORT TQLibrary
+{
+public:
+    TQLibrary( const TQString& filename );
+    virtual ~TQLibrary();
+
+    void *resolve( const char* );
+    static void *resolve( const TQString &filename, const char * );
+
+    bool load();
+    virtual bool unload();
+    bool isLoaded() const;
+
+    bool autoUnload() const;
+    void setAutoUnload( bool enable );
+
+    TQString library() const;
+
+private:
+    TQLibraryPrivate *d;
+
+    TQString libfile;
+    uint aunload : 1;
+
+private:	// Disabled copy constructor and operator=
+#if defined(TQ_DISABLE_COPY)
+    TQLibrary( const TQLibrary & );
+    TQLibrary &operator=( const TQLibrary & );
+#endif
+};
+
+#define TQ_DEFINED_TQLIBRARY
+#include "tqwinexport.h"
+#endif //TQT_NO_LIBRARY
+#endif //TQLIBRARY_H
diff --git a/tqtinterface/qt4/src/tools/tqlibrary_p.h b/tqtinterface/qt4/src/tools/tqlibrary_p.h
new file mode 100644
index 0000000..dbd18a8
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqlibrary_p.h
@@ -0,0 +1,84 @@
+/****************************************************************************
+**
+** Definition of an internal TQLibrary class
+**
+** Created : 000101
+**
+** Copyright (C) 2000-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQLIBRARY_P_H
+#define TQLIBRARY_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the TQt API.  It exists for the convenience
+// of the TQLibrary class.  This header file may change from
+// version to version without notice, or even be removed.
+//
+// We mean it.
+//
+//
+
+#include "tqlibrary.h"
+
+#ifndef TQT_NO_LIBRARY
+
+#ifndef TQT_H
+#include "tqwindowdefs.h"
+#endif // TQT_H
+
+class TQLibraryPrivate
+{
+public:
+    TQLibraryPrivate( TQLibrary *lib );
+
+#ifdef TQ_WS_WIN
+    HINSTANCE pHnd;
+#else
+    void *pHnd;
+#endif
+
+    bool loadLibrary();
+    bool freeLibrary();
+    void *resolveSymbol( const char * );
+
+private:
+    TQLibrary *library;
+};
+
+#endif // TQT_NO_LIBRARY
+#endif // TQLIBRARY_P_H
diff --git a/tqtinterface/qt4/src/tools/tqlibrary_unix.cpp b/tqtinterface/qt4/src/tools/tqlibrary_unix.cpp
new file mode 100644
index 0000000..62c909c
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqlibrary_unix.cpp
@@ -0,0 +1,169 @@
+/****************************************************************************
+**
+** Implementation of TQLibraryPrivate class
+**
+** Created : 000101
+**
+** Copyright (C) 2000-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "tqplatformdefs.h"
+#include "private/tqlibrary_p.h"
+
+#ifndef TQT_NO_LIBRARY
+
+#if defined(TQT_AOUT_UNDERSCORE)
+#include <string.h>
+#endif
+
+/*
+  The platform dependent implementations of
+  - loadLibrary
+  - freeLibrary
+  - resolveSymbol
+
+  It's not too hard to guess what the functions do.
+*/
+
+#if defined(TQT_HPUX_LD) // for HP-UX < 11.x and 32 bit
+
+bool TQLibraryPrivate::loadLibrary()
+{
+    if ( pHnd )
+	return TRUE;
+
+    TQString filename = library->library();
+
+    pHnd = (void*)shl_load( filename.latin1(), BIND_DEFERRED | BIND_NONFATAL | DYNAMIC_PATH, 0 );
+#if defined(TQT_DEBUG) || defined(TQT_DEBUG_COMPONENT)
+    if ( !pHnd )
+	qWarning( "%s: failed to load library!", filename.latin1() );
+#endif
+    return pHnd != 0;
+}
+
+bool TQLibraryPrivate::freeLibrary()
+{
+    if ( !pHnd )
+	return TRUE;
+
+    if ( shl_unload( (shl_t)pHnd ) ) {
+#if defined(TQT_DEBUG) || defined(TQT_DEBUG_COMPONENT)
+	TQString filename = library->library();
+	qWarning( "%s: Failed to unload library!", filename.latin1() );
+#endif
+	return FALSE;
+    }
+    pHnd = 0;
+    return TRUE;
+}
+
+void* TQLibraryPrivate::resolveSymbol( const char* symbol )
+{
+    if ( !pHnd )
+	return 0;
+
+    void* address = 0;
+    if ( shl_tqfindsym( (shl_t*)&pHnd, symbol, TYPE_UNDEFINED, &address ) < 0 ) {
+#if defined(TQT_DEBUG_COMPONENT)
+	TQString filename = library->library();
+	qWarning( "%s: couldn't resolve symbol \"%s\"", filename.latin1(), symbol );
+#endif
+    }
+    return address;
+}
+
+#else // POSIX
+#include <dlfcn.h>
+#ifndef DL_PREFIX //for mac dlcompat
+#  define DL_PREFIX(x) x
+#endif
+
+bool TQLibraryPrivate::loadLibrary()
+{
+    if ( pHnd )
+	return TRUE;
+
+    TQString filename = library->library();
+
+    pHnd = DL_PREFIX(dlopen)( filename.latin1(), RTLD_LAZY );
+#if defined(TQT_DEBUG) || defined(TQT_DEBUG_COMPONENT)
+    if ( !pHnd )
+	qWarning( "%s", DL_PREFIX(dlerror)() );
+#endif
+    return pHnd != 0;
+}
+
+bool TQLibraryPrivate::freeLibrary()
+{
+    if ( !pHnd )
+	return TRUE;
+
+    if ( DL_PREFIX(dlclose)( pHnd ) ) {
+#if defined(TQT_DEBUG) || defined(TQT_DEBUG_COMPONENT)
+	qWarning( "%s", DL_PREFIX(dlerror)() );
+#endif
+	return FALSE;
+    }
+
+    pHnd = 0;
+    return TRUE;
+}
+
+void* TQLibraryPrivate::resolveSymbol( const char* symbol )
+{
+    if ( !pHnd )
+	return 0;
+
+#if defined(TQT_AOUT_UNDERSCORE)
+    // older a.out systems add an underscore in front of symbols
+    char* undrscr_symbol = new char[strlen(symbol)+2];
+    undrscr_symbol[0] = '_';
+    strcpy(undrscr_symbol+1, symbol);
+    void* address = DL_PREFIX(dlsym)( pHnd, undrscr_symbol );
+    delete [] undrscr_symbol;
+#else
+    void* address = DL_PREFIX(dlsym)( pHnd, symbol );
+#endif
+#if defined(TQT_DEBUG_COMPONENT)
+    const char* error = DL_PREFIX(dlerror)();
+    if ( error )
+	qWarning( "%s", error );
+#endif
+    return address;
+}
+
+#endif // POSIX
+
+#endif
diff --git a/tqtinterface/qt4/src/tools/tqlocale.cpp b/tqtinterface/qt4/src/tools/tqlocale.cpp
new file mode 100644
index 0000000..26a3230
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqlocale.cpp
@@ -0,0 +1,6311 @@
+/****************************************************************************
+**
+** Implementation of the TQLocale class
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include <sys/types.h>
+#include <ctype.h>
+#include <float.h>
+#include <limits.h>
+#include <math.h>
+#include <stdlib.h>
+
+#include "tqlocale.h"
+#include "tqlocale_p.h"
+#include "tqnamespace.h"
+
+#ifdef TQT_TQLOCALE_USES_FCVT
+# include <tqmutex.h>
+# include <private/tqmutexpool_p.h>
+#endif
+
+#if defined (TQ_OS_WIN)
+#   include <windows.h>
+#   undef NAN        // we want to use our fallback on Windows
+#   undef INFINITY
+#endif
+
+#ifdef TQ_OS_LINUX
+#    include <fenv.h>
+#endif
+
+#if !defined( TQWS ) && defined( TQ_OS_MAC )
+#   include <Carbon/Carbon.h>
+#endif
+
+#if defined (TQ_OS_SOLARIS)
+#   include <ieeefp.h>
+#endif
+
+#if defined (TQ_OS_OSF) && (defined(__DECC) || defined(__DECCXX))
+#   define INFINITY DBL_INFINITY
+#   define NAN DBL_TQNAN
+#endif
+
+#if (defined(TQ_CC_GNU) && defined(TQ_OS_WIN)) || __GNUC__ == 4 || defined(TQT_TQLOCALE_NEEDS_VOLATILE)
+#   define NEEDS_VOLATILE volatile
+#else
+#   define NEEDS_VOLATILE
+#endif
+
+enum {
+    LittleEndian,
+    BigEndian
+
+#ifdef TQ_BYTE_ORDER
+#  if TQ_BYTE_ORDER == TQ_BIG_ENDIAN
+    , ByteOrder = BigEndian
+#  elif TQ_BYTE_ORDER == TQ_LITTLE_ENDIAN
+    , ByteOrder = LittleEndian
+#  else
+#    error "undefined byte order"
+#  endif
+};
+#else
+};
+static const unsigned int one = 1;
+static const bool ByteOrder = ((*((unsigned char *) &one) == 0) ? BigEndian : LittleEndian);
+#endif
+
+#if !defined(INFINITY)
+static const unsigned char be_inf_bytes[] = { 0x7f, 0xf0, 0, 0, 0, 0, 0, 0 };
+static const unsigned char le_inf_bytes[] = { 0, 0, 0, 0, 0, 0, 0xf0, 0x7f };
+static inline double inf()
+{
+    return (ByteOrder == BigEndian ?
+            *((const double *) be_inf_bytes) :
+            *((const double *) le_inf_bytes));
+}
+#   define INFINITY (::inf())
+#endif
+
+#if !defined(NAN)
+static const unsigned char be_nan_bytes[] = { 0x7f, 0xf8, 0, 0, 0, 0, 0, 0 };
+static const unsigned char le_nan_bytes[] = { 0, 0, 0, 0, 0, 0, 0xf8, 0x7f };
+static inline double nan()
+{
+    return (ByteOrder == BigEndian ?
+            *((const double *) be_nan_bytes) :
+            *((const double *) le_nan_bytes));
+}
+#   define NAN (::nan())
+#endif
+
+// We can't rely on -NAN, since all operations on a NAN should return a NAN.
+static const unsigned char be_neg_nan_bytes[] = { 0xff, 0xf8, 0, 0, 0, 0, 0, 0 };
+static const unsigned char le_neg_nan_bytes[] = { 0, 0, 0, 0, 0, 0, 0xf8, 0xff };
+static inline double negNan()
+{
+    return (ByteOrder == BigEndian ?
+            *((const double *) be_neg_nan_bytes) :
+            *((const double *) le_neg_nan_bytes));
+}
+
+// Sizes as defined by the ISO C99 standard - fallback
+#ifndef LLONG_MAX
+#   define LLONG_MAX TQ_INT64_C(9223372036854775807)
+#endif
+#ifndef LLONG_MIN
+#   define LLONG_MIN (-LLONG_MAX - TQ_INT64_C(1))
+#endif
+#ifndef ULLONG_MAX
+#   define ULLONG_MAX TQ_UINT64_C(0xffffffffffffffff)
+#endif
+
+#ifndef TQT_TQLOCALE_USES_FCVT
+static char *qdtoa(double d, int mode, int ndigits, int *decpt,
+                        int *sign, char **rve, char **digits_str);
+static char *_qdtoa(double d, int mode, int ndigits, int *decpt,
+                        int *sign, char **rve, char **digits_str);
+static double qstrtod(const char *s00, char const **se, bool *ok);
+#endif
+static TQ_LLONG qstrtoll(const char *nptr, const char **endptr, register int base, bool *ok);
+static TQ_ULLONG qstrtoull(const char *nptr, const char **endptr, register int base, bool *ok);
+
+static inline bool compareBits(double d1, double d2)
+{
+    return memcmp((const char*)&d1, (const char*)&d2, sizeof(double)) == 0;
+}
+
+static inline bool qIsInf(double d)
+{
+    return compareBits(d, INFINITY) || compareBits(d, -INFINITY);
+}
+
+static inline bool qIsNan(double d)
+{
+    return compareBits(d, NAN) || compareBits(d, negNan());
+}
+
+static const uint locale_index[] = {
+     0, // unused
+     0, // C
+     0, // Abkhazian
+     0, // Afan
+     0, // Afar
+     1, // Afrikaans
+     2, // Albanian
+     0, // Amharic
+     3, // Arabic
+    19, // Armenian
+     0, // Assamese
+     0, // Aymara
+    20, // Azerbaijani
+     0, // Bashkir
+    21, // Basque
+    22, // Bengali
+     0, // Bhutani
+     0, // Bihari
+     0, // Bislama
+     0, // Breton
+    23, // Bulgarian
+     0, // Burmese
+    24, // Byelorussian
+     0, // Cambodian
+    25, // Catalan
+    26, // Chinese
+     0, // Corsican
+    31, // Croatian
+    32, // Czech
+    33, // Danish
+    34, // Dutch
+    36, // English
+     0, // Esperanto
+    48, // Estonian
+    49, // Faroese
+     0, // Fiji
+    50, // Finnish
+    51, // French
+     0, // Frisian
+     0, // Gaelic
+    57, // Galician
+    58, // Georgian
+    59, // German
+    64, // Greek
+     0, // Greenlandic
+     0, // Guarani
+    65, // Gujarati
+     0, // Hausa
+    66, // Hebrew
+    67, // Hindi
+    68, // Hungarian
+    69, // Icelandic
+    70, // Indonesian
+     0, // Interlingua
+     0, // Interlingue
+     0, // Inuktitut
+     0, // Inupiak
+     0, // Irish
+    71, // Italian
+    73, // Japanese
+     0, // Javanese
+    74, // Kannada
+     0, // Kashmiri
+    75, // Kazakh
+     0, // Kinyarwanda
+    76, // Kirghiz
+    77, // Korean
+     0, // Kurdish
+     0, // Kurundi
+     0, // Laothian
+     0, // Latin
+    78, // Latvian
+     0, // Lingala
+    79, // Lithuanian
+    80, // Macedonian
+     0, // Malagasy
+    81, // Malay
+     0, // Malayalam
+     0, // Maltese
+     0, // Maori
+    83, // Marathi
+     0, // Moldavian
+    84, // Mongolian
+     0, // Nauru
+     0, // Nepali
+    85, // Norwegian
+     0, // Occitan
+     0, // Oriya
+     0, // Pashto
+    86, // Persian
+    87, // Polish
+    88, // Portuguese
+    90, // Punjabi
+     0, // Quechua
+     0, // RhaetoRomance
+    91, // Romanian
+    92, // Russian
+     0, // Samoan
+     0, // Sangho
+    93, // Sanskrit
+     0, // Serbian
+     0, // SerboCroatian
+     0, // Sesotho
+     0, // Setswana
+     0, // Shona
+     0, // Sindhi
+     0, // Singhalese
+     0, // Siswati
+    94, // Slovak
+    95, // Slovenian
+     0, // Somali
+    96, // Spanish
+     0, // Sundanese
+   115, // Swahili
+   116, // Swedish
+     0, // Tagalog
+     0, // Tajik
+   118, // Tamil
+     0, // Tatar
+   119, // Telugu
+   120, // Thai
+     0, // Tibetan
+     0, // Tigrinya
+     0, // Tonga
+     0, // Tsonga
+   121, // Turkish
+     0, // Turkmen
+     0, // Twi
+     0, // Uigur
+   122, // Ukrainian
+   123, // Urdu
+   124, // Uzbek
+   125, // Vietnamese
+     0, // Volapuk
+     0, // Welsh
+     0, // Wolof
+     0, // Xhosa
+     0, // Yiddish
+     0, // Yoruba
+     0, // Zhuang
+     0, // Zulu
+     0  // trailing 0
+};
+
+static const TQLocalePrivate locale_data[] = {
+//      lang   terr    dec  group   list  prcnt   zero  minus    exp
+    {      1,     0,    46,    44,    59,    37,    48,    45,   101 }, // C/AnyCountry
+    {      5,   195,    46,    44,    44,    37,    48,    45,    101 }, // Afrikaans/SouthAfrica
+    {      6,     2,    44,    46,    59,    37,    48,    45,    101 }, // Albanian/Albania
+    {      8,   186,    46,    44,    59,    37,  1632,    45,    101 }, // Arabic/SaudiArabia
+    {      8,     3,    46,    44,    59,    37,    48,    45,    101 }, // Arabic/Algeria
+    {      8,    17,    46,    44,    59,    37,  1632,    45,    101 }, // Arabic/Bahrain
+    {      8,    64,    46,    44,    59,    37,  1632,    45,    101 }, // Arabic/Egypt
+    {      8,   103,    46,    44,    59,    37,  1632,    45,    101 }, // Arabic/Iraq
+    {      8,   109,    46,    44,    59,    37,  1632,    45,    101 }, // Arabic/Jordan
+    {      8,   115,    46,    44,    59,    37,  1632,    45,    101 }, // Arabic/Kuwait
+    {      8,   119,    46,    44,    59,    37,  1632,    45,    101 }, // Arabic/Lebanon
+    {      8,   122,    46,    44,    59,    37,    48,    45,    101 }, // Arabic/LibyanArabJamahiriya
+    {      8,   145,    46,    44,    59,    37,    48,    45,    101 }, // Arabic/Morocco
+    {      8,   162,    46,    44,    59,    37,  1632,    45,    101 }, // Arabic/Oman
+    {      8,   175,    46,    44,    59,    37,  1632,    45,    101 }, // Arabic/Qatar
+    {      8,   207,    46,    44,    59,    37,  1632,    45,    101 }, // Arabic/SyrianArabRepublic
+    {      8,   216,    46,    44,    59,    37,    48,    45,    101 }, // Arabic/Tunisia
+    {      8,   223,    46,    44,    59,    37,  1632,    45,    101 }, // Arabic/UnitedArabEmirates
+    {      8,   237,    46,    44,    59,    37,  1632,    45,    101 }, // Arabic/Yemen
+    {      9,    11,    46,    44,    44,    37,    48,    45,    101 }, // Armenian/Armenia
+    {     12,    15,    44,   160,    59,    37,    48,    45,    101 }, // Azerbaijani/Azerbaijan
+    {     14,   197,    44,    46,    59,    37,    48,    45,    101 }, // Basque/Spain
+    {     15,   100,    46,    44,    59,    37,    48,    45,    101 }, // Bengali/India
+    {     20,    33,    44,   160,    59,    37,    48,    45,    101 }, // Bulgarian/Bulgaria
+    {     22,    20,    44,   160,    59,    37,    48,    45,    101 }, // Byelorussian/Belarus
+    {     24,   197,    44,    46,    59,    37,    48,    45,    101 }, // Catalan/Spain
+    {     25,    44,    46,    44,    44,    37,    48,    45,    101 }, // Chinese/China
+    {     25,    97,    46,    44,    44,    37,    48,    45,    101 }, // Chinese/HongKong
+    {     25,   126,    46,    44,    44,    37,    48,    45,    101 }, // Chinese/Macau
+    {     25,   190,    46,    44,    44,    37,    48,    45,    101 }, // Chinese/Singapore
+    {     25,   208,    46,    44,    44,    37,    48,    45,    101 }, // Chinese/Taiwan
+    {     27,    54,    44,    46,    59,    37,    48,    45,    101 }, // Croatian/Croatia
+    {     28,    57,    44,   160,    59,    37,    48,    45,    101 }, // Czech/CzechRepublic
+    {     29,    58,    44,    46,    59,    37,    48,    45,    101 }, // Danish/Denmark
+    {     30,   151,    44,    46,    59,    37,    48,    45,    101 }, // Dutch/Netherlands
+    {     30,    21,    44,    46,    59,    37,    48,    45,    101 }, // Dutch/Belgium
+    {     31,   225,    46,    44,    44,    37,    48,    45,    101 }, // English/UnitedStates
+    {     31,    13,    46,    44,    44,    37,    48,    45,    101 }, // English/Australia
+    {     31,    22,    46,    44,    59,    37,    48,    45,    101 }, // English/Belize
+    {     31,    38,    46,    44,    44,    37,    48,    45,    101 }, // English/Canada
+    {     31,   104,    46,    44,    44,    37,    48,    45,    101 }, // English/Ireland
+    {     31,   107,    46,    44,    44,    37,    48,    45,    101 }, // English/Jamaica
+    {     31,   154,    46,    44,    44,    37,    48,    45,    101 }, // English/NewZealand
+    {     31,   170,    46,    44,    44,    37,    48,    45,    101 }, // English/Philippines
+    {     31,   195,    46,    44,    44,    37,    48,    45,    101 }, // English/SouthAfrica
+    {     31,   215,    46,    44,    59,    37,    48,    45,    101 }, // English/TrinidadAndTobago
+    {     31,   224,    46,    44,    44,    37,    48,    45,    101 }, // English/UnitedKingdom
+    {     31,   240,    46,    44,    44,    37,    48,    45,    101 }, // English/Zimbabwe
+    {     33,    68,    44,   160,    59,    37,    48,    45,    101 }, // Estonian/Estonia
+    {     34,    71,    44,    46,    59,    37,    48,    45,    101 }, // Faroese/FaroeIslands
+    {     36,    73,    44,   160,    59,    37,    48,    45,    101 }, // Finnish/Finland
+    {     37,    74,    44,   160,    59,    37,    48,    45,    101 }, // French/France
+    {     37,    21,    44,    46,    59,    37,    48,    45,    101 }, // French/Belgium
+    {     37,    38,    44,   160,    59,    37,    48,    45,    101 }, // French/Canada
+    {     37,   125,    44,   160,    59,    37,    48,    45,    101 }, // French/Luxembourg
+    {     37,   142,    44,   160,    59,    37,    48,    45,    101 }, // French/Monaco
+    {     37,   206,    46,    39,    59,    37,    48,    45,    101 }, // French/Switzerland
+    {     40,   197,    44,    46,    44,    37,    48,    45,    101 }, // Galician/Spain
+    {     41,    81,    44,   160,    59,    37,    48,    45,    101 }, // Georgian/Georgia
+    {     42,    82,    44,    46,    59,    37,    48,    45,    101 }, // German/Germany
+    {     42,    14,    44,    46,    59,    37,    48,    45,    101 }, // German/Austria
+    {     42,   123,    46,    39,    59,    37,    48,    45,    101 }, // German/Liechtenstein
+    {     42,   125,    44,    46,    59,    37,    48,    45,    101 }, // German/Luxembourg
+    {     42,   206,    46,    39,    59,    37,    48,    45,    101 }, // German/Switzerland
+    {     43,    85,    44,    46,    59,    37,    48,    45,    101 }, // Greek/Greece
+    {     46,   100,    46,    44,    44,    37,  2790,    45,    101 }, // Gujarati/India
+    {     48,   105,    46,    44,    44,    37,    48,    45,    101 }, // Hebrew/Israel
+    {     49,   100,    46,    44,    44,    37,    48,    45,    101 }, // Hindi/India
+    {     50,    98,    44,   160,    59,    37,    48,    45,    101 }, // Hungarian/Hungary
+    {     51,    99,    44,    46,    59,    37,    48,    45,    101 }, // Icelandic/Iceland
+    {     52,   101,    44,    46,    59,    37,    48,    45,    101 }, // Indonesian/Indonesia
+    {     58,   106,    44,    46,    59,    37,    48,    45,    101 }, // Italian/Italy
+    {     58,   206,    46,    39,    59,    37,    48,    45,    101 }, // Italian/Switzerland
+    {     59,   108,    46,    44,    44,    37,    48,    45,    101 }, // Japanese/Japan
+    {     61,   100,    46,    44,    44,    37,  3302,    45,    101 }, // Kannada/India
+    {     63,   110,    44,   160,    59,    37,    48,    45,    101 }, // Kazakh/Kazakhstan
+    {     65,   116,    44,   160,    59,    37,    48,    45,    101 }, // Kirghiz/Kyrgyzstan
+    {     66,   114,    46,    44,    44,    37,    48,    45,    101 }, // Korean/RepublicOfKorea
+    {     71,   118,    44,   160,    59,    37,    48,    45,    101 }, // Latvian/Latvia
+    {     73,   124,    44,    46,    59,    37,    48,    45,    101 }, // Lithuanian/Lithuania
+    {     74,   127,    44,    46,    59,    37,    48,    45,    101 }, // Macedonian/Macedonia
+    {     76,   130,    44,    46,    59,    37,    48,    45,    101 }, // Malay/Malaysia
+    {     76,    32,    44,    46,    59,    37,    48,    45,    101 }, // Malay/BruneiDarussalam
+    {     80,   100,    46,    44,    44,    37,  2406,    45,    101 }, // Marathi/India
+    {     82,   143,    44,   160,    59,    37,    48,    45,    101 }, // Mongolian/Mongolia
+    {     85,   161,    44,   160,    59,    37,    48,    45,    101 }, // Norwegian/Norway
+    {     89,   102,    46,    44,    59,    37,  1776,    45,    101 }, // Persian/Iran
+    {     90,   172,    44,   160,    59,    37,    48,    45,    101 }, // Polish/Poland
+    {     91,   173,    44,    46,    59,    37,    48,    45,    101 }, // Portuguese/Portugal
+    {     91,    30,    44,    46,    59,    37,    48,    45,    101 }, // Portuguese/Brazil
+    {     92,   100,    46,    44,    44,    37,  2662,    45,    101 }, // Punjabi/India
+    {     95,   177,    44,    46,    59,    37,    48,    45,    101 }, // Romanian/Romania
+    {     96,   178,    44,   160,    59,    37,    48,    45,    101 }, // Russian/RussianFederation
+    {     99,   100,    46,    44,    44,    37,  2406,    45,    101 }, // Sanskrit/India
+    {    108,   191,    44,   160,    59,    37,    48,    45,    101 }, // Slovak/Slovakia
+    {    109,   192,    44,    46,    59,    37,    48,    45,    101 }, // Slovenian/Slovenia
+    {    111,   197,    44,    46,    59,    37,    48,    45,    101 }, // Spanish/Spain
+    {    111,    10,    44,    46,    44,    37,    48,    45,    101 }, // Spanish/Argentina
+    {    111,    26,    44,    46,    44,    37,    48,    45,    101 }, // Spanish/Bolivia
+    {    111,    43,    44,    46,    44,    37,    48,    45,    101 }, // Spanish/Chile
+    {    111,    47,    44,    46,    44,    37,    48,    45,    101 }, // Spanish/Colombia
+    {    111,    52,    44,    46,    44,    37,    48,    45,    101 }, // Spanish/CostaRica
+    {    111,    61,    46,    44,    44,    37,    48,    45,    101 }, // Spanish/DominicanRepublic
+    {    111,    63,    44,    46,    44,    37,    48,    45,    101 }, // Spanish/Ecuador
+    {    111,    65,    46,    44,    44,    37,    48,    45,    101 }, // Spanish/ElSalvador
+    {    111,    90,    46,    44,    44,    37,    48,    45,    101 }, // Spanish/Guatemala
+    {    111,    96,    46,    44,    44,    37,    48,    45,    101 }, // Spanish/Honduras
+    {    111,   139,    46,    44,    44,    37,    48,    45,    101 }, // Spanish/Mexico
+    {    111,   155,    46,    44,    44,    37,    48,    45,    101 }, // Spanish/Nicaragua
+    {    111,   166,    46,    44,    44,    37,    48,    45,    101 }, // Spanish/Panama
+    {    111,   168,    44,    46,    44,    37,    48,    45,    101 }, // Spanish/Paraguay
+    {    111,   169,    46,    44,    44,    37,    48,    45,    101 }, // Spanish/Peru
+    {    111,   174,    46,    44,    44,    37,    48,    45,    101 }, // Spanish/PuertoRico
+    {    111,   227,    44,    46,    44,    37,    48,    45,    101 }, // Spanish/Uruguay
+    {    111,   231,    44,    46,    44,    37,    48,    45,    101 }, // Spanish/Venezuela
+    {    113,   111,    46,    44,    44,    37,    48,    45,    101 }, // Swahili/Kenya
+    {    114,   205,    44,   160,    59,    37,    48,    45,    101 }, // Swedish/Sweden
+    {    114,    73,    44,   160,    59,    37,    48,    45,    101 }, // Swedish/Finland
+    {    117,   100,    46,    44,    44,    37,    48,    45,    101 }, // Tamil/India
+    {    119,   100,    46,    44,    44,    37,  3174,    45,    101 }, // Telugu/India
+    {    120,   211,    46,    44,    44,    37,  3664,    45,    101 }, // Thai/Thailand
+    {    125,   217,    44,    46,    59,    37,    48,    45,    101 }, // Turkish/Turkey
+    {    129,   222,    44,   160,    59,    37,    48,    45,    101 }, // Ukrainian/Ukraine
+    {    130,   163,    46,    44,    59,    37,  1776,    45,    101 }, // Urdu/Pakistan
+    {    131,   228,    44,   160,    59,    37,    48,    45,    101 }, // Uzbek/Uzbekistan
+    {    132,   232,    44,    46,    44,    37,    48,    45,    101 }, // Vietnamese/VietNam
+    {      0,     0,     0,     0,     0,     0,     0,     0,     0 }  // trailing 0s
+};
+
+static const char language_name_list[] =
+"Default\0"
+"C\0"
+"Abkhazian\0"
+"Afan\0"
+"Afar\0"
+"Afrikaans\0"
+"Albanian\0"
+"Amharic\0"
+"Arabic\0"
+"Armenian\0"
+"Assamese\0"
+"Aymara\0"
+"Azerbaijani\0"
+"Bashkir\0"
+"Basque\0"
+"Bengali\0"
+"Bhutani\0"
+"Bihari\0"
+"Bislama\0"
+"Breton\0"
+"Bulgarian\0"
+"Burmese\0"
+"Byelorussian\0"
+"Cambodian\0"
+"Catalan\0"
+"Chinese\0"
+"Corsican\0"
+"Croatian\0"
+"Czech\0"
+"Danish\0"
+"Dutch\0"
+"English\0"
+"Esperanto\0"
+"Estonian\0"
+"Faroese\0"
+"Fiji\0"
+"Finnish\0"
+"French\0"
+"Frisian\0"
+"Gaelic\0"
+"Galician\0"
+"Georgian\0"
+"German\0"
+"Greek\0"
+"Greenlandic\0"
+"Guarani\0"
+"Gujarati\0"
+"Hausa\0"
+"Hebrew\0"
+"Hindi\0"
+"Hungarian\0"
+"Icelandic\0"
+"Indonesian\0"
+"Interlingua\0"
+"Interlingue\0"
+"Inuktitut\0"
+"Inupiak\0"
+"Irish\0"
+"Italian\0"
+"Japanese\0"
+"Javanese\0"
+"Kannada\0"
+"Kashmiri\0"
+"Kazakh\0"
+"Kinyarwanda\0"
+"Kirghiz\0"
+"Korean\0"
+"Kurdish\0"
+"Kurundi\0"
+"Laothian\0"
+"Latin\0"
+"Latvian\0"
+"Lingala\0"
+"Lithuanian\0"
+"Macedonian\0"
+"Malagasy\0"
+"Malay\0"
+"Malayalam\0"
+"Maltese\0"
+"Maori\0"
+"Marathi\0"
+"Moldavian\0"
+"Mongolian\0"
+"Nauru\0"
+"Nepali\0"
+"Norwegian\0"
+"Occitan\0"
+"Oriya\0"
+"Pashto\0"
+"Persian\0"
+"Polish\0"
+"Portuguese\0"
+"Punjabi\0"
+"Quechua\0"
+"RhaetoRomance\0"
+"Romanian\0"
+"Russian\0"
+"Samoan\0"
+"Sangho\0"
+"Sanskrit\0"
+"Serbian\0"
+"SerboCroatian\0"
+"Sesotho\0"
+"Setswana\0"
+"Shona\0"
+"Sindhi\0"
+"Singhalese\0"
+"Siswati\0"
+"Slovak\0"
+"Slovenian\0"
+"Somali\0"
+"Spanish\0"
+"Sundanese\0"
+"Swahili\0"
+"Swedish\0"
+"Tagalog\0"
+"Tajik\0"
+"Tamil\0"
+"Tatar\0"
+"Telugu\0"
+"Thai\0"
+"Tibetan\0"
+"Tigrinya\0"
+"Tonga\0"
+"Tsonga\0"
+"Turkish\0"
+"Turkmen\0"
+"Twi\0"
+"Uigur\0"
+"Ukrainian\0"
+"Urdu\0"
+"Uzbek\0"
+"Vietnamese\0"
+"Volapuk\0"
+"Welsh\0"
+"Wolof\0"
+"Xhosa\0"
+"Yiddish\0"
+"Yoruba\0"
+"Zhuang\0"
+"Zulu\0";
+
+static const uint language_name_index[] = {
+     0,// Unused
+     8,// C
+    10,// Abkhazian
+    20,// Afan
+    25,// Afar
+    30,// Afrikaans
+    40,// Albanian
+    49,// Amharic
+    57,// Arabic
+    64,// Armenian
+    73,// Assamese
+    82,// Aymara
+    89,// Azerbaijani
+   101,// Bashkir
+   109,// Basque
+   116,// Bengali
+   124,// Bhutani
+   132,// Bihari
+   139,// Bislama
+   147,// Breton
+   154,// Bulgarian
+   164,// Burmese
+   172,// Byelorussian
+   185,// Cambodian
+   195,// Catalan
+   203,// Chinese
+   211,// Corsican
+   220,// Croatian
+   229,// Czech
+   235,// Danish
+   242,// Dutch
+   248,// English
+   256,// Esperanto
+   266,// Estonian
+   275,// Faroese
+   283,// Fiji
+   288,// Finnish
+   296,// French
+   303,// Frisian
+   311,// Gaelic
+   318,// Galician
+   327,// Georgian
+   336,// German
+   343,// Greek
+   349,// Greenlandic
+   361,// Guarani
+   369,// Gujarati
+   378,// Hausa
+   384,// Hebrew
+   391,// Hindi
+   397,// Hungarian
+   407,// Icelandic
+   417,// Indonesian
+   428,// Interlingua
+   440,// Interlingue
+   452,// Inuktitut
+   462,// Inupiak
+   470,// Irish
+   476,// Italian
+   484,// Japanese
+   493,// Javanese
+   502,// Kannada
+   510,// Kashmiri
+   519,// Kazakh
+   526,// Kinyarwanda
+   538,// Kirghiz
+   546,// Korean
+   553,// Kurdish
+   561,// Kurundi
+   569,// Laothian
+   578,// Latin
+   584,// Latvian
+   592,// Lingala
+   600,// Lithuanian
+   611,// Macedonian
+   622,// Malagasy
+   631,// Malay
+   637,// Malayalam
+   647,// Maltese
+   655,// Maori
+   661,// Marathi
+   669,// Moldavian
+   679,// Mongolian
+   689,// Nauru
+   695,// Nepali
+   702,// Norwegian
+   712,// Occitan
+   720,// Oriya
+   726,// Pashto
+   733,// Persian
+   741,// Polish
+   748,// Portuguese
+   759,// Punjabi
+   767,// Quechua
+   775,// RhaetoRomance
+   789,// Romanian
+   798,// Russian
+   806,// Samoan
+   813,// Sangho
+   820,// Sanskrit
+   829,// Serbian
+   837,// SerboCroatian
+   851,// Sesotho
+   859,// Setswana
+   868,// Shona
+   874,// Sindhi
+   881,// Singhalese
+   892,// Siswati
+   900,// Slovak
+   907,// Slovenian
+   917,// Somali
+   924,// Spanish
+   932,// Sundanese
+   942,// Swahili
+   950,// Swedish
+   958,// Tagalog
+   966,// Tajik
+   972,// Tamil
+   978,// Tatar
+   984,// Telugu
+   991,// Thai
+   996,// Tibetan
+  1004,// Tigrinya
+  1013,// Tonga
+  1019,// Tsonga
+  1026,// Turkish
+  1034,// Turkmen
+  1042,// Twi
+  1046,// Uigur
+  1052,// Ukrainian
+  1062,// Urdu
+  1067,// Uzbek
+  1073,// Vietnamese
+  1084,// Volapuk
+  1092,// Welsh
+  1098,// Wolof
+  1104,// Xhosa
+  1110,// Yiddish
+  1118,// Yoruba
+  1125,// Zhuang
+  1132// Zulu
+};
+
+static const char country_name_list[] =
+"Default\0"
+"Afghanistan\0"
+"Albania\0"
+"Algeria\0"
+"AmericanSamoa\0"
+"Andorra\0"
+"Angola\0"
+"Anguilla\0"
+"Antarctica\0"
+"AntiguaAndBarbuda\0"
+"Argentina\0"
+"Armenia\0"
+"Aruba\0"
+"Australia\0"
+"Austria\0"
+"Azerbaijan\0"
+"Bahamas\0"
+"Bahrain\0"
+"Bangladesh\0"
+"Barbados\0"
+"Belarus\0"
+"Belgium\0"
+"Belize\0"
+"Benin\0"
+"Bermuda\0"
+"Bhutan\0"
+"Bolivia\0"
+"BosniaAndHerzegowina\0"
+"Botswana\0"
+"BouvetIsland\0"
+"Brazil\0"
+"BritishIndianOceanTerritory\0"
+"BruneiDarussalam\0"
+"Bulgaria\0"
+"BurkinaFaso\0"
+"Burundi\0"
+"Cambodia\0"
+"Cameroon\0"
+"Canada\0"
+"CapeVerde\0"
+"CaymanIslands\0"
+"CentralAfricanRepublic\0"
+"Chad\0"
+"Chile\0"
+"China\0"
+"ChristmasIsland\0"
+"CocosIslands\0"
+"Colombia\0"
+"Comoros\0"
+"DetqmocraticRepublicOfCongo\0"
+"PeoplesRepublicOfCongo\0"
+"CookIslands\0"
+"CostaRica\0"
+"IvoryCoast\0"
+"Croatia\0"
+"Cuba\0"
+"Cyprus\0"
+"CzechRepublic\0"
+"Denmark\0"
+"Djibouti\0"
+"Dominica\0"
+"DominicanRepublic\0"
+"EastTimor\0"
+"Ecuador\0"
+"Egypt\0"
+"ElSalvador\0"
+"EquatorialGuinea\0"
+"Eritrea\0"
+"Estonia\0"
+"Ethiopia\0"
+"FalklandIslands\0"
+"FaroeIslands\0"
+"Fiji\0"
+"Finland\0"
+"France\0"
+"MetropolitanFrance\0"
+"FrenchGuiana\0"
+"FrenchPolynesia\0"
+"FrenchSouthernTerritories\0"
+"Gabon\0"
+"Gambia\0"
+"Georgia\0"
+"Germany\0"
+"Ghana\0"
+"Gibraltar\0"
+"Greece\0"
+"Greenland\0"
+"Grenada\0"
+"Guadeloupe\0"
+"Guam\0"
+"Guatemala\0"
+"Guinea\0"
+"GuineaBissau\0"
+"Guyana\0"
+"Haiti\0"
+"HeardAndMcDonaldIslands\0"
+"Honduras\0"
+"HongKong\0"
+"Hungary\0"
+"Iceland\0"
+"India\0"
+"Indonesia\0"
+"Iran\0"
+"Iraq\0"
+"Ireland\0"
+"Israel\0"
+"Italy\0"
+"Jamaica\0"
+"Japan\0"
+"Jordan\0"
+"Kazakhstan\0"
+"Kenya\0"
+"Kiribati\0"
+"DetqmocraticRepublicOfKorea\0"
+"RepublicOfKorea\0"
+"Kuwait\0"
+"Kyrgyzstan\0"
+"Lao\0"
+"Latvia\0"
+"Lebanon\0"
+"Lesotho\0"
+"Liberia\0"
+"LibyanArabJamahiriya\0"
+"Liechtenstein\0"
+"Lithuania\0"
+"Luxembourg\0"
+"Macau\0"
+"Macedonia\0"
+"Madagascar\0"
+"Malawi\0"
+"Malaysia\0"
+"Maldives\0"
+"Mali\0"
+"Malta\0"
+"MarshallIslands\0"
+"Martinique\0"
+"Mauritania\0"
+"Mauritius\0"
+"Mayotte\0"
+"Mexico\0"
+"Micronesia\0"
+"Moldova\0"
+"Monaco\0"
+"Mongolia\0"
+"Montserrat\0"
+"Morocco\0"
+"Mozambique\0"
+"Myanmar\0"
+"Namibia\0"
+"Nauru\0"
+"Nepal\0"
+"Netherlands\0"
+"NetherlandsAntilles\0"
+"NewCaledonia\0"
+"NewZealand\0"
+"Nicaragua\0"
+"Niger\0"
+"Nigeria\0"
+"Niue\0"
+"NorfolkIsland\0"
+"NorthernMarianaIslands\0"
+"Norway\0"
+"Oman\0"
+"Pakistan\0"
+"Palau\0"
+"PalestinianTerritory\0"
+"Panama\0"
+"PapuaNewGuinea\0"
+"Paraguay\0"
+"Peru\0"
+"Philippines\0"
+"Pitcairn\0"
+"Poland\0"
+"Portugal\0"
+"PuertoRico\0"
+"Qatar\0"
+"Reunion\0"
+"Romania\0"
+"RussianFederation\0"
+"Rwanda\0"
+"SaintKittsAndNevis\0"
+"StLucia\0"
+"StVincentAndTheGrenadines\0"
+"Samoa\0"
+"SanMarino\0"
+"SaoTomeAndPrincipe\0"
+"SaudiArabia\0"
+"Senegal\0"
+"Seychelles\0"
+"SierraLeone\0"
+"Singapore\0"
+"Slovakia\0"
+"Slovenia\0"
+"SolomonIslands\0"
+"Somalia\0"
+"SouthAfrica\0"
+"SouthGeorgiaAndTheSouthSandwichIslands\0"
+"Spain\0"
+"SriLanka\0"
+"StHelena\0"
+"StPierreAndMiquelon\0"
+"Sudan\0"
+"Suriname\0"
+"SvalbardAndJanMayenIslands\0"
+"Swaziland\0"
+"Sweden\0"
+"Switzerland\0"
+"SyrianArabRepublic\0"
+"Taiwan\0"
+"Tajikistan\0"
+"Tanzania\0"
+"Thailand\0"
+"Togo\0"
+"Tokelau\0"
+"Tonga\0"
+"TrinidadAndTobago\0"
+"Tunisia\0"
+"Turkey\0"
+"Turkmenistan\0"
+"TurksAndCaicosIslands\0"
+"Tuvalu\0"
+"Uganda\0"
+"Ukraine\0"
+"UnitedArabEmirates\0"
+"UnitedKingdom\0"
+"UnitedStates\0"
+"UnitedStatesMinorOutlyingIslands\0"
+"Uruguay\0"
+"Uzbekistan\0"
+"Vanuatu\0"
+"VaticanCityState\0"
+"Venezuela\0"
+"VietNam\0"
+"BritishVirginIslands\0"
+"USVirginIslands\0"
+"WallisAndFutunaIslands\0"
+"WesternSahara\0"
+"Yemen\0"
+"Yugoslavia\0"
+"Zambia\0"
+"Zimbabwe\0";
+
+static const uint country_name_index[] = {
+     0,// AnyCountry
+     8,// Afghanistan
+    20,// Albania
+    28,// Algeria
+    36,// AmericanSamoa
+    50,// Andorra
+    58,// Angola
+    65,// Anguilla
+    74,// Antarctica
+    85,// AntiguaAndBarbuda
+   103,// Argentina
+   113,// Armenia
+   121,// Aruba
+   127,// Australia
+   137,// Austria
+   145,// Azerbaijan
+   156,// Bahamas
+   164,// Bahrain
+   172,// Bangladesh
+   183,// Barbados
+   192,// Belarus
+   200,// Belgium
+   208,// Belize
+   215,// Benin
+   221,// Bermuda
+   229,// Bhutan
+   236,// Bolivia
+   244,// BosniaAndHerzegowina
+   265,// Botswana
+   274,// BouvetIsland
+   287,// Brazil
+   294,// BritishIndianOceanTerritory
+   322,// BruneiDarussalam
+   339,// Bulgaria
+   348,// BurkinaFaso
+   360,// Burundi
+   368,// Cambodia
+   377,// Cameroon
+   386,// Canada
+   393,// CapeVerde
+   403,// CaymanIslands
+   417,// CentralAfricanRepublic
+   440,// Chad
+   445,// Chile
+   451,// China
+   457,// ChristmasIsland
+   473,// CocosIslands
+   486,// Colombia
+   495,// Comoros
+   503,// DetqmocraticRepublicOfCongo
+   529,// PeoplesRepublicOfCongo
+   552,// CookIslands
+   564,// CostaRica
+   574,// IvoryCoast
+   585,// Croatia
+   593,// Cuba
+   598,// Cyprus
+   605,// CzechRepublic
+   619,// Denmark
+   627,// Djibouti
+   636,// Dominica
+   645,// DominicanRepublic
+   663,// EastTimor
+   673,// Ecuador
+   681,// Egypt
+   687,// ElSalvador
+   698,// EquatorialGuinea
+   715,// Eritrea
+   723,// Estonia
+   731,// Ethiopia
+   740,// FalklandIslands
+   756,// FaroeIslands
+   769,// Fiji
+   774,// Finland
+   782,// France
+   789,// MetropolitanFrance
+   808,// FrenchGuiana
+   821,// FrenchPolynesia
+   837,// FrenchSouthernTerritories
+   863,// Gabon
+   869,// Gambia
+   876,// Georgia
+   884,// Germany
+   892,// Ghana
+   898,// Gibraltar
+   908,// Greece
+   915,// Greenland
+   925,// Grenada
+   933,// Guadeloupe
+   944,// Guam
+   949,// Guatemala
+   959,// Guinea
+   966,// GuineaBissau
+   979,// Guyana
+   986,// Haiti
+   992,// HeardAndMcDonaldIslands
+  1016,// Honduras
+  1025,// HongKong
+  1034,// Hungary
+  1042,// Iceland
+  1050,// India
+  1056,// Indonesia
+  1066,// Iran
+  1071,// Iraq
+  1076,// Ireland
+  1084,// Israel
+  1091,// Italy
+  1097,// Jamaica
+  1105,// Japan
+  1111,// Jordan
+  1118,// Kazakhstan
+  1129,// Kenya
+  1135,// Kiribati
+  1144,// DetqmocraticRepublicOfKorea
+  1170,// RepublicOfKorea
+  1186,// Kuwait
+  1193,// Kyrgyzstan
+  1204,// Lao
+  1208,// Latvia
+  1215,// Lebanon
+  1223,// Lesotho
+  1231,// Liberia
+  1239,// LibyanArabJamahiriya
+  1260,// Liechtenstein
+  1274,// Lithuania
+  1284,// Luxembourg
+  1295,// Macau
+  1301,// Macedonia
+  1311,// Madagascar
+  1322,// Malawi
+  1329,// Malaysia
+  1338,// Maldives
+  1347,// Mali
+  1352,// Malta
+  1358,// MarshallIslands
+  1374,// Martinique
+  1385,// Mauritania
+  1396,// Mauritius
+  1406,// Mayotte
+  1414,// Mexico
+  1421,// Micronesia
+  1432,// Moldova
+  1440,// Monaco
+  1447,// Mongolia
+  1456,// Montserrat
+  1467,// Morocco
+  1475,// Mozambique
+  1486,// Myanmar
+  1494,// Namibia
+  1502,// Nauru
+  1508,// Nepal
+  1514,// Netherlands
+  1526,// NetherlandsAntilles
+  1546,// NewCaledonia
+  1559,// NewZealand
+  1570,// Nicaragua
+  1580,// Niger
+  1586,// Nigeria
+  1594,// Niue
+  1599,// NorfolkIsland
+  1613,// NorthernMarianaIslands
+  1636,// Norway
+  1643,// Oman
+  1648,// Pakistan
+  1657,// Palau
+  1663,// PalestinianTerritory
+  1684,// Panama
+  1691,// PapuaNewGuinea
+  1706,// Paraguay
+  1715,// Peru
+  1720,// Philippines
+  1732,// Pitcairn
+  1741,// Poland
+  1748,// Portugal
+  1757,// PuertoRico
+  1768,// Qatar
+  1774,// Reunion
+  1782,// Romania
+  1790,// RussianFederation
+  1808,// Rwanda
+  1815,// SaintKittsAndNevis
+  1834,// StLucia
+  1842,// StVincentAndTheGrenadines
+  1868,// Samoa
+  1874,// SanMarino
+  1884,// SaoTomeAndPrincipe
+  1903,// SaudiArabia
+  1915,// Senegal
+  1923,// Seychelles
+  1934,// SierraLeone
+  1946,// Singapore
+  1956,// Slovakia
+  1965,// Slovenia
+  1974,// SolomonIslands
+  1989,// Somalia
+  1997,// SouthAfrica
+  2009,// SouthGeorgiaAndTheSouthSandwichIslands
+  2048,// Spain
+  2054,// SriLanka
+  2063,// StHelena
+  2072,// StPierreAndMiquelon
+  2092,// Sudan
+  2098,// Suriname
+  2107,// SvalbardAndJanMayenIslands
+  2134,// Swaziland
+  2144,// Sweden
+  2151,// Switzerland
+  2163,// SyrianArabRepublic
+  2182,// Taiwan
+  2189,// Tajikistan
+  2200,// Tanzania
+  2209,// Thailand
+  2218,// Togo
+  2223,// Tokelau
+  2231,// Tonga
+  2237,// TrinidadAndTobago
+  2255,// Tunisia
+  2263,// Turkey
+  2270,// Turkmenistan
+  2283,// TurksAndCaicosIslands
+  2305,// Tuvalu
+  2312,// Uganda
+  2319,// Ukraine
+  2327,// UnitedArabEmirates
+  2346,// UnitedKingdom
+  2360,// UnitedStates
+  2373,// UnitedStatesMinorOutlyingIslands
+  2406,// Uruguay
+  2414,// Uzbekistan
+  2425,// Vanuatu
+  2433,// VaticanCityState
+  2450,// Venezuela
+  2460,// VietNam
+  2468,// BritishVirginIslands
+  2489,// USVirginIslands
+  2505,// WallisAndFutunaIslands
+  2528,// WesternSahara
+  2542,// Yemen
+  2548,// Yugoslavia
+  2559,// Zambia
+  2566// Zimbabwe
+};
+
+static const char language_code_list[] =
+"  " // Unused
+"  " // C
+"ab" // Abkhazian
+"om" // Afan
+"aa" // Afar
+"af" // Afrikaans
+"sq" // Albanian
+"am" // Amharic
+"ar" // Arabic
+"hy" // Armenian
+"as" // Assamese
+"ay" // Aymara
+"az" // Azerbaijani
+"ba" // Bashkir
+"eu" // Basque
+"bn" // Bengali
+"dz" // Bhutani
+"bh" // Bihari
+"bi" // Bislama
+"br" // Breton
+"bg" // Bulgarian
+"my" // Burmese
+"be" // Byelorussian
+"km" // Cambodian
+"ca" // Catalan
+"zh" // Chinese
+"co" // Corsican
+"hr" // Croatian
+"cs" // Czech
+"da" // Danish
+"nl" // Dutch
+"en" // English
+"eo" // Esperanto
+"et" // Estonian
+"fo" // Faroese
+"fj" // Fiji
+"fi" // Finnish
+"fr" // French
+"fy" // Frisian
+"gd" // Gaelic
+"gl" // Galician
+"ka" // Georgian
+"de" // German
+"el" // Greek
+"kl" // Greenlandic
+"gn" // Guarani
+"gu" // Gujarati
+"ha" // Hausa
+"he" // Hebrew
+"hi" // Hindi
+"hu" // Hungarian
+"is" // Icelandic
+"id" // Indonesian
+"ia" // Interlingua
+"ie" // Interlingue
+"iu" // Inuktitut
+"ik" // Inupiak
+"ga" // Irish
+"it" // Italian
+"ja" // Japanese
+"jv" // Javanese
+"kn" // Kannada
+"ks" // Kashmiri
+"kk" // Kazakh
+"rw" // Kinyarwanda
+"ky" // Kirghiz
+"ko" // Korean
+"ku" // Kurdish
+"rn" // Kurundi
+"lo" // Laothian
+"la" // Latin
+"lv" // Latvian
+"ln" // Lingala
+"lt" // Lithuanian
+"mk" // Macedonian
+"mg" // Malagasy
+"ms" // Malay
+"ml" // Malayalam
+"mt" // Maltese
+"mi" // Maori
+"mr" // Marathi
+"mo" // Moldavian
+"mn" // Mongolian
+"na" // Nauru
+"ne" // Nepali
+"no" // Norwegian
+"oc" // Occitan
+"or" // Oriya
+"ps" // Pashto
+"fa" // Persian
+"pl" // Polish
+"pt" // Portuguese
+"pa" // Punjabi
+"qu" // Quechua
+"rm" // RhaetoRomance
+"ro" // Romanian
+"ru" // Russian
+"sm" // Samoan
+"sg" // Sangho
+"sa" // Sanskrit
+"sr" // Serbian
+"sh" // SerboCroatian
+"st" // Sesotho
+"tn" // Setswana
+"sn" // Shona
+"sd" // Sindhi
+"si" // Singhalese
+"ss" // Siswati
+"sk" // Slovak
+"sl" // Slovenian
+"so" // Somali
+"es" // Spanish
+"su" // Sundanese
+"sw" // Swahili
+"sv" // Swedish
+"tl" // Tagalog
+"tg" // Tajik
+"ta" // Tamil
+"tt" // Tatar
+"te" // Telugu
+"th" // Thai
+"bo" // Tibetan
+"ti" // Tigrinya
+"to" // Tonga
+"ts" // Tsonga
+"tr" // Turkish
+"tk" // Turkmen
+"tw" // Twi
+"ug" // Uigur
+"uk" // Ukrainian
+"ur" // Urdu
+"uz" // Uzbek
+"vi" // Vietnamese
+"vo" // Volapuk
+"cy" // Welsh
+"wo" // Wolof
+"xh" // Xhosa
+"yi" // Yiddish
+"yo" // Yoruba
+"za" // Zhuang
+"zu" // Zulu
+;
+
+static const char country_code_list[] =
+"  " // AnyLanguage
+"AF" // Afghanistan
+"AL" // Albania
+"DZ" // Algeria
+"AS" // AmericanSamoa
+"AD" // Andorra
+"AO" // Angola
+"AI" // Anguilla
+"AQ" // Antarctica
+"AG" // AntiguaAndBarbuda
+"AR" // Argentina
+"AM" // Armenia
+"AW" // Aruba
+"AU" // Australia
+"AT" // Austria
+"AZ" // Azerbaijan
+"BS" // Bahamas
+"BH" // Bahrain
+"BD" // Bangladesh
+"BB" // Barbados
+"BY" // Belarus
+"BE" // Belgium
+"BZ" // Belize
+"BJ" // Benin
+"BM" // Bermuda
+"BT" // Bhutan
+"BO" // Bolivia
+"BA" // BosniaAndHerzegowina
+"BW" // Botswana
+"BV" // BouvetIsland
+"BR" // Brazil
+"IO" // BritishIndianOceanTerritory
+"BN" // BruneiDarussalam
+"BG" // Bulgaria
+"BF" // BurkinaFaso
+"BI" // Burundi
+"KH" // Cambodia
+"CM" // Cameroon
+"CA" // Canada
+"CV" // CapeVerde
+"KY" // CaymanIslands
+"CF" // CentralAfricanRepublic
+"TD" // Chad
+"CL" // Chile
+"CN" // China
+"CX" // ChristmasIsland
+"CC" // CocosIslands
+"CO" // Colombia
+"KM" // Comoros
+"CD" // DetqmocraticRepublicOfCongo
+"CG" // PeoplesRepublicOfCongo
+"CK" // CookIslands
+"CR" // CostaRica
+"CI" // IvoryCoast
+"HR" // Croatia
+"CU" // Cuba
+"CY" // Cyprus
+"CZ" // CzechRepublic
+"DK" // Denmark
+"DJ" // Djibouti
+"DM" // Dominica
+"DO" // DominicanRepublic
+"TL" // EastTimor
+"EC" // Ecuador
+"EG" // Egypt
+"SV" // ElSalvador
+"GQ" // EquatorialGuinea
+"ER" // Eritrea
+"EE" // Estonia
+"ET" // Ethiopia
+"FK" // FalklandIslands
+"FO" // FaroeIslands
+"FJ" // Fiji
+"FI" // Finland
+"FR" // France
+"FX" // MetropolitanFrance
+"GF" // FrenchGuiana
+"PF" // FrenchPolynesia
+"TF" // FrenchSouthernTerritories
+"GA" // Gabon
+"GM" // Gambia
+"GE" // Georgia
+"DE" // Germany
+"GH" // Ghana
+"GI" // Gibraltar
+"GR" // Greece
+"GL" // Greenland
+"GD" // Grenada
+"GP" // Guadeloupe
+"GU" // Guam
+"GT" // Guatemala
+"GN" // Guinea
+"GW" // GuineaBissau
+"GY" // Guyana
+"HT" // Haiti
+"HM" // HeardAndMcDonaldIslands
+"HN" // Honduras
+"HK" // HongKong
+"HU" // Hungary
+"IS" // Iceland
+"IN" // India
+"ID" // Indonesia
+"IR" // Iran
+"IQ" // Iraq
+"IE" // Ireland
+"IL" // Israel
+"IT" // Italy
+"JM" // Jamaica
+"JP" // Japan
+"JO" // Jordan
+"KZ" // Kazakhstan
+"KE" // Kenya
+"KI" // Kiribati
+"KP" // DetqmocraticRepublicOfKorea
+"KR" // RepublicOfKorea
+"KW" // Kuwait
+"KG" // Kyrgyzstan
+"LA" // Lao
+"LV" // Latvia
+"LB" // Lebanon
+"LS" // Lesotho
+"LR" // Liberia
+"LY" // LibyanArabJamahiriya
+"LI" // Liechtenstein
+"LT" // Lithuania
+"LU" // Luxembourg
+"MO" // Macau
+"MK" // Macedonia
+"MG" // Madagascar
+"MW" // Malawi
+"MY" // Malaysia
+"MV" // Maldives
+"ML" // Mali
+"MT" // Malta
+"MH" // MarshallIslands
+"MQ" // Martinique
+"MR" // Mauritania
+"MU" // Mauritius
+"YT" // Mayotte
+"MX" // Mexico
+"FM" // Micronesia
+"MD" // Moldova
+"MC" // Monaco
+"MN" // Mongolia
+"MS" // Montserrat
+"MA" // Morocco
+"MZ" // Mozambique
+"MM" // Myanmar
+"NA" // Namibia
+"NR" // Nauru
+"NP" // Nepal
+"NL" // Netherlands
+"AN" // NetherlandsAntilles
+"NC" // NewCaledonia
+"NZ" // NewZealand
+"NI" // Nicaragua
+"NE" // Niger
+"NG" // Nigeria
+"NU" // Niue
+"NF" // NorfolkIsland
+"MP" // NorthernMarianaIslands
+"NO" // Norway
+"OM" // Oman
+"PK" // Pakistan
+"PW" // Palau
+"PS" // PalestinianTerritory
+"PA" // Panama
+"PG" // PapuaNewGuinea
+"PY" // Paraguay
+"PE" // Peru
+"PH" // Philippines
+"PN" // Pitcairn
+"PL" // Poland
+"PT" // Portugal
+"PR" // PuertoRico
+"QA" // Qatar
+"RE" // Reunion
+"RO" // Romania
+"RU" // RussianFederation
+"RW" // Rwanda
+"KN" // SaintKittsAndNevis
+"LC" // StLucia
+"VC" // StVincentAndTheGrenadines
+"WS" // Samoa
+"SM" // SanMarino
+"ST" // SaoTomeAndPrincipe
+"SA" // SaudiArabia
+"SN" // Senegal
+"SC" // Seychelles
+"SL" // SierraLeone
+"SG" // Singapore
+"SK" // Slovakia
+"SI" // Slovenia
+"SB" // SolomonIslands
+"SO" // Somalia
+"ZA" // SouthAfrica
+"GS" // SouthGeorgiaAndTheSouthSandwichIslands
+"ES" // Spain
+"LK" // SriLanka
+"SH" // StHelena
+"PM" // StPierreAndMiquelon
+"SD" // Sudan
+"SR" // Suriname
+"SJ" // SvalbardAndJanMayenIslands
+"SZ" // Swaziland
+"SE" // Sweden
+"CH" // Switzerland
+"SY" // SyrianArabRepublic
+"TW" // Taiwan
+"TJ" // Tajikistan
+"TZ" // Tanzania
+"TH" // Thailand
+"TG" // Togo
+"TK" // Tokelau
+"TO" // Tonga
+"TT" // TrinidadAndTobago
+"TN" // Tunisia
+"TR" // Turkey
+"TM" // Turkmenistan
+"TC" // TurksAndCaicosIslands
+"TV" // Tuvalu
+"UG" // Uganda
+"UA" // Ukraine
+"AE" // UnitedArabEmirates
+"GB" // UnitedKingdom
+"US" // UnitedStates
+"UM" // UnitedStatesMinorOutlyingIslands
+"UY" // Uruguay
+"UZ" // Uzbekistan
+"VU" // Vanuatu
+"VA" // VaticanCityState
+"VE" // Venezuela
+"VN" // VietNam
+"VG" // BritishVirginIslands
+"VI" // USVirginIslands
+"WF" // WallisAndFutunaIslands
+"EH" // WesternSahara
+"YE" // Yemen
+"YU" // Yugoslavia
+"ZM" // Zambia
+"ZW" // Zimbabwe
+;
+
+static TQLocale::Language codeToLanguage(const TQString &code)
+{
+    if (code.length() != 2)
+        return TQLocale::C;
+
+    ushort uc1 = code.tqunicode()[0].tqunicode();
+    ushort uc2 = code.tqunicode()[1].tqunicode();
+
+    const char *c = language_code_list;
+    for (; *c != 0; c += 2) {
+        if (uc1 == (unsigned char)c[0] && uc2 == (unsigned char)c[1])
+            return (TQLocale::Language) ((c - language_code_list)/2);
+    }
+
+    return TQLocale::C;
+}
+
+static TQLocale::Country codeToCountry(const TQString &code)
+{
+    if (code.length() != 2)
+        return TQLocale::AnyCountry;
+
+    ushort uc1 = code.tqunicode()[0].tqunicode();
+    ushort uc2 = code.tqunicode()[1].tqunicode();
+
+    const char *c = country_code_list;
+    for (; *c != 0; c += 2) {
+        if (uc1 == (unsigned char)c[0] && uc2 == (unsigned char)c[1])
+            return (TQLocale::Country) ((c - country_code_list)/2);
+    }
+
+    return TQLocale::AnyCountry;
+}
+
+static TQString languageToCode(TQLocale::Language language)
+{
+    if (language == TQLocale::C)
+            return "C";
+
+    TQString code;
+    code.setLength(2);
+    const char *c = language_code_list + 2*(uint)language;
+    code[0] = c[0];
+    code[1] = c[1];
+    return code;
+}
+
+static TQString countryToCode(TQLocale::Country country)
+{
+    if (country == TQLocale::AnyCountry)
+        return TQString::null;
+
+    TQString code;
+    code.setLength(2);
+    const char *c = country_code_list + 2*(uint)country;
+    code[0] = c[0];
+    code[1] = c[1];
+    return code;
+}
+
+const TQLocalePrivate *TQLocale::default_d = 0;
+
+TQString TQLocalePrivate::infinity() const
+{
+    return TQString::tqfromLatin1("inf");
+}
+
+TQString TQLocalePrivate::nan() const
+{
+    return TQString::tqfromLatin1("nan");
+}
+
+#if defined(TQ_OS_WIN)
+/* Win95 doesn't have a function to return the ISO lang/country name of the user's locale.
+   Instead it can return a "Windows code". This maps windows codes to ISO country names. */
+
+struct WindowsToISOListElt {
+    int windows_code;
+    char iso_name[6];
+};
+
+static const WindowsToISOListElt windows_to_iso_list[] = {
+    { 0x0401, "ar_SA" },
+    { 0x0402, "bg\0  " },
+    { 0x0403, "ca\0  " },
+    { 0x0404, "zh_TW" },
+    { 0x0405, "cs\0  " },
+    { 0x0406, "da\0  " },
+    { 0x0407, "de\0  " },
+    { 0x0408, "el\0  " },
+    { 0x0409, "en_US" },
+    { 0x040a, "es\0  " },
+    { 0x040b, "fi\0  " },
+    { 0x040c, "fr\0  " },
+    { 0x040d, "he\0  " },
+    { 0x040e, "hu\0  " },
+    { 0x040f, "is\0  " },
+    { 0x0410, "it\0  " },
+    { 0x0411, "ja\0  " },
+    { 0x0412, "ko\0  " },
+    { 0x0413, "nl\0  " },
+    { 0x0414, "no\0  " },
+    { 0x0415, "pl\0  " },
+    { 0x0416, "pt_BR" },
+    { 0x0418, "ro\0  " },
+    { 0x0419, "ru\0  " },
+    { 0x041a, "hr\0  " },
+    { 0x041c, "sq\0  " },
+    { 0x041d, "sv\0  " },
+    { 0x041e, "th\0  " },
+    { 0x041f, "tr\0  " },
+    { 0x0420, "ur\0  " },
+    { 0x0421, "in\0  " },
+    { 0x0422, "uk\0  " },
+    { 0x0423, "be\0  " },
+    { 0x0425, "et\0  " },
+    { 0x0426, "lv\0  " },
+    { 0x0427, "lt\0  " },
+    { 0x0429, "fa\0  " },
+    { 0x042a, "vi\0  " },
+    { 0x042d, "eu\0  " },
+    { 0x042f, "mk\0  " },
+    { 0x0436, "af\0  " },
+    { 0x0438, "fo\0  " },
+    { 0x0439, "hi\0  " },
+    { 0x043e, "ms\0  " },
+    { 0x0458, "mt\0  " },
+    { 0x0801, "ar_IQ" },
+    { 0x0804, "zh_CN" },
+    { 0x0807, "de_CH" },
+    { 0x0809, "en_GB" },
+    { 0x080a, "es_MX" },
+    { 0x080c, "fr_BE" },
+    { 0x0810, "it_CH" },
+    { 0x0812, "ko\0  " },
+    { 0x0813, "nl_BE" },
+    { 0x0814, "no\0  " },
+    { 0x0816, "pt\0  " },
+    { 0x081a, "sr\0  " },
+    { 0x081d, "sv_FI" },
+    { 0x0c01, "ar_EG" },
+    { 0x0c04, "zh_HK" },
+    { 0x0c07, "de_AT" },
+    { 0x0c09, "en_AU" },
+    { 0x0c0a, "es\0  " },
+    { 0x0c0c, "fr_CA" },
+    { 0x0c1a, "sr\0  " },
+    { 0x1001, "ar_LY" },
+    { 0x1004, "zh_SG" },
+    { 0x1007, "de_LU" },
+    { 0x1009, "en_CA" },
+    { 0x100a, "es_GT" },
+    { 0x100c, "fr_CH" },
+    { 0x1401, "ar_DZ" },
+    { 0x1407, "de_LI" },
+    { 0x1409, "en_NZ" },
+    { 0x140a, "es_CR" },
+    { 0x140c, "fr_LU" },
+    { 0x1801, "ar_MA" },
+    { 0x1809, "en_IE" },
+    { 0x180a, "es_PA" },
+    { 0x1c01, "ar_TN" },
+    { 0x1c09, "en_ZA" },
+    { 0x1c0a, "es_DO" },
+    { 0x2001, "ar_OM" },
+    { 0x2009, "en_JM" },
+    { 0x200a, "es_VE" },
+    { 0x2401, "ar_YE" },
+    { 0x2409, "en\0  " },
+    { 0x240a, "es_CO" },
+    { 0x2801, "ar_SY" },
+    { 0x2809, "en_BZ" },
+    { 0x280a, "es_PE" },
+    { 0x2c01, "ar_JO" },
+    { 0x2c09, "en_TT" },
+    { 0x2c0a, "es_AR" },
+    { 0x3001, "ar_LB" },
+    { 0x300a, "es_EC" },
+    { 0x3401, "ar_KW" },
+    { 0x340a, "es_CL" },
+    { 0x3801, "ar_AE" },
+    { 0x380a, "es_UY" },
+    { 0x3c01, "ar_BH" },
+    { 0x3c0a, "es_PY" },
+    { 0x4001, "ar_QA" },
+    { 0x400a, "es_BO" },
+    { 0x440a, "es_SV" },
+    { 0x480a, "es_HN" },
+    { 0x4c0a, "es_NI" },
+    { 0x500a, "es_PR" }
+};
+
+static const int windows_to_iso_count
+    = sizeof(windows_to_iso_list)/sizeof(WindowsToISOListElt);
+
+static const char *winLangCodeToIsoName(int code)
+{
+    int cmp = code - windows_to_iso_list[0].windows_code;
+    if (cmp < 0)
+        return 0;
+
+    if (cmp == 0)
+        return windows_to_iso_list[0].iso_name;
+
+    int begin = 0;
+    int end = windows_to_iso_count;
+
+    while (end - begin > 1) {
+        uint mid = (begin + end)/2;
+
+        const WindowsToISOListElt *elt = windows_to_iso_list + mid;
+        int cmp = code - elt->windows_code;
+        if (cmp < 0)
+            end = mid;
+        else if (cmp > 0)
+            begin = mid;
+        else
+            return elt->iso_name;
+    }
+
+    return 0;
+
+}
+#endif // TQ_OS_WIN
+
+const char* TQLocalePrivate::systemLocaleName()
+{
+    static TQCString lang;
+    lang = getenv( "LANG" );
+
+#if !defined( TQWS ) && defined( TQ_OS_MAC )
+    if ( !lang.isEmpty() )
+        return lang;
+
+    char mac_ret[255];
+    if(!LocaleRefGetPartString(NULL, kLocaleLanguageMask | kLocaleRegionMask, 255, mac_ret))
+        lang = mac_ret;
+#endif
+
+#if defined(TQ_WS_WIN)
+    if ( !lang.isEmpty() ) {
+        long id = 0;
+        bool ok = false;
+        id = qstrtoll(lang.data(), 0, 0, &ok);
+        if ( !ok || id == 0 || id < INT_MIN || id > INT_MAX )
+            return lang;
+        else
+            return winLangCodeToIsoName( (int)id );
+    }
+
+    if (qWinVersion() == TQt::WV_95) {
+        lang = winLangCodeToIsoName(GetUserDefaultLangID());
+    } else {
+        TQT_WA( {
+            wchar_t out[256];
+            TQString language;
+            TQString sublanguage;
+            if ( GetLocaleInfoW( LOCALE_USER_DEFAULT, LOCALE_SISO639LANGNAME , out, 255 ) )
+                language = TQString::fromUcs2( (ushort*)out );
+            if ( GetLocaleInfoW( LOCALE_USER_DEFAULT, LOCALE_SISO3166CTRYNAME, out, 255 ) )
+                sublanguage = TQString::fromUcs2( (ushort*)out ).lower();
+            lang = language;
+            if ( sublanguage != language && !sublanguage.isEmpty() )
+                lang += "_" + sublanguage.upper();
+        } , {
+            char out[256];
+            TQString language;
+            TQString sublanguage;
+            if ( GetLocaleInfoA( LOCALE_USER_DEFAULT, LOCALE_SISO639LANGNAME, out, 255 ) )
+                language = TQString::fromLocal8Bit( out );
+            if ( GetLocaleInfoA( LOCALE_USER_DEFAULT, LOCALE_SISO3166CTRYNAME, out, 255 ) )
+                sublanguage = TQString::fromLocal8Bit( out ).lower();
+            lang = language;
+            if ( sublanguage != language && !sublanguage.isEmpty() )
+                lang += "_" + sublanguage.upper();
+        } );
+    }
+#endif
+    if ( lang.isEmpty() )
+        lang = "C";
+
+    return lang;
+}
+
+static const TQLocalePrivate *tqfindLocale(TQLocale::Language language,
+                                            TQLocale::Country country)
+{
+    unsigned language_id = (unsigned)language;
+    unsigned country_id = (unsigned)country;
+
+    uint idx = locale_index[language_id];
+
+    const TQLocalePrivate *d = locale_data + idx;
+
+    if (idx == 0) // default language has no associated country
+        return d;
+
+    if (country == TQLocale::AnyCountry)
+        return d;
+
+    TQ_ASSERT(d->languageId() == language_id);
+
+    while (d->languageId() == language_id
+                && d->countryId() != country_id)
+        ++d;
+
+    if (d->countryId() == country_id
+            && d->languageId() == language_id)
+        return d;
+
+    return locale_data + idx;
+}
+
+/*!
+    \class TQLocale
+    \brief The TQLocale class converts between numbers and their
+    string representations in various languages.
+
+    \reentrant
+    \ingroup text
+
+    It is initialized with a country/language pair in its constructor
+    and offers number-to-string and string-to-number conversion
+    functions simmilar to those in TQString.
+
+    \code
+    TQLocale egyptian(TQLocale::Arabic, TQLocale::Egypt);
+    TQString s1 = egyptian.toString(1.571429E+07, 'e');
+    TQString s2 = egyptian.toString(10);
+
+    double d = egyptian.toDouble(s1);
+    int s2 = egyptian.toInt(s2);
+    \endcode
+
+    TQLocale supports the concept of a default locale, which is
+    determined from the system's locale settings at application
+    startup. The default locale can be changed by calling the
+    static member setDefault(). The default locale has the
+    following effects:
+
+    \list
+    \i If a TQLocale object is constructed with the default constructor,
+       it will use the default locale's settings.
+    \i TQString::toDouble() interprets the string according to the default
+       locale. If this fails, it falls back on the "C" locale.
+    \i TQString::arg() uses the default locale to format a number when
+       its position specifier in the format string tqcontains an 'L',
+       e.g. "%L1".
+    \endlist
+
+    \code
+    TQLocale::setDefault(TQLocale(TQLocale::Hebrew, TQLocale::Israel));
+    TQLocale hebrew; // Constructs a default TQLocale
+    TQString s1 = hebrew.toString(15714.3, 'e');
+
+    bool ok;
+    double d;
+
+    TQLocale::setDefault(TQLocale::C);
+    d = TQString( "1234,56" ).toDouble(&ok); // ok == false
+    d = TQString( "1234.56" ).toDouble(&ok); // ok == true, d == 1234.56
+
+    TQLocale::setDefault(TQLocale::German);
+    d = TQString( "1234,56" ).toDouble(&ok); // ok == true, d == 1234.56
+    d = TQString( "1234.56" ).toDouble(&ok); // ok == true, d == 1234.56
+
+    TQLocale::setDefault(TQLocale(TQLocale::English, TQLocale::UnitedStates));
+    str = TQString( "%1 %L2 %L3" )
+            .arg( 12345 )
+            .arg( 12345 )
+            .arg( 12345, 0, 16 );
+    // str == "12345 12,345 3039"
+    \endcode
+
+    When a language/country pair is specified in the constructor, one
+    of three things can happen:
+
+    \list
+    \i If the language/country pair is found in the database, it is used.
+    \i If the language is found but the country is not, or if the country
+       is \c AnyCountry, the language is used with the most
+       appropriate available country (for example, Germany for German),
+    \i If neither the language nor the country are found, TQLocale
+       defaults to the default locale (see setDefault()).
+    \endlist
+
+    The "C" locale is identical to English/UnitedStates.
+
+    Use language() and country() to determine the actual language and
+    country values used.
+
+    An alternative method for constructing a TQLocale object is by
+    specifying the locale name.
+
+    \code
+    TQLocale korean("ko");
+    TQLocale swiss("de_CH");
+    \endcode
+
+    This constructor converts the locale name to a language/country
+    pair; it does not use the system locale database.
+
+    All the methods in TQLocale, with the exception of setDefault(),
+    are reentrant.
+
+    \sa TQString::toDouble() TQString::arg()
+
+    The double-to-string and string-to-double conversion functions are
+    covered by the following licenses:
+
+    \legalese
+
+    Copyright (c) 1991 by AT&T.
+
+    Permission to use, copy, modify, and distribute this software for any
+    purpose without fee is hereby granted, provided that this entire notice
+    is included in all copies of any software which is or includes a copy
+    or modification of this software and in all copies of the supporting
+    documentation for such software.
+
+    THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+    WARRANTY.  IN PARTICULAR, NEITHER THE AUTHOR NOR AT&T MAKES ANY
+    REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+    OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+
+    This product includes software developed by the University of
+    California, Berkeley and its contributors.
+*/
+
+/*!
+    \enum TQLocale::Language
+
+    This enumerated type is used to specify a language.
+
+    \value C Identical to English/UnitedStates
+    \value Abkhazian
+    \value Afan
+    \value Afar
+    \value Afrikaans
+    \value Albanian
+    \value Amharic
+    \value Arabic
+    \value Armenian
+    \value Assamese
+    \value Aymara
+    \value Azerbaijani
+    \value Bashkir
+    \value Basque
+    \value Bengali
+    \value Bhutani
+    \value Bihari
+    \value Bislama
+    \value Breton
+    \value Bulgarian
+    \value Burmese
+    \value Byelorussian
+    \value Cambodian
+    \value Catalan
+    \value Chinese
+    \value Corsican
+    \value Croatian
+    \value Czech
+    \value Danish
+    \value Dutch
+    \value English
+    \value Esperanto
+    \value Estonian
+    \value Faroese
+    \value FijiLanguage
+    \value Finnish
+    \value French
+    \value Frisian
+    \value Gaelic
+    \value Galician
+    \value Georgian
+    \value German
+    \value Greek
+    \value Greenlandic
+    \value Guarani
+    \value Gujarati
+    \value Hausa
+    \value Hebrew
+    \value Hindi
+    \value Hungarian
+    \value Icelandic
+    \value Indonesian
+    \value Interlingua
+    \value Interlingue
+    \value Inuktitut
+    \value Inupiak
+    \value Irish
+    \value Italian
+    \value Japanese
+    \value Javanese
+    \value Kannada
+    \value Kashmiri
+    \value Kazakh
+    \value Kinyarwanda
+    \value Kirghiz
+    \value Korean
+    \value Kurdish
+    \value Kurundi
+    \value Laothian
+    \value Latin
+    \value Latvian
+    \value Lingala
+    \value Lithuanian
+    \value Macedonian
+    \value Malagasy
+    \value Malay
+    \value Malayalam
+    \value Maltese
+    \value Maori
+    \value Marathi
+    \value Moldavian
+    \value Mongolian
+    \value NauruLanguage
+    \value Nepali
+    \value Norwegian
+    \value Occitan
+    \value Oriya
+    \value Pashto
+    \value Persian
+    \value Polish
+    \value Portuguese
+    \value Punjabi
+    \value Quechua
+    \value RhaetoRomance
+    \value Romanian
+    \value Russian
+    \value Samoan
+    \value Sangho
+    \value Sanskrit
+    \value Serbian
+    \value SerboCroatian
+    \value Sesotho
+    \value Setswana
+    \value Shona
+    \value Sindhi
+    \value Singhalese
+    \value Siswati
+    \value Slovak
+    \value Slovenian
+    \value Somali
+    \value Spanish
+    \value Sundanese
+    \value Swahili
+    \value Swedish
+    \value Tagalog
+    \value Tajik
+    \value Tamil
+    \value Tatar
+    \value Telugu
+    \value Thai
+    \value Tibetan
+    \value Tigrinya
+    \value TongaLanguage
+    \value Tsonga
+    \value Turkish
+    \value Turkmen
+    \value Twi
+    \value Uigur
+    \value Ukrainian
+    \value Urdu
+    \value Uzbek
+    \value Vietnamese
+    \value Volapuk
+    \value Welsh
+    \value Wolof
+    \value Xhosa
+    \value Yiddish
+    \value Yoruba
+    \value Zhuang
+    \value Zulu
+*/
+
+/*!
+    \enum TQLocale::Country
+
+    This enumerated type is used to specify a country.
+
+    \value AnyCountry
+    \value Afghanistan
+    \value Albania
+    \value Algeria
+    \value AmericanSamoa
+    \value Andorra
+    \value Angola
+    \value Anguilla
+    \value Antarctica
+    \value AntiguaAndBarbuda
+    \value Argentina
+    \value Armenia
+    \value Aruba
+    \value Australia
+    \value Austria
+    \value Azerbaijan
+    \value Bahamas
+    \value Bahrain
+    \value Bangladesh
+    \value Barbados
+    \value Belarus
+    \value Belgium
+    \value Belize
+    \value Benin
+    \value Bermuda
+    \value Bhutan
+    \value Bolivia
+    \value BosniaAndHerzegowina
+    \value Botswana
+    \value BouvetIsland
+    \value Brazil
+    \value BritishIndianOceanTerritory
+    \value BruneiDarussalam
+    \value Bulgaria
+    \value BurkinaFaso
+    \value Burundi
+    \value Cambodia
+    \value Cameroon
+    \value Canada
+    \value CapeVerde
+    \value CaymanIslands
+    \value CentralAfricanRepublic
+    \value Chad
+    \value Chile
+    \value China
+    \value ChristmasIsland
+    \value CocosIslands
+    \value Colombia
+    \value Comoros
+    \value DetqmocraticRepublicOfCongo
+    \value PeoplesRepublicOfCongo
+    \value CookIslands
+    \value CostaRica
+    \value IvoryCoast
+    \value Croatia
+    \value Cuba
+    \value Cyprus
+    \value CzechRepublic
+    \value Denmark
+    \value Djibouti
+    \value Dominica
+    \value DominicanRepublic
+    \value EastTimor
+    \value Ecuador
+    \value Egypt
+    \value ElSalvador
+    \value EquatorialGuinea
+    \value Eritrea
+    \value Estonia
+    \value Ethiopia
+    \value FalklandIslands
+    \value FaroeIslands
+    \value FijiCountry
+    \value Finland
+    \value France
+    \value MetropolitanFrance
+    \value FrenchGuiana
+    \value FrenchPolynesia
+    \value FrenchSouthernTerritories
+    \value Gabon
+    \value Gambia
+    \value Georgia
+    \value Germany
+    \value Ghana
+    \value Gibraltar
+    \value Greece
+    \value Greenland
+    \value Grenada
+    \value Guadeloupe
+    \value Guam
+    \value Guatemala
+    \value Guinea
+    \value GuineaBissau
+    \value Guyana
+    \value Haiti
+    \value HeardAndMcDonaldIslands
+    \value Honduras
+    \value HongKong
+    \value Hungary
+    \value Iceland
+    \value India
+    \value Indonesia
+    \value Iran
+    \value Iraq
+    \value Ireland
+    \value Israel
+    \value Italy
+    \value Jamaica
+    \value Japan
+    \value Jordan
+    \value Kazakhstan
+    \value Kenya
+    \value Kiribati
+    \value DetqmocraticRepublicOfKorea
+    \value RepublicOfKorea
+    \value Kuwait
+    \value Kyrgyzstan
+    \value Lao
+    \value Latvia
+    \value Lebanon
+    \value Lesotho
+    \value Liberia
+    \value LibyanArabJamahiriya
+    \value Liechtenstein
+    \value Lithuania
+    \value Luxembourg
+    \value Macau
+    \value Macedonia
+    \value Madagascar
+    \value Malawi
+    \value Malaysia
+    \value Maldives
+    \value Mali
+    \value Malta
+    \value MarshallIslands
+    \value Martinique
+    \value Mauritania
+    \value Mauritius
+    \value Mayotte
+    \value Mexico
+    \value Micronesia
+    \value Moldova
+    \value Monaco
+    \value Mongolia
+    \value Montserrat
+    \value Morocco
+    \value Mozambique
+    \value Myanmar
+    \value Namibia
+    \value NauruCountry
+    \value Nepal
+    \value Netherlands
+    \value NetherlandsAntilles
+    \value NewCaledonia
+    \value NewZealand
+    \value Nicaragua
+    \value Niger
+    \value Nigeria
+    \value Niue
+    \value NorfolkIsland
+    \value NorthernMarianaIslands
+    \value Norway
+    \value Oman
+    \value Pakistan
+    \value Palau
+    \value PalestinianTerritory
+    \value Panama
+    \value PapuaNewGuinea
+    \value Paraguay
+    \value Peru
+    \value Philippines
+    \value Pitcairn
+    \value Poland
+    \value Portugal
+    \value PuertoRico
+    \value Qatar
+    \value Reunion
+    \value Romania
+    \value RussianFederation
+    \value Rwanda
+    \value SaintKittsAndNevis
+    \value StLucia
+    \value StVincentAndTheGrenadines
+    \value Samoa
+    \value SanMarino
+    \value SaoTomeAndPrincipe
+    \value SaudiArabia
+    \value Senegal
+    \value Seychelles
+    \value SierraLeone
+    \value Singapore
+    \value Slovakia
+    \value Slovenia
+    \value SolomonIslands
+    \value Somalia
+    \value SouthAfrica
+    \value SouthGeorgiaAndTheSouthSandwichIslands
+    \value Spain
+    \value SriLanka
+    \value StHelena
+    \value StPierreAndMiquelon
+    \value Sudan
+    \value Suriname
+    \value SvalbardAndJanMayenIslands
+    \value Swaziland
+    \value Sweden
+    \value Switzerland
+    \value SyrianArabRepublic
+    \value Taiwan
+    \value Tajikistan
+    \value Tanzania
+    \value Thailand
+    \value Togo
+    \value Tokelau
+    \value TongaCountry
+    \value TrinidadAndTobago
+    \value Tunisia
+    \value Turkey
+    \value Turkmenistan
+    \value TurksAndCaicosIslands
+    \value Tuvalu
+    \value Uganda
+    \value Ukraine
+    \value UnitedArabEmirates
+    \value UnitedKingdom
+    \value UnitedStates
+    \value UnitedStatesMinorOutlyingIslands
+    \value Uruguay
+    \value Uzbekistan
+    \value Vanuatu
+    \value VaticanCityState
+    \value Venezuela
+    \value VietNam
+    \value BritishVirginIslands
+    \value USVirginIslands
+    \value WallisAndFutunaIslands
+    \value WesternSahara
+    \value Yemen
+    \value Yugoslavia
+    \value Zambia
+    \value Zimbabwe
+*/
+
+/*!
+    Constructs a TQLocale object with the specified \a name,
+    which has the format
+    "language[_country][.codeset][@modifier]" or "C", where:
+
+    \list
+    \i language is a lowercase, two-letter, ISO 639 language code,
+    \i territory is an uppercase, two-letter, ISO 3166 country code,
+    \i and codeset and modifier are ignored.
+    \endlist
+
+    If the string violates the locale format, or language is not
+    a valid ISO 369 code, the "C" locale is used instead. If country
+    is not present, or is not a valid ISO 3166 code, the most
+    appropriate country is chosen for the specified language.
+
+    The language and country codes are converted to their respective
+    \c Language and \c Country enums. After this conversion is
+    performed the constructor behaves exactly like TQLocale(Country,
+    Language).
+
+    This constructor is much slower than TQLocale(Country, Language).
+
+    \sa name()
+*/
+
+TQLocale::TQLocale(const TQString &name)
+{
+    Language lang = C;
+    Country cntry = AnyCountry;
+
+    uint l = name.length();
+
+    do {
+        if (l < 2)
+            break;
+
+        const TQChar *uc = name.tqunicode();
+        if (l > 2
+                    && uc[2] != '_'
+                && uc[2] != '.'
+                && uc[2] != '@')
+            break;
+
+        lang = codeToLanguage(name.mid(0, 2));
+        if (lang == C)
+            break;
+
+        if (l == 2 || uc[2] == '.' || uc[2] == '@')
+            break;
+
+        // we have uc[2] == '_'
+        if (l < 5)
+            break;
+
+        if (l > 5 && uc[5] != '.' && uc[5] != '@')
+            break;
+
+        cntry = codeToCountry(name.mid(3, 2));
+    } while (FALSE);
+
+    d = tqfindLocale(lang, cntry);
+}
+
+/*!
+    Constructs a TQLocale object initialized with the default locale.
+
+    \sa setDefault()
+*/
+
+TQLocale::TQLocale()
+{
+    if (default_d == 0)
+        default_d = system().d;
+
+    d = default_d;
+}
+
+/*!
+    Constructs a TQLocale object with the specified \a language and \a
+    country.
+
+    \list
+    \i If the language/country pair is found in the database, it is used.
+    \i If the language is found but the country is not, or if the country
+       is \c AnyCountry, the language is used with the most
+       appropriate available country (for example, Germany for German),
+    \i If neither the language nor the country are found, TQLocale
+       defaults to the default locale (see setDefault()).
+    \endlist
+
+    The language and country that are actually used can be queried
+    using language() and country().
+
+    \sa setDefault() language() country()
+*/
+
+TQLocale::TQLocale(Language language, Country country)
+{
+    d = tqfindLocale(language, country);
+
+    // If not found, should default to system
+    if (d->languageId() == TQLocale::C && language != TQLocale::C) {
+        if (default_d == 0)
+            default_d = system().d;
+
+        d = default_d;
+    }
+}
+
+/*!
+    Constructs a TQLocale object as a copy of \a other.
+*/
+
+TQLocale::TQLocale(const TQLocale &other)
+{
+    d = other.d;
+}
+
+/*!
+    Assigns \a other to this TQLocale object and returns a reference
+    to this TQLocale object.
+*/
+
+TQLocale &TQLocale::operator=(const TQLocale &other)
+{
+    d = other.d;
+    return *this;
+}
+
+/*!
+    \nonreentrant
+
+    Sets the global default locale to \a locale. These
+    values are used when a TQLocale object is constructed with
+    no arguments. If this function is not called, the system's
+    locale is used.
+
+    \warning In a multithreaded application, the default locale
+    should be set at application startup, before any non-GUI threads
+    are created.
+
+    \sa system() c()
+*/
+
+void TQLocale::setDefault(const TQLocale &locale)
+{
+    default_d = locale.d;
+}
+
+/*!
+    Returns the language of this locale.
+
+    \sa TQLocale()
+*/
+TQLocale::Language TQLocale::language() const
+{
+    return (Language)d->languageId();
+}
+
+/*!
+    Returns the country of this locale.
+
+    \sa TQLocale()
+*/
+TQLocale::Country TQLocale::country() const
+{
+    return (Country)d->countryId();
+}
+
+/*!
+    Returns the language and country of this locale as a
+    string of the form "language_country", where
+    language is a lowercase, two-letter ISO 639 language code,
+    and country is an uppercase, two-letter ISO 3166 country code.
+
+    \sa TQLocale()
+*/
+
+TQString TQLocale::name() const
+{
+    Language l = language();
+
+    TQString result = languageToCode(l);
+
+    if (l == C)
+        return result;
+
+    Country c = country();
+    if (c == AnyCountry)
+        return result;
+
+    result.append('_');
+    result.append(countryToCode(c));
+
+    return result;
+}
+
+/*!
+    Returns a TQString containing the name of \a language.
+*/
+
+TQString TQLocale::languageToString(Language language)
+{
+    if ((uint)language > (uint)TQLocale::LastLanguage)
+            return "Unknown";
+    return language_name_list + language_name_index[(uint)language];
+}
+
+/*!
+    Returns a TQString containing the name of \a country.
+*/
+
+TQString TQLocale::countryToString(Country country)
+{
+    if ((uint)country > (uint)TQLocale::LastCountry)
+            return "Unknown";
+    return country_name_list + country_name_index[(uint)country];
+}
+
+/*!
+    Returns the short int represented by the localized string \a s, or
+    0 if the conversion failed.
+
+    If \a ok is not 0, reports failure by setting
+    *ok to false and success by setting *ok to true.
+
+    This function ignores leading and trailing whitespace.
+
+    \sa toString()
+*/
+
+short TQLocale::toShort(const TQString &s, bool *ok) const
+{
+    TQ_LLONG i = toLongLong(s, ok);
+    if (i < SHRT_MIN || i > SHRT_MAX) {
+        if (ok != 0)
+            *ok = FALSE;
+        return 0;
+    }
+    return (short) i;
+}
+
+/*!
+    Returns the unsigned short int represented by the localized string
+    \a s, or 0 if the conversion failed.
+
+    If \a ok is not 0, reports failure by setting
+    *ok to false and success by setting *ok to true.
+
+    This function ignores leading and trailing whitespace.
+
+    \sa toString()
+*/
+
+ushort TQLocale::toUShort(const TQString &s, bool *ok) const
+{
+    TQ_ULLONG i = toULongLong(s, ok);
+    if (i > USHRT_MAX) {
+        if (ok != 0)
+            *ok = FALSE;
+        return 0;
+    }
+    return (ushort) i;
+}
+
+/*!
+    Returns the int represented by the localized string \a s, or 0 if
+    the conversion failed.
+
+    If \a ok is not 0, reports failure by setting *ok to false and
+    success by setting *ok to true.
+
+    This function ignores leading and trailing whitespace.
+
+    \sa toString()
+*/
+
+int TQLocale::toInt(const TQString &s, bool *ok) const
+{
+    TQ_LLONG i = toLongLong(s, ok);
+    if (i < INT_MIN || i > INT_MAX) {
+        if (ok != 0)
+            *ok = FALSE;
+        return 0;
+    }
+    return (int) i;
+}
+
+/*!
+    Returns the unsigned int represented by the localized string \a s,
+    or 0 if the conversion failed.
+
+    If \a ok is not 0, reports failure by setting
+    *ok to false and success by setting *ok to true.
+
+    This function ignores leading and trailing whitespace.
+
+    \sa toString()
+*/
+
+uint TQLocale::toUInt(const TQString &s, bool *ok) const
+{
+    TQ_ULLONG i = toULongLong(s, ok);
+    if (i > UINT_MAX) {
+        if (ok != 0)
+            *ok = FALSE;
+        return 0;
+    }
+    return (uint) i;
+}
+
+/*!
+    Returns the long int represented by the localized string \a s, or
+    0 if the conversion failed.
+
+    If \a ok is not 0, reports failure by setting
+    *ok to false and success by setting *ok to true.
+
+    This function ignores leading and trailing whitespace.
+
+    \sa toString()
+*/
+
+TQ_LONG TQLocale::toLong(const TQString &s, bool *ok) const
+{
+    TQ_LLONG i = toLongLong(s, ok);
+    if (i < LONG_MIN || i > LONG_MAX) {
+        if (ok != 0)
+            *ok = FALSE;
+        return 0;
+    }
+    return (TQ_LONG) i;
+}
+
+/*!
+    Returns the unsigned long int represented by the localized string
+    \a s, or 0 if the conversion failed.
+
+    If \a ok is not 0, reports failure by setting
+    *ok to false and success by setting *ok to true.
+
+    This function ignores leading and trailing whitespace.
+
+    \sa toString()
+*/
+
+TQ_ULONG TQLocale::toULong(const TQString &s, bool *ok) const
+{
+    TQ_ULLONG i = toULongLong(s, ok);
+    if (i > ULONG_MAX) {
+        if (ok != 0)
+            *ok = FALSE;
+        return 0;
+    }
+    return (TQ_ULONG) i;
+}
+
+/*!
+    Returns the long long int represented by the localized string \a
+    s, or 0 if the conversion failed.
+
+    If \a ok is not 0, reports failure by setting
+    *ok to false and success by setting *ok to true.
+
+    This function ignores leading and trailing whitespace.
+
+    \sa toString()
+*/
+
+
+TQ_LLONG TQLocale::toLongLong(const TQString &s, bool *ok) const
+{
+    return d->stringToLongLong(s, 0, ok, TQLocalePrivate::ParseGroupSeparators);
+}
+
+/*!
+    Returns the unsigned long long int represented by the localized
+    string \a s, or 0 if the conversion failed.
+
+    If \a ok is not 0, reports failure by setting
+    *ok to false and success by setting *ok to true.
+
+    This function ignores leading and trailing whitespace.
+
+    \sa toString()
+*/
+
+
+TQ_ULLONG TQLocale::toULongLong(const TQString &s, bool *ok) const
+{
+    return d->stringToUnsLongLong(s, 0, ok, TQLocalePrivate::ParseGroupSeparators);
+}
+
+/*!
+    Returns the float represented by the localized string \a s, or 0.0
+    if the conversion failed.
+
+    If \a ok is not 0, reports failure by setting
+    *ok to false and success by setting *ok to true.
+
+    This function ignores leading and trailing whitespace.
+
+    \sa toString()
+*/
+
+#define TQT_MAX_FLOAT 3.4028234663852886e+38
+
+float TQLocale::toFloat(const TQString &s, bool *ok) const
+{
+    bool myOk;
+    double d = toDouble(s, &myOk);
+    if (!myOk || d > TQT_MAX_FLOAT || d < -TQT_MAX_FLOAT) {
+        if (ok != 0)
+            *ok = FALSE;
+        return 0.0;
+    }
+    if (ok != 0)
+        *ok = TRUE;
+    return (float) d;
+}
+
+/*!
+    Returns the double represented by the localized string \a s, or
+    0.0 if the conversion failed.
+
+    If \a ok is not 0, reports failure by setting
+    *ok to false and success by setting *ok to true.
+
+    Unlike TQString::toDouble(), this function does not fall back to
+    the "C" locale if the string cannot be interpreted in this
+    locale.
+
+    \code
+        bool ok;
+        double d;
+
+        TQLocale c(TQLocale::C);
+        d = c.toDouble( "1234.56", &ok );  // ok == true, d == 1234.56
+        d = c.toDouble( "1,234.56", &ok ); // ok == true, d == 1234.56
+        d = c.toDouble( "1234,56", &ok );  // ok == false
+
+        TQLocale german(TQLocale::German);
+        d = german.toDouble( "1234,56", &ok );  // ok == true, d == 1234.56
+        d = german.toDouble( "1.234,56", &ok ); // ok == true, d == 1234.56
+        d = german.toDouble( "1234.56", &ok );  // ok == false
+
+        d = german.toDouble( "1.234", &ok );    // ok == true, d == 1234.0
+    \endcode
+
+    Notice that the last conversion returns 1234.0, because '.' is the
+    thousands group separator in the German locale.
+
+    This function ignores leading and trailing whitespace.
+
+    \sa toString() TQString::toDouble()
+*/
+
+double TQLocale::toDouble(const TQString &s, bool *ok) const
+{
+    return d->stringToDouble(s, ok, TQLocalePrivate::ParseGroupSeparators);
+}
+
+/*!
+    Returns a localized string representation of \a i.
+
+    \sa toLongLong()
+*/
+
+TQString TQLocale::toString(TQ_LLONG i) const
+{
+    return d->longLongToString(i, -1, 10, -1, TQLocalePrivate::ThousandsGroup);
+}
+
+/*!
+    \overload
+
+    \sa toULongLong()
+*/
+
+TQString TQLocale::toString(TQ_ULLONG i) const
+{
+    return d->unsLongLongToString(i, -1, 10, -1, TQLocalePrivate::ThousandsGroup);
+}
+
+static bool qIsUpper(char c)
+{
+    return c >= 'A' && c <= 'Z';
+}
+
+static char qToLower(char c)
+{
+    if (c >= 'A' && c <= 'Z')
+        return c - 'A' + 'a';
+    else
+        return c;
+}
+
+/*!
+    \overload
+
+    \a f and \a prec have the same meaning as in TQString::number(double, char, int).
+
+    \sa toDouble()
+*/
+
+TQString TQLocale::toString(double i, char f, int prec) const
+{
+    TQLocalePrivate::DoubleForm form = TQLocalePrivate::DFDecimal;
+    uint flags = 0;
+
+    if (qIsUpper(f))
+        flags = TQLocalePrivate::CapitalEorX;
+    f = qToLower(f);
+
+    switch (f) {
+        case 'f':
+            form = TQLocalePrivate::DFDecimal;
+            break;
+        case 'e':
+            form = TQLocalePrivate::DFExponent;
+            break;
+        case 'g':
+            form = TQLocalePrivate::DFSignificantDigits;
+            break;
+        default:
+            break;
+    }
+
+    flags |= TQLocalePrivate::ThousandsGroup;
+    return d->doubleToString(i, prec, form, -1, flags);
+}
+
+/*!
+    \fn TQLocale TQLocale::c()
+
+    Returns a TQLocale object initialized to the "C" locale.
+
+    \sa system()
+*/
+
+/*!
+    Returns a TQLocale object initialized to the system locale.
+*/
+
+TQLocale TQLocale::system()
+{
+#ifdef TQ_OS_UNIX
+    const char *s = getenv("LC_NUMERIC");
+    if (s == 0)
+        s = getenv("LC_ALL");
+    if (s != 0)
+            return TQLocale(s);
+#endif
+    return TQLocale(TQLocalePrivate::systemLocaleName());
+}
+
+/*!
+\fn TQString TQLocale::toString(short i) const
+
+\overload
+
+\sa toShort()
+*/
+
+/*!
+\fn TQString TQLocale::toString(ushort i) const
+
+\overload
+
+\sa toUShort()
+*/
+
+/*!
+\fn TQString TQLocale::toString(int i) const
+
+\overload
+
+\sa toInt()
+*/
+
+/*!
+\fn TQString TQLocale::toString(uint i) const
+
+\overload
+
+\sa toUInt()
+*/
+
+/*!
+\fn TQString TQLocale::toString(TQ_LONG i) const
+
+\overload
+
+\sa  toLong()
+*/
+
+/*!
+\fn TQString TQLocale::toString(TQ_ULONG i) const
+
+\overload
+
+\sa toULong()
+*/
+
+/*!
+\fn TQString TQLocale::toString(float i, char f = 'g', int prec = 6) const
+
+\overload
+
+\a f and \a prec have the same meaning as in TQString::number(double, char, int).
+
+\sa toDouble()
+*/
+
+
+bool TQLocalePrivate::isDigit(TQChar d) const
+{
+    return zero().tqunicode() <= d.tqunicode()
+            && zero().tqunicode() + 10 > d.tqunicode();
+}
+
+static char digitToCLocale(TQChar zero, TQChar d)
+{
+    if (zero.tqunicode() <= d.tqunicode()
+            && zero.tqunicode() + 10 > d.tqunicode())
+        return '0' + d.tqunicode() - zero.tqunicode();
+
+    qWarning("TQLocalePrivate::digitToCLocale(): bad digit: row=%d, cell=%d", d.row(), d.cell());
+    return TQChar(0);
+}
+
+static TQString qulltoa(TQ_ULLONG l, int base, const TQLocalePrivate &locale)
+{
+    TQChar buff[65]; // length of MAX_ULLONG in base 2
+    TQChar *p = buff + 65;
+
+    if (base != 10 || locale.zero().tqunicode() == '0') {
+        while (l != 0) {
+            int c = l % base;
+
+            --p;
+
+            if (c < 10)
+                *p = '0' + c;
+            else
+                *p = c - 10 + 'a';
+
+            l /= base;
+        }
+    }
+    else {
+        while (l != 0) {
+            int c = l % base;
+
+            *(--p) = locale.zero().tqunicode() + c;
+
+            l /= base;
+        }
+    }
+
+    return TQString(p, 65 - (p - buff));
+}
+
+static TQString qlltoa(TQ_LLONG l, int base, const TQLocalePrivate &locale)
+{
+    return qulltoa(l < 0 ? -l : l, base, locale);
+}
+
+enum PrecisionMode {
+    PMDecimalDigits =             0x01,
+    PMSignificantDigits =   0x02,
+    PMChopTrailingZeros =   0x03
+};
+
+static TQString &decimalForm(TQString &digits, int decpt, uint precision,
+                            PrecisionMode pm,
+                            bool always_show_decpt,
+                            bool thousands_group,
+                            const TQLocalePrivate &locale)
+{
+    if (decpt < 0) {
+        for (int i = 0; i < -decpt; ++i)
+            digits.prepend(locale.zero());
+        decpt = 0;
+    }
+    else if ((uint)decpt > digits.length()) {
+        for (uint i = digits.length(); i < (uint)decpt; ++i)
+            digits.append(locale.zero());
+    }
+
+    if (pm == PMDecimalDigits) {
+        uint decimal_digits = digits.length() - decpt;
+        for (uint i = decimal_digits; i < precision; ++i)
+            digits.append(locale.zero());
+    }
+    else if (pm == PMSignificantDigits) {
+        for (uint i = digits.length(); i < precision; ++i)
+            digits.append(locale.zero());
+    }
+    else { // pm == PMChopTrailingZeros
+    }
+
+    if (always_show_decpt || (uint)decpt < digits.length())
+        digits.insert(decpt, locale.decimal());
+
+    if (thousands_group) {
+        for (int i = decpt - 3; i > 0; i -= 3)
+            digits.insert(i, locale.group());
+    }
+
+    if (decpt == 0)
+        digits.prepend(locale.zero());
+
+    return digits;
+}
+
+static TQString &exponentForm(TQString &digits, int decpt, uint precision,
+                                PrecisionMode pm,
+                                bool always_show_decpt,
+                                const TQLocalePrivate &locale)
+{
+    int exp = decpt - 1;
+
+    if (pm == PMDecimalDigits) {
+        for (uint i = digits.length(); i < precision + 1; ++i)
+            digits.append(locale.zero());
+    }
+    else if (pm == PMSignificantDigits) {
+        for (uint i = digits.length(); i < precision; ++i)
+            digits.append(locale.zero());
+    }
+    else { // pm == PMChopTrailingZeros
+    }
+
+    if (always_show_decpt || digits.length() > 1)
+        digits.insert(1, locale.decimal());
+
+    digits.append(locale.exponential());
+    digits.append(locale.longLongToString(exp, 2, 10,
+                    -1, TQLocalePrivate::AlwaysShowSign));
+
+    return digits;
+}
+
+static bool isZero(double d)
+{
+    uchar *ch = (uchar *)&d;
+    if (ByteOrder == BigEndian) {
+        return !(ch[0] & 0x7F || ch[1] || ch[2] || ch[3] || ch[4] || ch[5] || ch[6] || ch[7]);
+    } else {
+        return !(ch[7] & 0x7F || ch[6] || ch[5] || ch[4] || ch[3] || ch[2] || ch[1] || ch[0]);
+    }
+}
+
+TQString TQLocalePrivate::doubleToString(double d,
+                                        int precision,
+                                        DoubleForm form,
+                                        int width,
+                                        unsigned flags) const
+{
+    if (precision == -1)
+        precision = 6;
+    if (width == -1)
+        width = 0;
+
+    bool negative = FALSE;
+    bool special_number = FALSE; // nan, +/-inf
+    TQString num_str;
+
+#ifdef TQ_OS_WIN
+    // Detect special numbers (nan, +/-inf)
+    if (qIsInf(d)) {
+        num_str = infinity();
+        special_number = TRUE;
+        negative = d < 0;
+    } else if (qIsNan(d)) {
+        num_str = nan();
+        special_number = TRUE;
+    }
+#else
+    // Comparing directly to INFINITY gives weird results on some systems.
+    double tmp_infinity = INFINITY;
+
+    // Detect special numbers (nan, +/-inf)
+    if (d == tmp_infinity || d == -tmp_infinity) {
+        num_str = infinity();
+        special_number = TRUE;
+        negative = d < 0;
+    } else if (qIsNan(d)) {
+        num_str = nan();
+        special_number = TRUE;
+    }
+#endif
+
+    // Handle normal numbers
+    if (!special_number) {
+        int decpt, sign;
+        TQString digits;
+
+#ifdef TQT_TQLOCALE_USES_FCVT
+#ifdef TQT_THREAD_SUPPORT
+        static bool dummy_for_mutex;
+        TQMutex *fcvt_mutex =  tqt_global_mutexpool ? tqt_global_mutexpool->get( &dummy_for_mutex ) : 0;
+# define FCVT_LOCK if (fcvt_mutex) fcvt_mutex->lock()
+# define FCVT_UNLOCK if (fcvt_mutex) fcvt_mutex->unlock()
+#else
+# define FCVT_LOCK
+# define FCVT_UNLOCK
+#endif
+        if (form == DFDecimal) {
+            FCVT_LOCK;
+            digits = fcvt(d, precision, &decpt, &sign);
+            FCVT_UNLOCK;
+        } else {
+            int pr = precision;
+            if (form == DFExponent)
+                ++pr;
+            else if (form == DFSignificantDigits && pr == 0)
+                pr = 1;
+            FCVT_LOCK;
+            digits = ecvt(d, pr, &decpt, &sign);
+            FCVT_UNLOCK;
+
+            // Chop trailing zeros
+            if (digits.length() > 0) {
+                int last_nonzero_idx = digits.length() - 1;
+                while (last_nonzero_idx > 0
+                       && digits.tqunicode()[last_nonzero_idx] == '0')
+                    --last_nonzero_idx;
+                digits.truncate(last_nonzero_idx + 1);
+            }
+
+        }
+
+#else
+        int mode;
+        if (form == DFDecimal)
+            mode = 3;
+        else
+            mode = 2;
+
+        /* This next bit is a bit quirky. In DFExponent form, the precision
+           is the number of digits after decpt. So that would suggest using
+           mode=3 for qdtoa. But qdtoa behaves strangely when mode=3 and
+           precision=0. So we get around this by using mode=2 and reasoning
+           that we want precision+1 significant digits, since the decimal
+           point in this mode is always after the first digit. */
+        int pr = precision;
+        if (form == DFExponent)
+            ++pr;
+
+        char *rve = 0;
+        char *buff = 0;
+        digits = qdtoa(d, mode, pr, &decpt, &sign, &rve, &buff);
+        if (buff != 0)
+            free(buff);
+#endif // TQT_TQLOCALE_USES_FCVT
+
+        if (zero().tqunicode() != '0') {
+            for (uint i = 0; i < digits.length(); ++i)
+                    digits.ref(i).unicode() += zero().tqunicode() - '0';
+        }
+
+        bool always_show_decpt = flags & Alternate;
+        switch (form) {
+            case DFExponent: {
+                num_str = exponentForm(digits, decpt, precision, PMDecimalDigits,
+                                                    always_show_decpt, *this);
+                break;
+            }
+            case DFDecimal: {
+                num_str = decimalForm(digits, decpt, precision, PMDecimalDigits,
+                                        always_show_decpt, flags & ThousandsGroup,
+                                        *this);
+                break;
+            }
+            case DFSignificantDigits: {
+                PrecisionMode mode = (flags & Alternate) ?
+                            PMSignificantDigits : PMChopTrailingZeros;
+
+                if (decpt != (int)digits.length() && (decpt <= -4 || decpt > (int)precision))
+                    num_str = exponentForm(digits, decpt, precision, mode,
+                                                    always_show_decpt, *this);
+                else
+                    num_str = decimalForm(digits, decpt, precision, mode,
+                                            always_show_decpt, flags & ThousandsGroup,
+                                            *this);
+                break;
+            }
+        }
+
+        negative = sign != 0 && !isZero(d);
+    }
+
+    // pad with zeros. LeftAdjusted overrides this flag). Also, we don't
+    // pad special numbers
+    if (flags & TQLocalePrivate::ZeroPadded
+            && !(flags & TQLocalePrivate::LeftAdjusted)
+            && !special_number) {
+        int num_pad_chars = width - (int)num_str.length();
+        // leave space for the sign
+        if (negative
+                || flags & TQLocalePrivate::AlwaysShowSign
+                || flags & TQLocalePrivate::BlankBeforePositive)
+            --num_pad_chars;
+
+        for (int i = 0; i < num_pad_chars; ++i)
+            num_str.prepend(zero());
+    }
+
+    // add sign
+    if (negative)
+        num_str.prepend(minus());
+    else if (flags & TQLocalePrivate::AlwaysShowSign)
+        num_str.prepend(plus());
+    else if (flags & TQLocalePrivate::BlankBeforePositive)
+            num_str.prepend(' ');
+
+    if (flags & TQLocalePrivate::CapitalEorX)
+            num_str = num_str.upper();
+
+    return num_str;
+}
+
+TQString TQLocalePrivate::longLongToString(TQ_LLONG l, int precision,
+                                            int base, int width,
+                                            unsigned flags) const
+{
+    bool precision_not_specified = FALSE;
+    if (precision == -1) {
+        precision_not_specified = TRUE;
+        precision = 1;
+    }
+
+    bool negative = l < 0;
+    if (base != 10) {
+        // these are not suported by sprintf for octal and hex
+        flags &= ~AlwaysShowSign;
+        flags &= ~BlankBeforePositive;
+        negative = FALSE; // neither are negative numbers
+    }
+
+    TQString num_str;
+    if (base == 10)
+        num_str = qlltoa(l, base, *this);
+    else
+        num_str = qulltoa(l, base, *this);
+
+    uint cnt_thousand_sep = 0;
+    if (flags & ThousandsGroup && base == 10) {
+        for (int i = (int)num_str.length() - 3; i > 0; i -= 3) {
+            num_str.insert(i, group());
+            ++cnt_thousand_sep;
+        }
+    }
+
+    for (int i = num_str.length()/* - cnt_thousand_sep*/; i < precision; ++i)
+            num_str.prepend(base == 10 ? zero() : TQChar('0'));
+
+    if (flags & Alternate
+            && base == 8
+            && (num_str.isEmpty()
+                        || num_str[0].unicode() != '0'))
+            num_str.prepend('0');
+
+    // LeftAdjusted overrides this flag ZeroPadded. sprintf only padds
+    // when precision is not specified in the format string
+    bool zero_padded = flags & ZeroPadded
+                        && !(flags & LeftAdjusted)
+                        && precision_not_specified;
+
+    if (zero_padded) {
+        int num_pad_chars = width - (int)num_str.length();
+
+        // leave space for the sign
+        if (negative
+                || flags & AlwaysShowSign
+                || flags & BlankBeforePositive)
+            --num_pad_chars;
+
+        // leave space for optional '0x' in hex form
+        if (base == 16
+                && flags & Alternate
+                && l != 0)
+            num_pad_chars -= 2;
+
+        for (int i = 0; i < num_pad_chars; ++i)
+            num_str.prepend(base == 10 ? zero() : TQChar('0'));
+    }
+
+    if (base == 16
+            && flags & Alternate
+            && l != 0)
+            num_str.prepend("0x");
+
+    // add sign
+    if (negative)
+        num_str.prepend(minus());
+    else if (flags & AlwaysShowSign)
+            num_str.prepend(base == 10 ? plus() : TQChar('+'));
+    else if (flags & BlankBeforePositive)
+            num_str.prepend(' ');
+
+    if (flags & CapitalEorX)
+            num_str = num_str.upper();
+
+    return num_str;
+}
+
+TQString TQLocalePrivate::unsLongLongToString(TQ_ULLONG l, int precision,
+                                            int base, int width,
+                                            unsigned flags) const
+{
+    bool precision_not_specified = FALSE;
+    if (precision == -1) {
+        precision_not_specified = TRUE;
+        precision = 1;
+    }
+
+    TQString num_str = qulltoa(l, base, *this);
+
+    uint cnt_thousand_sep = 0;
+    if (flags & ThousandsGroup && base == 10) {
+        for (int i = (int)num_str.length() - 3; i > 0; i -=3) {
+            num_str.insert(i, group());
+            ++cnt_thousand_sep;
+        }
+    }
+
+    for (int i = num_str.length()/* - cnt_thousand_sep*/; i < precision; ++i)
+            num_str.prepend(base == 10 ? zero() : TQChar('0'));
+
+    if (flags & Alternate
+            && base == 8
+            && (num_str.isEmpty()
+                        || num_str[0].unicode() != '0'))
+            num_str.prepend('0');
+
+    // LeftAdjusted overrides this flag ZeroPadded. sprintf only padds
+    // when precision is not specified in the format string
+    bool zero_padded = flags & ZeroPadded
+                        && !(flags & LeftAdjusted)
+                        && precision_not_specified;
+
+    if (zero_padded) {
+        int num_pad_chars = width - (int)num_str.length();
+
+        // leave space for optional '0x' in hex form
+        if (base == 16
+                && flags & Alternate
+                && l != 0)
+            num_pad_chars -= 2;
+
+        for (int i = 0; i < num_pad_chars; ++i)
+            num_str.prepend(base == 10 ? zero() : TQChar('0'));
+    }
+
+    if (base == 16
+            && flags & Alternate
+            && l != 0)
+            num_str.prepend("0x");
+
+    if (flags & CapitalEorX)
+            num_str = num_str.upper();
+
+    return num_str;
+}
+
+static inline bool isLatin1Digit(const TQChar &c)
+{
+    return c.tqunicode() >= '0' && c.tqunicode() <= '9';
+}
+
+// Removes thousand-group separators, ie. the ',' in "1,234,567.89e-5"
+bool TQLocalePrivate::removeGroupSeparators(TQString &num_str) const
+{
+    int group_cnt = 0; // counts number of group chars
+    int decpt_idx = -1;
+
+    // Find the decimal point and check if there are any group chars
+    uint i = 0;
+    for (; i < num_str.length(); ++i) {
+            TQChar c = num_str.tqunicode()[i];
+
+        if (c.tqunicode() == ',') {
+            // check that there are digits before and after the separator
+            if (i == 0 || !isLatin1Digit(num_str.tqunicode()[i - 1]))
+                return FALSE;
+            if (i == num_str.length() + 1 || !isLatin1Digit(num_str.tqunicode()[i + 1]))
+                return FALSE;
+            ++group_cnt;
+        }
+        else if (c.tqunicode() == '.') {
+            // Fail if more than one decimal points
+            if (decpt_idx != -1)
+                return FALSE;
+            decpt_idx = i;
+        } else if (c.tqunicode() == 'e' || c.tqunicode() == 'E') {
+            // an 'e' or 'E' - if we have not encountered a decimal
+            // point, this is where it "is".
+            if (decpt_idx == -1)
+                decpt_idx = i;
+        }
+    }
+
+    // If no group chars, we're done
+    if (group_cnt == 0)
+        return TRUE;
+
+    // No decimal point means that it "is" at the end of the string
+    if (decpt_idx == -1)
+            decpt_idx = num_str.length();
+
+    i = 0;
+    while (i < num_str.length() && group_cnt > 0) {
+            TQChar c = num_str.tqunicode()[i];
+
+        if (c.tqunicode() == ',') {
+            // Don't allow group chars after the decimal point
+            if ((int)i > decpt_idx)
+                return FALSE;
+
+            // Check that it is placed correctly relative to the decpt
+            if ((decpt_idx - i) % 4 != 0)
+                return FALSE;
+
+            // Remove it
+            num_str.remove(i, 1);
+
+            --group_cnt;
+            --decpt_idx; // adjust decpt_idx
+        } else {
+            // Check that we are not missing a separator
+            if ((int)i < decpt_idx && (decpt_idx - i) % 4 == 0)
+                return FALSE;
+            ++i;
+        }
+    }
+
+    return TRUE;
+}
+
+static void stripWhiteSpaceInPlace(TQString &s)
+{
+    uint i = 0;
+    while (i < s.length() && s.tqunicode()[i].isSpace())
+            ++i;
+    if (i > 0)
+            s.remove(0, i);
+
+    i = s.length();
+
+    if (i == 0)
+            return;
+    --i;
+    while (i > 0 && s.tqunicode()[i].isSpace())
+            --i;
+    if (i + 1 < s.length())
+            s.truncate(i + 1);
+}
+
+/*
+    Converts a number in locale to its representation in the C locale.
+    Only has to guarantee that a string that is a correct representation of
+    a number will be converted. If junk is passed in, junk will be passed
+    out and the error will be detected during the actual conversion to a
+    number. We can't detect junk here, since we don't even know the base
+    of the number.
+*/
+bool TQLocalePrivate::numberToCLocale(TQString &l_num,
+                                        GroupSeparatorMode group_sep_mode) const
+{
+    stripWhiteSpaceInPlace(l_num);
+
+    if (l_num.isEmpty())
+        return FALSE;
+
+    for (uint idx = 0; idx < l_num.length(); ++idx) {
+        TQChar c = l_num.ref(idx);
+
+        if (isDigit(c))
+            c = digitToCLocale(zero(), c);
+        else if (c == plus())
+            c = '+';
+        else if (c == minus())
+            c = '-';
+        else if (c == decimal())
+            c = '.';
+        else if (c == group())
+            c = ',';
+        // In several languages group() is the char 0xA0, which looks like a space.
+        // People use a regular space instead of it and complain it doesn't work.
+        else if (group().tqunicode() == 0xA0 && c.tqunicode() == ' ')
+            c = ',';
+        else if (c == exponential() || c == exponential().upper())
+                c = 'e';
+        else if (c == list())
+                c = ';';
+        else if (c == percent())
+            c = '%';
+        else if (c.tqunicode() >= 'A' && c.tqunicode() <= 'Z')
+            c = c.lower();
+        else if (c.tqunicode() >= 'a' && c.tqunicode() <= 'z')
+            ; // do nothing
+        else
+            return FALSE;
+    }
+
+    if (group_sep_mode == ParseGroupSeparators
+                && !removeGroupSeparators(l_num))
+            return FALSE;
+
+    return TRUE;
+}
+
+double TQLocalePrivate::stringToDouble(TQString num,
+                                        bool *ok,
+                                        GroupSeparatorMode group_sep_mode) const
+{
+    if (!numberToCLocale(num, group_sep_mode)) {
+        if (ok != 0)
+            *ok = FALSE;
+        return 0.0;
+    }
+
+    if (ok != 0)
+        *ok = TRUE;
+
+    if (num == "nan")
+        return NAN;
+
+    if (num == "+inf"
+                || num == "inf")
+        return INFINITY;
+
+    if (num == "-inf")
+        return -INFINITY;
+
+    bool _ok;
+    const char *num_buff = num.latin1();
+
+#ifdef TQT_TQLOCALE_USES_FCVT
+    char *endptr;
+    double d = strtod(num_buff, &endptr);
+    _ok = TRUE;
+#else
+    const char *endptr;
+    double d = qstrtod(num_buff, &endptr, &_ok);
+#endif
+
+    if (!_ok || *endptr != '\0') {
+        if (ok != 0)
+            *ok = FALSE;
+        return 0.0;
+    }
+    else
+        return d;
+}
+
+TQ_LLONG TQLocalePrivate::stringToLongLong(TQString num, int base,
+                                    bool *ok,
+                                    GroupSeparatorMode group_sep_mode) const
+{
+    if (!numberToCLocale(num, group_sep_mode)) {
+        if (ok != 0)
+            *ok = FALSE;
+        return 0;
+    }
+
+    bool _ok;
+    const char *endptr;
+    const char *num_buff = num.latin1();
+    TQ_LLONG l = qstrtoll(num_buff, &endptr, base, &_ok);
+
+    if (!_ok || *endptr != '\0') {
+        if (ok != 0)
+            *ok = FALSE;
+        return 0;
+    }
+
+    if (ok != 0)
+        *ok = TRUE;
+    return l;
+}
+
+TQ_ULLONG TQLocalePrivate::stringToUnsLongLong(TQString num, int base,
+                                    bool *ok,
+                                    GroupSeparatorMode group_sep_mode) const
+{
+    if (!numberToCLocale(num, group_sep_mode)) {
+        if (ok != 0)
+            *ok = FALSE;
+        return 0;
+    }
+
+    bool _ok;
+    const char *endptr;
+    const char *num_buff = num.latin1();
+    TQ_ULLONG l = qstrtoull(num_buff, &endptr, base, &_ok);
+
+    if (!_ok || *endptr != '\0') {
+        if (ok != 0)
+            *ok = FALSE;
+        return 0;
+    }
+
+    if (ok != 0)
+        *ok = TRUE;
+    return l;
+}
+
+/*-
+ * Copyright (c) 1992, 1993
+ *        The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *        This product includes software developed by the University of
+ *        California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSETQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+// static char sccsid[] = "@(#)strtouq.c        8.1 (Berkeley) 6/4/93";
+//  "$FreeBSD: src/lib/libc/stdlib/strtoull.c,v 1.5.2.1 2001/03/02 09:45:20 obrien Exp $";
+
+/*
+ * Convert a string to an TQ_ULLONG integer.
+ *
+ * Ignores `locale' stuff.  Assumes that the upper and lower case
+ * alphabets and digits are each contiguous.
+ */
+static TQ_ULLONG qstrtoull(const char *nptr, const char **endptr, register int base, bool *ok)
+{
+    register const char *s = nptr;
+    register TQ_ULLONG acc;
+    register unsigned char c;
+    register TQ_ULLONG qbase, cutoff;
+    register int neg, any, cutlim;
+
+    if (ok != 0)
+        *ok = TRUE;
+
+    /*
+     * See strtoq for comments as to the logic used.
+     */
+    s = nptr;
+    do {
+        c = *s++;
+    } while (isspace(c));
+    if (c == '-') {
+        if (ok != 0)
+            *ok = FALSE;
+        if (endptr != 0)
+            *endptr = s - 1;
+        return 0;
+    } else {
+        neg = 0;
+        if (c == '+')
+            c = *s++;
+    }
+    if ((base == 0 || base == 16) &&
+        c == '0' && (*s == 'x' || *s == 'X')) {
+        c = s[1];
+        s += 2;
+        base = 16;
+    }
+    if (base == 0)
+        base = c == '0' ? 8 : 10;
+    qbase = (unsigned)base;
+    cutoff = (TQ_ULLONG)ULLONG_MAX / qbase;
+    cutlim = (TQ_ULLONG)ULLONG_MAX % qbase;
+    for (acc = 0, any = 0;; c = *s++) {
+        if (!isascii(c))
+            break;
+        if (isdigit(c))
+            c -= '0';
+        else if (isalpha(c))
+            c -= isupper(c) ? 'A' - 10 : 'a' - 10;
+        else
+            break;
+        if (c >= base)
+            break;
+        if (any < 0 || acc > cutoff || (acc == cutoff && c > cutlim))
+            any = -1;
+        else {
+            any = 1;
+            acc *= qbase;
+            acc += c;
+        }
+    }
+    if (any < 0) {
+        acc = ULLONG_MAX;
+        if (ok != 0)
+            *ok = FALSE;
+    }
+    else if (neg)
+        acc = (~acc) + 1;
+    if (endptr != 0)
+        *endptr = (char *)(any ? s - 1 : nptr);
+    return (acc);
+}
+
+
+//  "$FreeBSD: src/lib/libc/stdlib/strtoll.c,v 1.5.2.1 2001/03/02 09:45:20 obrien Exp $";
+
+
+/*
+ * Convert a string to a TQ_LLONG integer.
+ *
+ * Ignores `locale' stuff.  Assumes that the upper and lower case
+ * alphabets and digits are each contiguous.
+ */
+static TQ_LLONG qstrtoll(const char *nptr, const char **endptr, register int base, bool *ok)
+{
+    register const char *s;
+    register TQ_ULLONG acc;
+    register unsigned char c;
+    register TQ_ULLONG qbase, cutoff;
+    register int neg, any, cutlim;
+
+    if (ok != 0)
+        *ok = TRUE;
+
+    /*
+     * Skip white space and pick up leading +/- sign if any.
+     * If base is 0, allow 0x for hex and 0 for octal, else
+     * assume decimal; if base is already 16, allow 0x.
+     */
+    s = nptr;
+    do {
+        c = *s++;
+    } while (isspace(c));
+    if (c == '-') {
+        neg = 1;
+        c = *s++;
+    } else {
+        neg = 0;
+        if (c == '+')
+            c = *s++;
+    }
+    if ((base == 0 || base == 16) &&
+        c == '0' && (*s == 'x' || *s == 'X')) {
+        c = s[1];
+        s += 2;
+        base = 16;
+    }
+    if (base == 0)
+        base = c == '0' ? 8 : 10;
+
+    /*
+     * Compute the cutoff value between legal numbers and illegal
+     * numbers.  That is the largest legal value, divided by the
+     * base.  An input number that is greater than this value, if
+     * followed by a legal input character, is too big.  One that
+     * is equal to this value may be valid or not; the limit
+     * between valid and invalid numbers is then based on the last
+     * digit.  For instance, if the range for quads is
+     * [-9223372036854775808..9223372036854775807] and the input base
+     * is 10, cutoff will be set to 922337203685477580 and cutlim to
+     * either 7 (neg==0) or 8 (neg==1), meaning that if we have
+     * accumulated a value > 922337203685477580, or equal but the
+     * next digit is > 7 (or 8), the number is too big, and we will
+     * return a range error.
+     *
+     * Set any if any `digits' consumed; make it negative to indicate
+     * overflow.
+     */
+    qbase = (unsigned)base;
+    cutoff = neg ? (TQ_ULLONG)-(LLONG_MIN + LLONG_MAX) + LLONG_MAX
+        : LLONG_MAX;
+    cutlim = cutoff % qbase;
+    cutoff /= qbase;
+    for (acc = 0, any = 0;; c = *s++) {
+        if (!isascii(c))
+            break;
+        if (isdigit(c))
+            c -= '0';
+        else if (isalpha(c))
+            c -= isupper(c) ? 'A' - 10 : 'a' - 10;
+        else
+            break;
+        if (c >= base)
+            break;
+        if (any < 0 || acc > cutoff || (acc == cutoff && c > cutlim))
+            any = -1;
+        else {
+            any = 1;
+            acc *= qbase;
+            acc += c;
+        }
+    }
+    if (any < 0) {
+        acc = neg ? LLONG_MIN : LLONG_MAX;
+        if (ok != 0)
+            *ok = FALSE;
+    } else if (neg) {
+        acc = (~acc) + 1;
+    }
+    if (endptr != 0)
+        *endptr = (char *)(any ? s - 1 : nptr);
+    return (acc);
+}
+
+#ifndef TQT_TQLOCALE_USES_FCVT
+
+/*        From: NetBSD: strtod.c,v 1.26 1998/02/03 18:44:21 perry Exp */
+/* $FreeBSD: src/lib/libc/stdlib/netbsd_strtod.c,v 1.2.2.2 2001/03/02 17:14:15 tegge Exp $        */
+
+/* Please send bug reports to
+        David M. Gay
+        AT&T Bell Laboratories, Room 2C-463
+        600 Mountain Avenue
+        Murray Hill, NJ 07974-2070
+        U.S.A.
+        dmg@research.att.com or research!dmg
+ */
+
+/* strtod for IEEE-, VAX-, and IBM-arithmetic machines.
+ *
+ * This strtod returns a nearest machine number to the input decimal
+ * string (or sets errno to ERANGE).  With IEEE arithmetic, ties are
+ * broken by the IEEE round-even rule.  Otherwise ties are broken by
+ * biased rounding (add half and chop).
+ *
+ * Inspired loosely by William D. Clinger's paper "How to Read Floating
+ * Point Numbers Accurately" [Proc. ACM SIGPLAN '90, pp. 92-101].
+ *
+ * Modifications:
+ *
+ *        1. We only require IEEE, IBM, or VAX double-precision
+ *                arithmetic (not IEEE double-extended).
+ *        2. We get by with floating-point arithmetic in a case that
+ *                Clinger missed -- when we're computing d * 10^n
+ *                for a small integer d and the integer n is not too
+ *                much larger than 22 (the maximum integer k for which
+ *                we can represent 10^k exactly), we may be able to
+ *                compute (d*10^k) * 10^(e-k) with just one roundoff.
+ *        3. Rather than a bit-at-a-time adjustment of the binary
+ *                result in the hard case, we use floating-point
+ *                arithmetic to determine the adjustment to within
+ *                one bit; only in really hard cases do we need to
+ *                compute a second residual.
+ *        4. Because of 3., we don't need a large table of powers of 10
+ *                for ten-to-e (just some small tables, e.g. of 10^k
+ *                for 0 <= k <= 22).
+ */
+
+/*
+ * #define IEEE_LITTLE_ENDIAN for IEEE-arithmetic machines where the least
+ *        significant byte has the lowest address.
+ * #define IEEE_BIG_ENDIAN for IEEE-arithmetic machines where the most
+ *        significant byte has the lowest address.
+ * #define Long int on machines with 32-bit ints and 64-bit longs.
+ * #define Sudden_Underflow for IEEE-format machines without gradual
+ *        underflow (i.e., that flush to zero on underflow).
+ * #define IBM for IBM mainframe-style floating-point arithmetic.
+ * #define VAX for VAX-style floating-point arithmetic.
+ * #define Unsigned_Shifts if >> does treats its left operand as unsigned.
+ * #define No_leftright to omit left-right logic in fast floating-point
+ *        computation of dtoa.
+ * #define Check_FLT_ROUNDS if FLT_ROUNDS can assume the values 2 or 3.
+ * #define RND_PRODTQUOT to use rnd_prod and rnd_quot (assembly routines
+ *        that use extended-precision instructions to compute rounded
+ *        products and quotients) with IBM.
+ * #define ROUND_BIASED for IEEE-format with biased rounding.
+ * #define Inaccurate_Divide for IEEE-format with correctly rounded
+ *        products but inaccurate quotients, e.g., for Intel i860.
+ * #define Just_16 to store 16 bits per 32-bit Long when doing high-precision
+ *        integer arithmetic.  Whether this speeds things up or slows things
+ *        down depends on the machine and the number being converted.
+ * #define KR_headers for old-style C function headers.
+ * #define Bad_float_h if your system lacks a float.h or if it does not
+ *        define some or all of DBL_DIG, DBL_MAX_10_EXP, DBL_MAX_EXP,
+ *        FLT_RADIX, FLT_ROUNDS, and DBL_MAX.
+ * #define MALLOC your_malloc, where your_malloc(n) acts like malloc(n)
+ *        if memory is available and otherwise does something you deem
+ *        appropriate.  If MALLOC is undefined, malloc will be invoked
+ *        directly -- and assumed always to succeed.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+__RCSID("$NetBSD: strtod.c,v 1.26 1998/02/03 18:44:21 perry Exp $");
+#endif /* LIBC_SCCS and not lint */
+
+/*
+#if defined(__m68k__)    || defined(__sparc__) || defined(__i386__) || \
+     defined(__mips__)    || defined(__ns32k__) || defined(__alpha__) || \
+     defined(__powerpc__) || defined(TQ_OS_WIN) || defined(TQ_OS_DARWIN) || defined(TQ_OS_MACX) || \
+     defined(mips) || defined(TQ_OS_AIX) || defined(TQ_OS_SOLARIS)
+#           define IEEE_BIG_OR_LITTLE_ENDIAN 1
+#endif
+*/
+
+// *All* of our architectures have IEEE arithmetic, don't they?
+#define IEEE_BIG_OR_LITTLE_ENDIAN 1
+
+#ifdef __arm32__
+/*
+ * Although the CPU is little endian the FP has different
+ * byte and word endianness. The byte order is still little endian
+ * but the word order is big endian.
+ */
+#define IEEE_BIG_OR_LITTLE_ENDIAN
+#endif
+
+#ifdef vax
+#define VAX
+#endif
+
+#define Long        TQ_INT32
+#define ULong        TQ_UINT32
+
+#define MALLOC malloc
+#define CONST const
+
+#ifdef BSD_TQDTOA_DEBUG
+#include <stdio.h>
+#define Bug(x) {fprintf(stderr, "%s\n", x); exit(1);}
+#endif
+
+#ifdef Unsigned_Shifts
+#define Sign_Extend(a,b) if (b < 0) a |= 0xffff0000;
+#else
+#define Sign_Extend(a,b) /*no-op*/
+#endif
+
+#if (defined(IEEE_BIG_OR_LITTLE_ENDIAN) + defined(VAX) + defined(IBM)) != 1
+#error Exactly one of IEEE_BIG_OR_LITTLE_ENDIAN, VAX, or IBM should be defined.
+#endif
+
+inline ULong getWord0(const NEEDS_VOLATILE double x)
+{
+    const NEEDS_VOLATILE uchar *ptr = reinterpret_cast<const NEEDS_VOLATILE uchar *>(&x);
+    if (ByteOrder == BigEndian) {
+        return (ptr[0]<<24) + (ptr[1]<<16) + (ptr[2]<<8) + ptr[3];
+    } else {
+        return (ptr[7]<<24) + (ptr[6]<<16) + (ptr[5]<<8) + ptr[4];
+    }
+}
+
+inline void setWord0(NEEDS_VOLATILE double *x, ULong l)
+{
+    NEEDS_VOLATILE uchar *ptr = reinterpret_cast<NEEDS_VOLATILE uchar *>(x);
+    if (ByteOrder == BigEndian) {
+        ptr[0] = (uchar)(l>>24);
+        ptr[1] = (uchar)(l>>16);
+        ptr[2] = (uchar)(l>>8);
+        ptr[3] = (uchar)l;
+    } else {
+        ptr[7] = (uchar)(l>>24);
+        ptr[6] = (uchar)(l>>16);
+        ptr[5] = (uchar)(l>>8);
+        ptr[4] = (uchar)l;
+    }
+}
+
+inline ULong getWord1(const NEEDS_VOLATILE double x)
+{
+    const NEEDS_VOLATILE uchar *ptr = reinterpret_cast<const NEEDS_VOLATILE uchar *>(&x);
+    if (ByteOrder == BigEndian) {
+        return (ptr[4]<<24) + (ptr[5]<<16) + (ptr[6]<<8) + ptr[7];
+    } else {
+        return (ptr[3]<<24) + (ptr[2]<<16) + (ptr[1]<<8) + ptr[0];
+    }
+}
+inline void setWord1(NEEDS_VOLATILE double *x, ULong l)
+{
+    NEEDS_VOLATILE uchar *ptr = reinterpret_cast<uchar NEEDS_VOLATILE *>(x);
+    if (ByteOrder == BigEndian) {
+        ptr[4] = (uchar)(l>>24);
+        ptr[5] = (uchar)(l>>16);
+        ptr[6] = (uchar)(l>>8);
+        ptr[7] = (uchar)l;
+    } else {
+        ptr[3] = (uchar)(l>>24);
+        ptr[2] = (uchar)(l>>16);
+        ptr[1] = (uchar)(l>>8);
+        ptr[0] = (uchar)l;
+    }
+}
+
+static inline void Storeinc(ULong *&a, const ULong &b, const ULong &c)
+{
+
+    *a = (((unsigned short)b) << 16) | ((unsigned short)c);
+    ++a;
+}
+
+/* #define P DBL_MANT_DIG */
+/* Ten_pmax = floor(P*log(2)/log(5)) */
+/* Bletch = (highest power of 2 < DBL_MAX_10_EXP) / 16 */
+/* Quick_max = floor((P-1)*log(FLT_RADIX)/log(10) - 1) */
+/* Int_max = floor(P*log(FLT_RADIX)/log(10) - 1) */
+
+#if defined(IEEE_BIG_OR_LITTLE_ENDIAN)
+#define Exp_shift  20
+#define Exp_shift1 20
+#define Exp_msk1    0x100000
+#define Exp_msk11   0x100000
+#define Exp_mask  0x7ff00000
+#define P 53
+#define Bias 1023
+#define IEEE_Arith
+#define Emin (-1022)
+#define Exp_1  0x3ff00000
+#define Exp_11 0x3ff00000
+#define Ebits 11
+#define Frac_mask  0xfffff
+#define Frac_mask1 0xfffff
+#define Ten_pmax 22
+#define Bletch 0x10
+#define Bndry_mask  0xfffff
+#define Bndry_mask1 0xfffff
+#define LSB 1
+#define Sign_bit 0x80000000
+#define Log2P 1
+#define Tiny0 0
+#define Tiny1 1
+#define Quick_max 14
+#define Int_max 14
+#define Infinite(x) (getWord0(x) == 0x7ff00000) /* sufficient test for here */
+#else
+#undef  Sudden_Underflow
+#define Sudden_Underflow
+#ifdef IBM
+#define Exp_shift  24
+#define Exp_shift1 24
+#define Exp_msk1   0x1000000
+#define Exp_msk11  0x1000000
+#define Exp_mask  0x7f000000
+#define P 14
+#define Bias 65
+#define Exp_1  0x41000000
+#define Exp_11 0x41000000
+#define Ebits 8        /* exponent has 7 bits, but 8 is the right value in b2d */
+#define Frac_mask  0xffffff
+#define Frac_mask1 0xffffff
+#define Bletch 4
+#define Ten_pmax 22
+#define Bndry_mask  0xefffff
+#define Bndry_mask1 0xffffff
+#define LSB 1
+#define Sign_bit 0x80000000
+#define Log2P 4
+#define Tiny0 0x100000
+#define Tiny1 0
+#define Quick_max 14
+#define Int_max 15
+#else /* VAX */
+#define Exp_shift  23
+#define Exp_shift1 7
+#define Exp_msk1    0x80
+#define Exp_msk11   0x800000
+#define Exp_mask  0x7f80
+#define P 56
+#define Bias 129
+#define Exp_1  0x40800000
+#define Exp_11 0x4080
+#define Ebits 8
+#define Frac_mask  0x7fffff
+#define Frac_mask1 0xffff007f
+#define Ten_pmax 24
+#define Bletch 2
+#define Bndry_mask  0xffff007f
+#define Bndry_mask1 0xffff007f
+#define LSB 0x10000
+#define Sign_bit 0x8000
+#define Log2P 1
+#define Tiny0 0x80
+#define Tiny1 0
+#define Quick_max 15
+#define Int_max 15
+#endif
+#endif
+
+#ifndef IEEE_Arith
+#define ROUND_BIASED
+#endif
+
+#ifdef RND_PRODTQUOT
+#define rounded_product(a,b) a = rnd_prod(a, b)
+#define rounded_quotient(a,b) a = rnd_quot(a, b)
+extern double rnd_prod(double, double), rnd_quot(double, double);
+#else
+#define rounded_product(a,b) a *= b
+#define rounded_quotient(a,b) a /= b
+#endif
+
+#define Big0 (Frac_mask1 | Exp_msk1*(DBL_MAX_EXP+Bias-1))
+#define Big1 0xffffffff
+
+#ifndef Just_16
+/* When Pack_32 is not defined, we store 16 bits per 32-bit Long.
+ * This makes some inner loops simpler and sometimes saves work
+ * during multiplications, but it often seems to make things slightly
+ * slower.  Hence the default is now to store 32 bits per Long.
+ */
+#ifndef Pack_32
+#define Pack_32
+#endif
+#endif
+
+#define Kmax 15
+
+struct
+Bigint {
+    struct Bigint *next;
+    int k, maxwds, sign, wds;
+    ULong x[1];
+};
+
+ typedef struct Bigint Bigint;
+
+static Bigint *Balloc(int k)
+{
+    int x;
+    Bigint *rv;
+
+    x = 1 << k;
+    rv = (Bigint *)MALLOC(sizeof(Bigint) + (x-1)*sizeof(Long));
+    rv->k = k;
+    rv->maxwds = x;
+    rv->sign = rv->wds = 0;
+    return rv;
+}
+
+static void Bfree(Bigint *v)
+{
+    free(v);
+}
+
+#define Bcopy(x,y) memcpy((char *)&x->sign, (char *)&y->sign, \
+y->wds*sizeof(Long) + 2*sizeof(int))
+
+/* multiply by m and add a */
+static Bigint *multadd(Bigint *b, int m, int a)
+{
+    int i, wds;
+    ULong *x, y;
+#ifdef Pack_32
+    ULong xi, z;
+#endif
+    Bigint *b1;
+
+    wds = b->wds;
+    x = b->x;
+    i = 0;
+    do {
+#ifdef Pack_32
+        xi = *x;
+        y = (xi & 0xffff) * m + a;
+        z = (xi >> 16) * m + (y >> 16);
+        a = (int)(z >> 16);
+        *x++ = (z << 16) + (y & 0xffff);
+#else
+        y = *x * m + a;
+        a = (int)(y >> 16);
+        *x++ = y & 0xffff;
+#endif
+    }
+    while(++i < wds);
+    if (a) {
+        if (wds >= b->maxwds) {
+            b1 = Balloc(b->k+1);
+            Bcopy(b1, b);
+            Bfree(b);
+            b = b1;
+        }
+        b->x[wds++] = a;
+        b->wds = wds;
+    }
+    return b;
+}
+
+static Bigint *s2b(CONST char *s, int nd0, int nd, ULong y9)
+{
+    Bigint *b;
+    int i, k;
+    Long x, y;
+
+    x = (nd + 8) / 9;
+    for(k = 0, y = 1; x > y; y <<= 1, k++) ;
+#ifdef Pack_32
+    b = Balloc(k);
+    b->x[0] = y9;
+    b->wds = 1;
+#else
+    b = Balloc(k+1);
+    b->x[0] = y9 & 0xffff;
+    b->wds = (b->x[1] = y9 >> 16) ? 2 : 1;
+#endif
+
+    i = 9;
+    if (9 < nd0) {
+        s += 9;
+        do b = multadd(b, 10, *s++ - '0');
+        while(++i < nd0);
+        s++;
+    }
+    else
+        s += 10;
+    for(; i < nd; i++)
+        b = multadd(b, 10, *s++ - '0');
+    return b;
+}
+
+static int hi0bits(ULong x)
+{
+    int k = 0;
+
+    if (!(x & 0xffff0000)) {
+        k = 16;
+        x <<= 16;
+    }
+    if (!(x & 0xff000000)) {
+        k += 8;
+        x <<= 8;
+    }
+    if (!(x & 0xf0000000)) {
+        k += 4;
+        x <<= 4;
+    }
+    if (!(x & 0xc0000000)) {
+        k += 2;
+        x <<= 2;
+    }
+    if (!(x & 0x80000000)) {
+        k++;
+        if (!(x & 0x40000000))
+            return 32;
+    }
+    return k;
+}
+
+static int lo0bits(ULong *y)
+{
+    int k;
+    ULong x = *y;
+
+    if (x & 7) {
+        if (x & 1)
+            return 0;
+        if (x & 2) {
+            *y = x >> 1;
+            return 1;
+        }
+        *y = x >> 2;
+        return 2;
+    }
+    k = 0;
+    if (!(x & 0xffff)) {
+        k = 16;
+        x >>= 16;
+    }
+    if (!(x & 0xff)) {
+        k += 8;
+        x >>= 8;
+    }
+    if (!(x & 0xf)) {
+        k += 4;
+        x >>= 4;
+    }
+    if (!(x & 0x3)) {
+        k += 2;
+        x >>= 2;
+    }
+    if (!(x & 1)) {
+        k++;
+        x >>= 1;
+        if (!x & 1)
+            return 32;
+    }
+    *y = x;
+    return k;
+}
+
+static Bigint *i2b(int i)
+{
+    Bigint *b;
+
+    b = Balloc(1);
+    b->x[0] = i;
+    b->wds = 1;
+    return b;
+}
+
+static Bigint *mult(Bigint *a, Bigint *b)
+{
+    Bigint *c;
+    int k, wa, wb, wc;
+    ULong carry, y, z;
+    ULong *x, *xa, *xae, *xb, *xbe, *xc, *xc0;
+#ifdef Pack_32
+    ULong z2;
+#endif
+
+    if (a->wds < b->wds) {
+        c = a;
+        a = b;
+        b = c;
+    }
+    k = a->k;
+    wa = a->wds;
+    wb = b->wds;
+    wc = wa + wb;
+    if (wc > a->maxwds)
+        k++;
+    c = Balloc(k);
+    for(x = c->x, xa = x + wc; x < xa; x++)
+        *x = 0;
+    xa = a->x;
+    xae = xa + wa;
+    xb = b->x;
+    xbe = xb + wb;
+    xc0 = c->x;
+#ifdef Pack_32
+    for(; xb < xbe; xb++, xc0++) {
+        if ((y = *xb & 0xffff) != 0) {
+            x = xa;
+            xc = xc0;
+            carry = 0;
+            do {
+                z = (*x & 0xffff) * y + (*xc & 0xffff) + carry;
+                carry = z >> 16;
+                z2 = (*x++ >> 16) * y + (*xc >> 16) + carry;
+                carry = z2 >> 16;
+                Storeinc(xc, z2, z);
+            }
+            while(x < xae);
+            *xc = carry;
+        }
+        if ((y = *xb >> 16) != 0) {
+            x = xa;
+            xc = xc0;
+            carry = 0;
+            z2 = *xc;
+            do {
+                z = (*x & 0xffff) * y + (*xc >> 16) + carry;
+                carry = z >> 16;
+                Storeinc(xc, z, z2);
+                z2 = (*x++ >> 16) * y + (*xc & 0xffff) + carry;
+                carry = z2 >> 16;
+            }
+            while(x < xae);
+            *xc = z2;
+        }
+    }
+#else
+    for(; xb < xbe; xc0++) {
+        if (y = *xb++) {
+            x = xa;
+            xc = xc0;
+            carry = 0;
+            do {
+                z = *x++ * y + *xc + carry;
+                carry = z >> 16;
+                *xc++ = z & 0xffff;
+            }
+            while(x < xae);
+            *xc = carry;
+        }
+    }
+#endif
+    for(xc0 = c->x, xc = xc0 + wc; wc > 0 && !*--xc; --wc) ;
+    c->wds = wc;
+    return c;
+}
+
+static Bigint *p5s;
+
+static Bigint *pow5mult(Bigint *b, int k)
+{
+    Bigint *b1, *p5, *p51;
+    int i;
+    static const int p05[3] = { 5, 25, 125 };
+
+    if ((i = k & 3) != 0)
+        b = multadd(b, p05[i-1], 0);
+
+    if (!(k >>= 2))
+        return b;
+    if (!(p5 = p5s)) {
+        /* first time */
+        p5 = p5s = i2b(625);
+        p5->next = 0;
+    }
+    for(;;) {
+        if (k & 1) {
+            b1 = mult(b, p5);
+            Bfree(b);
+            b = b1;
+        }
+        if (!(k >>= 1))
+            break;
+        if (!(p51 = p5->next)) {
+            p51 = p5->next = mult(p5,p5);
+            p51->next = 0;
+        }
+        p5 = p51;
+    }
+    return b;
+}
+
+static Bigint *lshift(Bigint *b, int k)
+{
+    int i, k1, n, n1;
+    Bigint *b1;
+    ULong *x, *x1, *xe, z;
+
+#ifdef Pack_32
+    n = k >> 5;
+#else
+    n = k >> 4;
+#endif
+    k1 = b->k;
+    n1 = n + b->wds + 1;
+    for(i = b->maxwds; n1 > i; i <<= 1)
+        k1++;
+    b1 = Balloc(k1);
+    x1 = b1->x;
+    for(i = 0; i < n; i++)
+        *x1++ = 0;
+    x = b->x;
+    xe = x + b->wds;
+#ifdef Pack_32
+    if (k &= 0x1f) {
+        k1 = 32 - k;
+        z = 0;
+        do {
+            *x1++ = *x << k | z;
+            z = *x++ >> k1;
+        }
+        while(x < xe);
+        if ((*x1 = z) != 0)
+            ++n1;
+    }
+#else
+    if (k &= 0xf) {
+        k1 = 16 - k;
+        z = 0;
+        do {
+            *x1++ = *x << k  & 0xffff | z;
+            z = *x++ >> k1;
+        }
+        while(x < xe);
+        if (*x1 = z)
+            ++n1;
+    }
+#endif
+    else do
+        *x1++ = *x++;
+    while(x < xe);
+    b1->wds = n1 - 1;
+    Bfree(b);
+    return b1;
+}
+
+static int cmp(Bigint *a, Bigint *b)
+{
+    ULong *xa, *xa0, *xb, *xb0;
+    int i, j;
+
+    i = a->wds;
+    j = b->wds;
+#ifdef BSD_TQDTOA_DEBUG
+    if (i > 1 && !a->x[i-1])
+        Bug("cmp called with a->x[a->wds-1] == 0");
+    if (j > 1 && !b->x[j-1])
+        Bug("cmp called with b->x[b->wds-1] == 0");
+#endif
+    if (i -= j)
+        return i;
+    xa0 = a->x;
+    xa = xa0 + j;
+    xb0 = b->x;
+    xb = xb0 + j;
+    for(;;) {
+        if (*--xa != *--xb)
+            return *xa < *xb ? -1 : 1;
+        if (xa <= xa0)
+            break;
+    }
+    return 0;
+}
+
+static Bigint *diff(Bigint *a, Bigint *b)
+{
+    Bigint *c;
+    int i, wa, wb;
+    Long borrow, y;        /* We need signed shifts here. */
+    ULong *xa, *xae, *xb, *xbe, *xc;
+#ifdef Pack_32
+    Long z;
+#endif
+
+    i = cmp(a,b);
+    if (!i) {
+        c = Balloc(0);
+        c->wds = 1;
+        c->x[0] = 0;
+        return c;
+    }
+    if (i < 0) {
+        c = a;
+        a = b;
+        b = c;
+        i = 1;
+    }
+    else
+        i = 0;
+    c = Balloc(a->k);
+    c->sign = i;
+    wa = a->wds;
+    xa = a->x;
+    xae = xa + wa;
+    wb = b->wds;
+    xb = b->x;
+    xbe = xb + wb;
+    xc = c->x;
+    borrow = 0;
+#ifdef Pack_32
+    do {
+        y = (*xa & 0xffff) - (*xb & 0xffff) + borrow;
+        borrow = y >> 16;
+        Sign_Extend(borrow, y);
+        z = (*xa++ >> 16) - (*xb++ >> 16) + borrow;
+        borrow = z >> 16;
+        Sign_Extend(borrow, z);
+        Storeinc(xc, z, y);
+    }
+    while(xb < xbe);
+    while(xa < xae) {
+        y = (*xa & 0xffff) + borrow;
+        borrow = y >> 16;
+        Sign_Extend(borrow, y);
+        z = (*xa++ >> 16) + borrow;
+        borrow = z >> 16;
+        Sign_Extend(borrow, z);
+        Storeinc(xc, z, y);
+    }
+#else
+    do {
+        y = *xa++ - *xb++ + borrow;
+        borrow = y >> 16;
+        Sign_Extend(borrow, y);
+        *xc++ = y & 0xffff;
+    }
+    while(xb < xbe);
+    while(xa < xae) {
+        y = *xa++ + borrow;
+        borrow = y >> 16;
+        Sign_Extend(borrow, y);
+        *xc++ = y & 0xffff;
+    }
+#endif
+    while(!*--xc)
+        wa--;
+    c->wds = wa;
+    return c;
+}
+
+static double ulp(double x)
+{
+    Long L;
+    double a;
+
+    L = (getWord0(x) & Exp_mask) - (P-1)*Exp_msk1;
+#ifndef Sudden_Underflow
+    if (L > 0) {
+#endif
+#ifdef IBM
+        L |= Exp_msk1 >> 4;
+#endif
+        setWord0(&a, L);
+        setWord1(&a, 0);
+#ifndef Sudden_Underflow
+    }
+    else {
+        L = -L >> Exp_shift;
+        if (L < Exp_shift) {
+            setWord0(&a, 0x80000 >> L);
+            setWord1(&a, 0);
+        }
+        else {
+            setWord0(&a, 0);
+            L -= Exp_shift;
+            setWord1(&a, L >= 31 ? 1U : 1U << (31 - L));
+        }
+    }
+#endif
+    return a;
+}
+
+static double b2d(Bigint *a, int *e)
+{
+    ULong *xa, *xa0, w, y, z;
+    int k;
+    double d;
+
+    xa0 = a->x;
+    xa = xa0 + a->wds;
+    y = *--xa;
+#ifdef BSD_TQDTOA_DEBUG
+    if (!y) Bug("zero y in b2d");
+#endif
+    k = hi0bits(y);
+    *e = 32 - k;
+#ifdef Pack_32
+    if (k < Ebits) {
+        setWord0(&d, Exp_1 | y >> (Ebits - k));
+        w = xa > xa0 ? *--xa : 0;
+        setWord1(&d, y << ((32-Ebits) + k) | w >> (Ebits - k));
+        goto ret_d;
+    }
+    z = xa > xa0 ? *--xa : 0;
+    if (k -= Ebits) {
+        setWord0(&d, Exp_1 | y << k | z >> (32 - k));
+        y = xa > xa0 ? *--xa : 0;
+        setWord1(&d, z << k | y >> (32 - k));
+    }
+    else {
+        setWord0(&d, Exp_1 | y);
+        setWord1(&d, z);
+    }
+#else
+    if (k < Ebits + 16) {
+        z = xa > xa0 ? *--xa : 0;
+        setWord0(&d, Exp_1 | y << k - Ebits | z >> Ebits + 16 - k);
+        w = xa > xa0 ? *--xa : 0;
+        y = xa > xa0 ? *--xa : 0;
+        setWord1(&d, z << k + 16 - Ebits | w << k - Ebits | y >> 16 + Ebits - k);
+        goto ret_d;
+    }
+    z = xa > xa0 ? *--xa : 0;
+    w = xa > xa0 ? *--xa : 0;
+    k -= Ebits + 16;
+    setWord0(&d, Exp_1 | y << k + 16 | z << k | w >> 16 - k);
+    y = xa > xa0 ? *--xa : 0;
+    setWord1(&d, w << k + 16 | y << k);
+#endif
+ ret_d:
+    return d;
+}
+
+static Bigint *d2b(double d, int *e, int *bits)
+{
+    Bigint *b;
+    int de, i, k;
+    ULong *x, y, z;
+
+#ifdef Pack_32
+    b = Balloc(1);
+#else
+    b = Balloc(2);
+#endif
+    x = b->x;
+
+    z = getWord0(d) & Frac_mask;
+    setWord0(&d, getWord0(d) & 0x7fffffff);        /* clear sign bit, which we ignore */
+#ifdef Sudden_Underflow
+    de = (int)(getWord0(d) >> Exp_shift);
+#ifndef IBM
+    z |= Exp_msk11;
+#endif
+#else
+    if ((de = (int)(getWord0(d) >> Exp_shift)) != 0)
+        z |= Exp_msk1;
+#endif
+#ifdef Pack_32
+    if ((y = getWord1(d)) != 0) {
+        if ((k = lo0bits(&y)) != 0) {
+            x[0] = y | z << (32 - k);
+            z >>= k;
+        }
+        else
+            x[0] = y;
+        i = b->wds = (x[1] = z) ? 2 : 1;
+    }
+    else {
+#ifdef BSD_TQDTOA_DEBUG
+        if (!z)
+            Bug("Zero passed to d2b");
+#endif
+        k = lo0bits(&z);
+        x[0] = z;
+        i = b->wds = 1;
+        k += 32;
+    }
+#else
+    if (y = getWord1(d)) {
+        if (k = lo0bits(&y))
+            if (k >= 16) {
+                x[0] = y | z << 32 - k & 0xffff;
+                x[1] = z >> k - 16 & 0xffff;
+                x[2] = z >> k;
+                i = 2;
+            }
+            else {
+                x[0] = y & 0xffff;
+                x[1] = y >> 16 | z << 16 - k & 0xffff;
+                x[2] = z >> k & 0xffff;
+                x[3] = z >> k+16;
+                i = 3;
+            }
+        else {
+            x[0] = y & 0xffff;
+            x[1] = y >> 16;
+            x[2] = z & 0xffff;
+            x[3] = z >> 16;
+            i = 3;
+        }
+    }
+    else {
+#ifdef BSD_TQDTOA_DEBUG
+        if (!z)
+            Bug("Zero passed to d2b");
+#endif
+        k = lo0bits(&z);
+        if (k >= 16) {
+            x[0] = z;
+            i = 0;
+        }
+        else {
+            x[0] = z & 0xffff;
+            x[1] = z >> 16;
+            i = 1;
+        }
+        k += 32;
+    }
+    while(!x[i])
+        --i;
+    b->wds = i + 1;
+#endif
+#ifndef Sudden_Underflow
+    if (de) {
+#endif
+#ifdef IBM
+        *e = (de - Bias - (P-1) << 2) + k;
+        *bits = 4*P + 8 - k - hi0bits(getWord0(d) & Frac_mask);
+#else
+        *e = de - Bias - (P-1) + k;
+        *bits = P - k;
+#endif
+#ifndef Sudden_Underflow
+    }
+    else {
+        *e = de - Bias - (P-1) + 1 + k;
+#ifdef Pack_32
+        *bits = 32*i - hi0bits(x[i-1]);
+#else
+        *bits = (i+2)*16 - hi0bits(x[i]);
+#endif
+    }
+#endif
+    return b;
+}
+
+static double ratio(Bigint *a, Bigint *b)
+{
+    double da, db;
+    int k, ka, kb;
+
+    da = b2d(a, &ka);
+    db = b2d(b, &kb);
+#ifdef Pack_32
+    k = ka - kb + 32*(a->wds - b->wds);
+#else
+    k = ka - kb + 16*(a->wds - b->wds);
+#endif
+#ifdef IBM
+    if (k > 0) {
+        setWord0(&da, getWord0(da) + (k >> 2)*Exp_msk1);
+        if (k &= 3)
+            da *= 1 << k;
+    }
+    else {
+        k = -k;
+        setWord0(&db, getWord0(db) + (k >> 2)*Exp_msk1);
+        if (k &= 3)
+            db *= 1 << k;
+    }
+#else
+    if (k > 0)
+        setWord0(&da, getWord0(da) + k*Exp_msk1);
+    else {
+        k = -k;
+        setWord0(&db, getWord0(db) + k*Exp_msk1);
+    }
+#endif
+    return da / db;
+}
+
+static CONST double tens[] = {
+    1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
+    1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
+    1e20, 1e21, 1e22
+#ifdef VAX
+    , 1e23, 1e24
+#endif
+};
+
+#ifdef IEEE_Arith
+static CONST double bigtens[] = { 1e16, 1e32, 1e64, 1e128, 1e256 };
+static CONST double tinytens[] = { 1e-16, 1e-32, 1e-64, 1e-128, 1e-256 };
+#define n_bigtens 5
+#else
+#ifdef IBM
+static CONST double bigtens[] = { 1e16, 1e32, 1e64 };
+static CONST double tinytens[] = { 1e-16, 1e-32, 1e-64 };
+#define n_bigtens 3
+#else
+static CONST double bigtens[] = { 1e16, 1e32 };
+static CONST double tinytens[] = { 1e-16, 1e-32 };
+#define n_bigtens 2
+#endif
+#endif
+
+/*
+  The pre-release gcc3.3 shipped with SuSE 8.2 has a bug which causes
+  the comparison 1e-100 == 0.0 to return true. As a workaround, we
+  compare it to a global variable containing 0.0, which produces
+  correct assembler output.
+
+  ### consider detecting the broken compilers and using the static
+  ### double for these, and use a #define for all working compilers
+*/
+static double g_double_zero = 0.0;
+
+static double qstrtod(CONST char *s00, CONST char **se, bool *ok)
+{
+    int bb2, bb5, bbe, bd2, bd5, bbbits, bs2, c, dsign,
+        e, e1, esign, i, j, k, nd, nd0, nf, nz, nz0, sign;
+    CONST char *s, *s0, *s1;
+    double aadj, aadj1, adj, rv, rv0;
+    Long L;
+    ULong y, z;
+    Bigint *bb1, *bd0;
+    Bigint *bb = NULL, *bd = NULL, *bs = NULL, *delta = NULL;/* pacify gcc */
+
+    /*
+      #ifndef KR_headers
+      CONST char decimal_point = localeconv()->decimal_point[0];
+      #else
+      CONST char decimal_point = '.';
+      #endif */
+    if (ok != 0)
+        *ok = TRUE;
+
+    CONST char decimal_point = '.';
+
+    sign = nz0 = nz = 0;
+    rv = 0.;
+
+
+    for(s = s00; isspace((unsigned char) *s); s++)
+        ;
+
+    if (*s == '-') {
+        sign = 1;
+        s++;
+    } else if (*s == '+') {
+        s++;
+    }
+
+    if (*s == '\0') {
+        s = s00;
+        goto ret;
+    }
+
+    if (*s == '0') {
+        nz0 = 1;
+        while(*++s == '0') ;
+        if (!*s)
+            goto ret;
+    }
+    s0 = s;
+    y = z = 0;
+    for(nd = nf = 0; (c = *s) >= '0' && c <= '9'; nd++, s++)
+        if (nd < 9)
+            y = 10*y + c - '0';
+        else if (nd < 16)
+            z = 10*z + c - '0';
+    nd0 = nd;
+    if (c == decimal_point) {
+        c = *++s;
+        if (!nd) {
+            for(; c == '0'; c = *++s)
+                nz++;
+            if (c > '0' && c <= '9') {
+                s0 = s;
+                nf += nz;
+                nz = 0;
+                goto have_dig;
+            }
+            goto dig_done;
+        }
+        for(; c >= '0' && c <= '9'; c = *++s) {
+        have_dig:
+            nz++;
+            if (c -= '0') {
+                nf += nz;
+                for(i = 1; i < nz; i++)
+                    if (nd++ < 9)
+                        y *= 10;
+                    else if (nd <= DBL_DIG + 1)
+                        z *= 10;
+                if (nd++ < 9)
+                    y = 10*y + c;
+                else if (nd <= DBL_DIG + 1)
+                    z = 10*z + c;
+                nz = 0;
+            }
+        }
+    }
+ dig_done:
+    e = 0;
+    if (c == 'e' || c == 'E') {
+        if (!nd && !nz && !nz0) {
+            s = s00;
+            goto ret;
+        }
+        s00 = s;
+        esign = 0;
+        switch(c = *++s) {
+        case '-':
+            esign = 1;
+        case '+':
+            c = *++s;
+        }
+        if (c >= '0' && c <= '9') {
+            while(c == '0')
+                c = *++s;
+            if (c > '0' && c <= '9') {
+                L = c - '0';
+                s1 = s;
+                while((c = *++s) >= '0' && c <= '9')
+                    L = 10*L + c - '0';
+                if (s - s1 > 8 || L > 19999)
+                    /* Avoid confusion from exponents
+                     * so large that e might overflow.
+                     */
+                    e = 19999; /* safe for 16 bit ints */
+                else
+                    e = (int)L;
+                if (esign)
+                    e = -e;
+            }
+            else
+                e = 0;
+        }
+        else
+            s = s00;
+    }
+    if (!nd) {
+        if (!nz && !nz0)
+            s = s00;
+        goto ret;
+    }
+    e1 = e -= nf;
+
+    /* Now we have nd0 digits, starting at s0, followed by a
+     * decimal point, followed by nd-nd0 digits.  The number we're
+     * after is the integer represented by those digits times
+     * 10**e */
+
+    if (!nd0)
+        nd0 = nd;
+    k = nd < DBL_DIG + 1 ? nd : DBL_DIG + 1;
+    rv = y;
+    if (k > 9)
+        rv = tens[k - 9] * rv + z;
+    bd0 = 0;
+    if (nd <= DBL_DIG
+#ifndef RND_PRODTQUOT
+        && FLT_ROUNDS == 1
+#endif
+        ) {
+        if (!e)
+            goto ret;
+        if (e > 0) {
+            if (e <= Ten_pmax) {
+#ifdef VAX
+                goto vax_ovfl_check;
+#else
+                /* rv = */ rounded_product(rv, tens[e]);
+                goto ret;
+#endif
+            }
+            i = DBL_DIG - nd;
+            if (e <= Ten_pmax + i) {
+                /* A fancier test would sometimes let us do
+                 * this for larger i values.
+                 */
+                e -= i;
+                rv *= tens[i];
+#ifdef VAX
+                /* VAX exponent range is so narrow we must
+                 * worry about overflow here...
+                 */
+            vax_ovfl_check:
+                setWord0(&rv, getWord0(rv) - P*Exp_msk1);
+                /* rv = */ rounded_product(rv, tens[e]);
+                if ((getWord0(rv) & Exp_mask)
+                    > Exp_msk1*(DBL_MAX_EXP+Bias-1-P))
+                    goto ovfl;
+                setWord0(&rv, getWord0(rv) + P*Exp_msk1);
+#else
+                /* rv = */ rounded_product(rv, tens[e]);
+#endif
+                goto ret;
+            }
+        }
+#ifndef Inaccurate_Divide
+        else if (e >= -Ten_pmax) {
+            /* rv = */ rounded_quotient(rv, tens[-e]);
+            goto ret;
+        }
+#endif
+    }
+    e1 += nd - k;
+
+    /* Get starting approximation = rv * 10**e1 */
+
+    if (e1 > 0) {
+        if ((i = e1 & 15) != 0)
+            rv *= tens[i];
+        if (e1 &= ~15) {
+            if (e1 > DBL_MAX_10_EXP) {
+            ovfl:
+                //                                errno = ERANGE;
+                if (ok != 0)
+                    *ok = FALSE;
+#ifdef __STDC__
+                rv = HUGE_VAL;
+#else
+                /* Can't trust HUGE_VAL */
+#ifdef IEEE_Arith
+                setWord0(&rv, Exp_mask);
+                setWord1(&rv, 0);
+#else
+                setWord0(&rv, Big0);
+                setWord1(&rv, Big1);
+#endif
+#endif
+                if (bd0)
+                    goto retfree;
+                goto ret;
+            }
+            if (e1 >>= 4) {
+                for(j = 0; e1 > 1; j++, e1 >>= 1)
+                    if (e1 & 1)
+                        rv *= bigtens[j];
+                /* The last multiplication could overflow. */
+                setWord0(&rv, getWord0(rv) - P*Exp_msk1);
+                rv *= bigtens[j];
+                if ((z = getWord0(rv) & Exp_mask)
+                    > Exp_msk1*(DBL_MAX_EXP+Bias-P))
+                    goto ovfl;
+                if (z > Exp_msk1*(DBL_MAX_EXP+Bias-1-P)) {
+                    /* set to largest number */
+                    /* (Can't trust DBL_MAX) */
+                    setWord0(&rv, Big0);
+                    setWord1(&rv, Big1);
+                }
+                else
+                    setWord0(&rv, getWord0(rv) + P*Exp_msk1);
+            }
+
+        }
+    }
+    else if (e1 < 0) {
+        e1 = -e1;
+        if ((i = e1 & 15) != 0)
+            rv /= tens[i];
+        if (e1 &= ~15) {
+            e1 >>= 4;
+            if (e1 >= 1 << n_bigtens)
+                goto undfl;
+            for(j = 0; e1 > 1; j++, e1 >>= 1)
+                if (e1 & 1)
+                    rv *= tinytens[j];
+            /* The last multiplication could underflow. */
+            rv0 = rv;
+            rv *= tinytens[j];
+            if (rv == g_double_zero)
+                {
+                    rv = 2.*rv0;
+                    rv *= tinytens[j];
+                    if (rv == g_double_zero)
+                        {
+                        undfl:
+                            rv = 0.;
+                            //                                        errno = ERANGE;
+                            if (ok != 0)
+                                *ok = FALSE;
+                            if (bd0)
+                                goto retfree;
+                            goto ret;
+                        }
+                    setWord0(&rv, Tiny0);
+                    setWord1(&rv, Tiny1);
+                    /* The refinement below will clean
+                     * this approximation up.
+                     */
+                }
+        }
+    }
+
+    /* Now the hard part -- adjusting rv to the correct value.*/
+
+    /* Put digits into bd: true value = bd * 10^e */
+
+    bd0 = s2b(s0, nd0, nd, y);
+
+    for(;;) {
+        bd = Balloc(bd0->k);
+        Bcopy(bd, bd0);
+        bb = d2b(rv, &bbe, &bbbits);        /* rv = bb * 2^bbe */
+        bs = i2b(1);
+
+        if (e >= 0) {
+            bb2 = bb5 = 0;
+            bd2 = bd5 = e;
+        }
+        else {
+            bb2 = bb5 = -e;
+            bd2 = bd5 = 0;
+        }
+        if (bbe >= 0)
+            bb2 += bbe;
+        else
+            bd2 -= bbe;
+        bs2 = bb2;
+#ifdef Sudden_Underflow
+#ifdef IBM
+        j = 1 + 4*P - 3 - bbbits + ((bbe + bbbits - 1) & 3);
+#else
+        j = P + 1 - bbbits;
+#endif
+#else
+        i = bbe + bbbits - 1;        /* logb(rv) */
+        if (i < Emin)        /* denormal */
+            j = bbe + (P-Emin);
+        else
+            j = P + 1 - bbbits;
+#endif
+        bb2 += j;
+        bd2 += j;
+        i = bb2 < bd2 ? bb2 : bd2;
+        if (i > bs2)
+            i = bs2;
+        if (i > 0) {
+            bb2 -= i;
+            bd2 -= i;
+            bs2 -= i;
+        }
+        if (bb5 > 0) {
+            bs = pow5mult(bs, bb5);
+            bb1 = mult(bs, bb);
+            Bfree(bb);
+            bb = bb1;
+        }
+        if (bb2 > 0)
+            bb = lshift(bb, bb2);
+        if (bd5 > 0)
+            bd = pow5mult(bd, bd5);
+        if (bd2 > 0)
+            bd = lshift(bd, bd2);
+        if (bs2 > 0)
+            bs = lshift(bs, bs2);
+        delta = diff(bb, bd);
+        dsign = delta->sign;
+        delta->sign = 0;
+        i = cmp(delta, bs);
+        if (i < 0) {
+            /* Error is less than half an ulp -- check for
+             * special case of mantissa a power of two.
+             */
+            if (dsign || getWord1(rv) || getWord0(rv) & Bndry_mask)
+                break;
+            delta = lshift(delta,Log2P);
+            if (cmp(delta, bs) > 0)
+                goto drop_down;
+            break;
+        }
+        if (i == 0) {
+            /* exactly half-way between */
+            if (dsign) {
+                if ((getWord0(rv) & Bndry_mask1) == Bndry_mask1
+                    &&  getWord1(rv) == 0xffffffff) {
+                    /*boundary case -- increment exponent*/
+                    setWord0(&rv, (getWord0(rv) & Exp_mask)
+                                + Exp_msk1
+#ifdef IBM
+                                | Exp_msk1 >> 4
+#endif
+                                );
+                    setWord1(&rv, 0);
+                    break;
+                }
+            }
+            else if (!(getWord0(rv) & Bndry_mask) && !getWord1(rv)) {
+            drop_down:
+                /* boundary case -- decrement exponent */
+#ifdef Sudden_Underflow
+                L = getWord0(rv) & Exp_mask;
+#ifdef IBM
+                if (L <  Exp_msk1)
+#else
+                    if (L <= Exp_msk1)
+#endif
+                        goto undfl;
+                L -= Exp_msk1;
+#else
+                L = (getWord0(rv) & Exp_mask) - Exp_msk1;
+#endif
+                setWord0(&rv, L | Bndry_mask1);
+                setWord1(&rv, 0xffffffff);
+#ifdef IBM
+                goto cont;
+#else
+                break;
+#endif
+            }
+#ifndef ROUND_BIASED
+            if (!(getWord1(rv) & LSB))
+                break;
+#endif
+            if (dsign)
+                rv += ulp(rv);
+#ifndef ROUND_BIASED
+            else {
+                rv -= ulp(rv);
+#ifndef Sudden_Underflow
+                if (rv == g_double_zero)
+                    goto undfl;
+#endif
+            }
+#endif
+            break;
+        }
+        if ((aadj = ratio(delta, bs)) <= 2.) {
+            if (dsign)
+                aadj = aadj1 = 1.;
+            else if (getWord1(rv) || getWord0(rv) & Bndry_mask) {
+#ifndef Sudden_Underflow
+                if (getWord1(rv) == Tiny1 && !getWord0(rv))
+                    goto undfl;
+#endif
+                aadj = 1.;
+                aadj1 = -1.;
+            }
+            else {
+                /* special case -- power of FLT_RADIX to be */
+                /* rounded down... */
+
+                if (aadj < 2./FLT_RADIX)
+                    aadj = 1./FLT_RADIX;
+                else
+                    aadj *= 0.5;
+                aadj1 = -aadj;
+            }
+        }
+        else {
+            aadj *= 0.5;
+            aadj1 = dsign ? aadj : -aadj;
+#ifdef Check_FLT_ROUNDS
+            switch(FLT_ROUNDS) {
+            case 2: /* towards +infinity */
+                aadj1 -= 0.5;
+                break;
+            case 0: /* towards 0 */
+            case 3: /* towards -infinity */
+                aadj1 += 0.5;
+            }
+#else
+            if (FLT_ROUNDS == 0)
+                aadj1 += 0.5;
+#endif
+        }
+        y = getWord0(rv) & Exp_mask;
+
+        /* Check for overflow */
+
+        if (y == Exp_msk1*(DBL_MAX_EXP+Bias-1)) {
+            rv0 = rv;
+            setWord0(&rv, getWord0(rv) - P*Exp_msk1);
+            adj = aadj1 * ulp(rv);
+            rv += adj;
+            if ((getWord0(rv) & Exp_mask) >=
+                Exp_msk1*(DBL_MAX_EXP+Bias-P)) {
+                if (getWord0(rv0) == Big0 && getWord1(rv0) == Big1)
+                    goto ovfl;
+                setWord0(&rv, Big0);
+                setWord1(&rv, Big1);
+                goto cont;
+            }
+            else
+                setWord0(&rv, getWord0(rv) + P*Exp_msk1);
+        }
+        else {
+#ifdef Sudden_Underflow
+            if ((getWord0(rv) & Exp_mask) <= P*Exp_msk1) {
+                rv0 = rv;
+                setWord0(&rv, getWord0(rv) + P*Exp_msk1);
+                adj = aadj1 * ulp(rv);
+                rv += adj;
+#ifdef IBM
+                if ((getWord0(rv) & Exp_mask) <  P*Exp_msk1)
+#else
+                    if ((getWord0(rv) & Exp_mask) <= P*Exp_msk1)
+#endif
+                        {
+                            if (getWord0(rv0) == Tiny0
+                                && getWord1(rv0) == Tiny1)
+                                goto undfl;
+                            setWord0(&rv, Tiny0);
+                            setWord1(&rv, Tiny1);
+                            goto cont;
+                        }
+                    else
+                        setWord0(&rv, getWord0(rv) - P*Exp_msk1);
+            }
+            else {
+                adj = aadj1 * ulp(rv);
+                rv += adj;
+            }
+#else
+            /* Compute adj so that the IEEE rounding rules will
+             * correctly round rv + adj in some half-way cases.
+             * If rv * ulp(rv) is denormalized (i.e.,
+             * y <= (P-1)*Exp_msk1), we must adjust aadj to avoid
+             * trouble from bits lost to denormalization;
+             * example: 1.2e-307 .
+             */
+            if (y <= (P-1)*Exp_msk1 && aadj >= 1.) {
+                aadj1 = (double)(int)(aadj + 0.5);
+                if (!dsign)
+                    aadj1 = -aadj1;
+            }
+            adj = aadj1 * ulp(rv);
+            rv += adj;
+#endif
+        }
+        z = getWord0(rv) & Exp_mask;
+        if (y == z) {
+            /* Can we stop now? */
+            L = (Long) aadj;
+            aadj -= L;
+            /* The tolerances below are conservative. */
+            if (dsign || getWord1(rv) || getWord0(rv) & Bndry_mask) {
+                if (aadj < .4999999 || aadj > .5000001)
+                    break;
+            }
+            else if (aadj < .4999999/FLT_RADIX)
+                break;
+        }
+    cont:
+        Bfree(bb);
+        Bfree(bd);
+        Bfree(bs);
+        Bfree(delta);
+    }
+ retfree:
+    Bfree(bb);
+    Bfree(bd);
+    Bfree(bs);
+    Bfree(bd0);
+    Bfree(delta);
+ ret:
+    if (se)
+        *se = (char *)s;
+    return sign ? -rv : rv;
+}
+
+static int quorem(Bigint *b, Bigint *S)
+{
+    int n;
+    Long borrow, y;
+    ULong carry, q, ys;
+    ULong *bx, *bxe, *sx, *sxe;
+#ifdef Pack_32
+    Long z;
+    ULong si, zs;
+#endif
+
+    n = S->wds;
+#ifdef BSD_TQDTOA_DEBUG
+    /*debug*/ if (b->wds > n)
+        /*debug*/        Bug("oversize b in quorem");
+#endif
+    if (b->wds < n)
+        return 0;
+    sx = S->x;
+    sxe = sx + --n;
+    bx = b->x;
+    bxe = bx + n;
+    q = *bxe / (*sxe + 1);        /* ensure q <= true quotient */
+#ifdef BSD_TQDTOA_DEBUG
+    /*debug*/ if (q > 9)
+        /*debug*/        Bug("oversized quotient in quorem");
+#endif
+    if (q) {
+        borrow = 0;
+        carry = 0;
+        do {
+#ifdef Pack_32
+            si = *sx++;
+            ys = (si & 0xffff) * q + carry;
+            zs = (si >> 16) * q + (ys >> 16);
+            carry = zs >> 16;
+            y = (*bx & 0xffff) - (ys & 0xffff) + borrow;
+            borrow = y >> 16;
+            Sign_Extend(borrow, y);
+            z = (*bx >> 16) - (zs & 0xffff) + borrow;
+            borrow = z >> 16;
+            Sign_Extend(borrow, z);
+            Storeinc(bx, z, y);
+#else
+            ys = *sx++ * q + carry;
+            carry = ys >> 16;
+            y = *bx - (ys & 0xffff) + borrow;
+            borrow = y >> 16;
+            Sign_Extend(borrow, y);
+            *bx++ = y & 0xffff;
+#endif
+        }
+        while(sx <= sxe);
+        if (!*bxe) {
+            bx = b->x;
+            while(--bxe > bx && !*bxe)
+                --n;
+            b->wds = n;
+        }
+    }
+    if (cmp(b, S) >= 0) {
+        q++;
+        borrow = 0;
+        carry = 0;
+        bx = b->x;
+        sx = S->x;
+        do {
+#ifdef Pack_32
+            si = *sx++;
+            ys = (si & 0xffff) + carry;
+            zs = (si >> 16) + (ys >> 16);
+            carry = zs >> 16;
+            y = (*bx & 0xffff) - (ys & 0xffff) + borrow;
+            borrow = y >> 16;
+            Sign_Extend(borrow, y);
+            z = (*bx >> 16) - (zs & 0xffff) + borrow;
+            borrow = z >> 16;
+            Sign_Extend(borrow, z);
+            Storeinc(bx, z, y);
+#else
+            ys = *sx++ + carry;
+            carry = ys >> 16;
+            y = *bx - (ys & 0xffff) + borrow;
+            borrow = y >> 16;
+            Sign_Extend(borrow, y);
+            *bx++ = y & 0xffff;
+#endif
+        }
+        while(sx <= sxe);
+        bx = b->x;
+        bxe = bx + n;
+        if (!*bxe) {
+            while(--bxe > bx && !*bxe)
+                --n;
+            b->wds = n;
+        }
+    }
+    return q;
+}
+
+/* dtoa for IEEE arithmetic (dmg): convert double to ASCII string.
+ *
+ * Inspired by "How to Print Floating-Point Numbers Accurately" by
+ * Guy L. Steele, Jr. and Jon L. White [Proc. ACM SIGPLAN '90, pp. 92-101].
+ *
+ * Modifications:
+ *        1. Rather than iterating, we use a simple numeric overestimate
+ *           to determine k = floor(log10(d)).  We scale relevant
+ *           quantities using O(log2(k)) rather than O(k) multiplications.
+ *        2. For some modes > 2 (corresponding to ecvt and fcvt), we don't
+ *           try to generate digits strictly left to right.  Instead, we
+ *           compute with fewer bits and propagate the carry if necessary
+ *           when rounding the final digit up.  This is often faster.
+ *        3. Under the assumption that input will be rounded nearest,
+ *           mode 0 renders 1e23 as 1e23 rather than 9.999999999999999e22.
+ *           That is, we allow equality in stopping tests when the
+ *           round-nearest rule will give the same floating-point value
+ *           as would satisfaction of the stopping test with strict
+ *           inequality.
+ *        4. We remove common factors of powers of 2 from relevant
+ *           quantities.
+ *        5. When converting floating-point integers less than 1e16,
+ *           we use floating-point arithmetic rather than resorting
+ *           to multiple-precision integers.
+ *        6. When asked to produce fewer than 15 digits, we first try
+ *           to get by with floating-point arithmetic; we resort to
+ *           multiple-precision integer arithmetic only if we cannot
+ *           guarantee that the floating-point calculation has given
+ *           the correctly rounded result.  For k requested digits and
+ *           "uniformly" distributed input, the probability is
+ *           something like 10^(k-15) that we must resort to the Long
+ *           calculation.
+ */
+
+
+/* This actually sometimes returns a pointer to a string literal
+   cast to a char*. Do NOT try to modify the return value. */
+
+static char *qdtoa ( double d, int mode, int ndigits, int *decpt, int *sign, char **rve, char **resultp)
+{
+    // Some values of the floating-point control word can cause _qdtoa to crash with an underflow.
+    // We set a safe value here.
+#ifdef TQ_OS_WIN
+#ifndef TQ_CC_BOR
+    unsigned int oldbits = _control87(0, 0);
+#ifndef _M_X64 //x64 does not support precition control
+    _control87(0x9001F, 0xFFFFF);
+#else
+    _control87(0x9001F, _MCW_DN|_MCW_EM|_MCW_RC);
+#endif //_M_X64
+#endif
+#endif
+
+#ifdef TQ_OS_LINUX
+    fenv_t envp;
+    feholdexcept(&envp);
+#endif
+
+    char *s = _qdtoa(d, mode, ndigits, decpt, sign, rve, resultp);
+
+#ifdef TQ_OS_WIN
+#ifndef TQ_CC_BOR
+    _clear87();
+#ifndef _M_X64
+    _control87(oldbits, 0xFFFFF);
+#else
+    _control87(oldbits, _MCW_DN|_MCW_EM|_MCW_RC);
+#endif //_M_X64
+#endif
+#endif
+
+#ifdef TQ_OS_LINUX
+    fesetenv(&envp);
+#endif
+
+    return s;
+}
+
+static char *_qdtoa( NEEDS_VOLATILE double d, int mode, int ndigits, int *decpt, int *sign, char **rve, char **resultp)
+{
+    /*
+      Arguments ndigits, decpt, sign are similar to those
+      of ecvt and fcvt; trailing zeros are suppressed from
+      the returned string.  If not null, *rve is set to point
+      to the end of the return value.  If d is +-Infinity or NaN,
+      then *decpt is set to 9999.
+
+      mode:
+      0 ==> shortest string that yields d when read in
+      and rounded to nearest.
+      1 ==> like 0, but with Steele & White stopping rule;
+      e.g. with IEEE P754 arithmetic , mode 0 gives
+      1e23 whereas mode 1 gives 9.999999999999999e22.
+      2 ==> max(1,ndigits) significant digits.  This gives a
+      return value similar to that of ecvt, except
+      that trailing zeros are suppressed.
+      3 ==> through ndigits past the decimal point.  This
+      gives a return value similar to that from fcvt,
+      except that trailing zeros are suppressed, and
+      ndigits can be negative.
+      4-9 should give the same return values as 2-3, i.e.,
+      4 <= mode <= 9 ==> same return as mode
+      2 + (mode & 1).  These modes are mainly for
+      debugging; often they run slower but sometimes
+      faster than modes 2-3.
+      4,5,8,9 ==> left-to-right digit generation.
+      6-9 ==> don't try fast floating-point estimate
+      (if applicable).
+
+      Values of mode other than 0-9 are treated as mode 0.
+
+      Sufficient space is allocated to the return value
+      to hold the suppressed trailing zeros.
+    */
+
+    int bbits, b2, b5, be, dig, i, ieps, ilim0,
+        j, j1, k, k0, k_check, leftright, m2, m5, s2, s5,
+        try_quick;
+    int ilim = 0, ilim1 = 0, spec_case = 0;        /* pacify gcc */
+    Long L;
+#ifndef Sudden_Underflow
+    int denorm;
+    ULong x;
+#endif
+    Bigint *b, *b1, *delta, *mhi, *S;
+    Bigint *mlo = NULL; /* pacify gcc */
+    double d2;
+    double ds, eps;
+    char *s, *s0;
+
+    if (getWord0(d) & Sign_bit) {
+        /* set sign for everything, including 0's and NaNs */
+        *sign = 1;
+        setWord0(&d, getWord0(d) & ~Sign_bit);        /* clear sign bit */
+    }
+    else
+        *sign = 0;
+
+#if defined(IEEE_Arith) + defined(VAX)
+#ifdef IEEE_Arith
+    if ((getWord0(d) & Exp_mask) == Exp_mask)
+#else
+        if (getWord0(d)  == 0x8000)
+#endif
+            {
+                /* Infinity or NaN */
+                *decpt = 9999;
+                s =
+#ifdef IEEE_Arith
+                    !getWord1(d) && !(getWord0(d) & 0xfffff) ? (char*)"Infinity" :
+#endif
+                    (char*)"NaN";
+                if (rve)
+                    *rve =
+#ifdef IEEE_Arith
+                        s[3] ? s + 8 :
+#endif
+                        s + 3;
+                return s;
+            }
+#endif
+#ifdef IBM
+    d += 0; /* normalize */
+#endif
+    if (d == g_double_zero)
+        {
+            *decpt = 1;
+            s = (char*) "0";
+            if (rve)
+                *rve = s + 1;
+            return s;
+        }
+
+    b = d2b(d, &be, &bbits);
+#ifdef Sudden_Underflow
+    i = (int)(getWord0(d) >> Exp_shift1 & (Exp_mask>>Exp_shift1));
+#else
+    if ((i = (int)(getWord0(d) >> Exp_shift1 & (Exp_mask>>Exp_shift1))) != 0) {
+#endif
+        d2 = d;
+        setWord0(&d2, getWord0(d2) & Frac_mask1);
+        setWord0(&d2, getWord0(d2) | Exp_11);
+#ifdef IBM
+        if (j = 11 - hi0bits(getWord0(d2) & Frac_mask))
+            d2 /= 1 << j;
+#endif
+
+        /* log(x)        ~=~ log(1.5) + (x-1.5)/1.5
+         * log10(x)         =  log(x) / log(10)
+         *                ~=~ log(1.5)/log(10) + (x-1.5)/(1.5*log(10))
+         * log10(d) = (i-Bias)*log(2)/log(10) + log10(d2)
+         *
+         * This suggests computing an approximation k to log10(d) by
+         *
+         * k = (i - Bias)*0.301029995663981
+         *        + ( (d2-1.5)*0.289529654602168 + 0.176091259055681 );
+         *
+         * We want k to be too large rather than too small.
+         * The error in the first-order Taylor series approximation
+         * is in our favor, so we just round up the constant enough
+         * to compensate for any error in the multiplication of
+         * (i - Bias) by 0.301029995663981; since |i - Bias| <= 1077,
+         * and 1077 * 0.30103 * 2^-52 ~=~ 7.2e-14,
+         * adding 1e-13 to the constant term more than suffices.
+         * Hence we adjust the constant term to 0.1760912590558.
+         * (We could get a more accurate k by invoking log10,
+         *  but this is probably not worthwhile.)
+         */
+
+        i -= Bias;
+#ifdef IBM
+        i <<= 2;
+        i += j;
+#endif
+#ifndef Sudden_Underflow
+        denorm = 0;
+    }
+    else {
+        /* d is denormalized */
+
+        i = bbits + be + (Bias + (P-1) - 1);
+        x = i > 32  ? getWord0(d) << (64 - i) | getWord1(d) >> (i - 32)
+            : getWord1(d) << (32 - i);
+        d2 = x;
+        setWord0(&d2, getWord0(d2) - 31*Exp_msk1); /* adjust exponent */
+        i -= (Bias + (P-1) - 1) + 1;
+        denorm = 1;
+    }
+#endif
+    ds = (d2-1.5)*0.289529654602168 + 0.1760912590558 + i*0.301029995663981;
+    k = (int)ds;
+    if (ds < 0. && ds != k)
+        k--;        /* want k = floor(ds) */
+    k_check = 1;
+    if (k >= 0 && k <= Ten_pmax) {
+        if (d < tens[k])
+            k--;
+        k_check = 0;
+    }
+    j = bbits - i - 1;
+    if (j >= 0) {
+        b2 = 0;
+        s2 = j;
+    }
+    else {
+        b2 = -j;
+        s2 = 0;
+    }
+    if (k >= 0) {
+        b5 = 0;
+        s5 = k;
+        s2 += k;
+    }
+    else {
+        b2 -= k;
+        b5 = -k;
+        s5 = 0;
+    }
+    if (mode < 0 || mode > 9)
+        mode = 0;
+    try_quick = 1;
+    if (mode > 5) {
+        mode -= 4;
+        try_quick = 0;
+    }
+    leftright = 1;
+    switch(mode) {
+    case 0:
+    case 1:
+        ilim = ilim1 = -1;
+        i = 18;
+        ndigits = 0;
+        break;
+    case 2:
+        leftright = 0;
+        /* no break */
+    case 4:
+        if (ndigits <= 0)
+            ndigits = 1;
+        ilim = ilim1 = i = ndigits;
+        break;
+    case 3:
+        leftright = 0;
+        /* no break */
+    case 5:
+        i = ndigits + k + 1;
+        ilim = i;
+        ilim1 = i - 1;
+        if (i <= 0)
+            i = 1;
+    }
+    *resultp = (char *) malloc(i + 1);
+    s = s0 = *resultp;
+
+    if (ilim >= 0 && ilim <= Quick_max && try_quick) {
+
+        /* Try to get by with floating-point arithmetic. */
+
+        i = 0;
+        d2 = d;
+        k0 = k;
+        ilim0 = ilim;
+        ieps = 2; /* conservative */
+        if (k > 0) {
+            ds = tens[k&0xf];
+            j = k >> 4;
+            if (j & Bletch) {
+                /* prevent overflows */
+                j &= Bletch - 1;
+                d /= bigtens[n_bigtens-1];
+                ieps++;
+            }
+            for(; j; j >>= 1, i++)
+                if (j & 1) {
+                    ieps++;
+                    ds *= bigtens[i];
+                }
+            d /= ds;
+        }
+        else if ((j1 = -k) != 0) {
+            d *= tens[j1 & 0xf];
+            for(j = j1 >> 4; j; j >>= 1, i++)
+                if (j & 1) {
+                    ieps++;
+                    d *= bigtens[i];
+                }
+        }
+        if (k_check && d < 1. && ilim > 0) {
+            if (ilim1 <= 0)
+                goto fast_failed;
+            ilim = ilim1;
+            k--;
+            d *= 10.;
+            ieps++;
+        }
+        eps = ieps*d + 7.;
+        setWord0(&eps, getWord0(eps) - (P-1)*Exp_msk1);
+        if (ilim == 0) {
+            S = mhi = 0;
+            d -= 5.;
+            if (d > eps)
+                goto one_digit;
+            if (d < -eps)
+                goto no_digits;
+            goto fast_failed;
+        }
+#ifndef No_leftright
+        if (leftright) {
+            /* Use Steele & White method of only
+             * generating digits needed.
+             */
+            eps = 0.5/tens[ilim-1] - eps;
+            for(i = 0;;) {
+                L = (Long)d;
+                d -= L;
+                *s++ = '0' + (int)L;
+                if (d < eps)
+                    goto ret1;
+                if (1. - d < eps)
+                    goto bump_up;
+                if (++i >= ilim)
+                    break;
+                eps *= 10.;
+                d *= 10.;
+            }
+        }
+        else {
+#endif
+            /* Generate ilim digits, then fix them up. */
+            eps *= tens[ilim-1];
+            for(i = 1;; i++, d *= 10.) {
+                L = (Long)d;
+                d -= L;
+                *s++ = '0' + (int)L;
+                if (i == ilim) {
+                    if (d > 0.5 + eps)
+                        goto bump_up;
+                    else if (d < 0.5 - eps) {
+                        while(*--s == '0');
+                        s++;
+                        goto ret1;
+                    }
+                    break;
+                }
+            }
+#ifndef No_leftright
+        }
+#endif
+    fast_failed:
+        s = s0;
+        d = d2;
+        k = k0;
+        ilim = ilim0;
+    }
+
+    /* Do we have a "small" integer? */
+
+    if (be >= 0 && k <= Int_max) {
+        /* Yes. */
+        ds = tens[k];
+        if (ndigits < 0 && ilim <= 0) {
+            S = mhi = 0;
+            if (ilim < 0 || d <= 5*ds)
+                goto no_digits;
+            goto one_digit;
+        }
+        for(i = 1;; i++) {
+            L = (Long)(d / ds);
+            d -= L*ds;
+#ifdef Check_FLT_ROUNDS
+            /* If FLT_ROUNDS == 2, L will usually be high by 1 */
+            if (d < 0) {
+                L--;
+                d += ds;
+            }
+#endif
+            *s++ = '0' + (int)L;
+            if (i == ilim) {
+                d += d;
+                if (d > ds || (d == ds && L & 1)) {
+                bump_up:
+                    while(*--s == '9')
+                        if (s == s0) {
+                            k++;
+                            *s = '0';
+                            break;
+                        }
+                    ++*s++;
+                }
+                break;
+            }
+            if ((d *= 10.) == g_double_zero)
+                break;
+        }
+        goto ret1;
+    }
+
+    m2 = b2;
+    m5 = b5;
+    mhi = mlo = 0;
+    if (leftright) {
+        if (mode < 2) {
+            i =
+#ifndef Sudden_Underflow
+                denorm ? be + (Bias + (P-1) - 1 + 1) :
+#endif
+#ifdef IBM
+                1 + 4*P - 3 - bbits + ((bbits + be - 1) & 3);
+#else
+            1 + P - bbits;
+#endif
+        }
+        else {
+            j = ilim - 1;
+            if (m5 >= j)
+                m5 -= j;
+            else {
+                s5 += j -= m5;
+                b5 += j;
+                m5 = 0;
+            }
+            if ((i = ilim) < 0) {
+                m2 -= i;
+                i = 0;
+            }
+        }
+        b2 += i;
+        s2 += i;
+        mhi = i2b(1);
+    }
+    if (m2 > 0 && s2 > 0) {
+        i = m2 < s2 ? m2 : s2;
+        b2 -= i;
+        m2 -= i;
+        s2 -= i;
+    }
+    if (b5 > 0) {
+        if (leftright) {
+            if (m5 > 0) {
+                mhi = pow5mult(mhi, m5);
+                b1 = mult(mhi, b);
+                Bfree(b);
+                b = b1;
+            }
+            if ((j = b5 - m5) != 0)
+                b = pow5mult(b, j);
+        }
+        else
+            b = pow5mult(b, b5);
+    }
+    S = i2b(1);
+    if (s5 > 0)
+        S = pow5mult(S, s5);
+
+    /* Check for special case that d is a normalized power of 2. */
+
+    if (mode < 2) {
+        if (!getWord1(d) && !(getWord0(d) & Bndry_mask)
+#ifndef Sudden_Underflow
+            && getWord0(d) & Exp_mask
+#endif
+            ) {
+            /* The special case */
+            b2 += Log2P;
+            s2 += Log2P;
+            spec_case = 1;
+        }
+        else
+            spec_case = 0;
+    }
+
+    /* Arrange for convenient computation of quotients:
+     * shift left if necessary so divisor has 4 leading 0 bits.
+     *
+     * Perhaps we should just compute leading 28 bits of S once
+     * and for all and pass them and a shift to quorem, so it
+     * can do shifts and ors to compute the numerator for q.
+     */
+#ifdef Pack_32
+    if ((i = ((s5 ? 32 - hi0bits(S->x[S->wds-1]) : 1) + s2) & 0x1f) != 0)
+        i = 32 - i;
+#else
+    if (i = ((s5 ? 32 - hi0bits(S->x[S->wds-1]) : 1) + s2) & 0xf)
+        i = 16 - i;
+#endif
+    if (i > 4) {
+        i -= 4;
+        b2 += i;
+        m2 += i;
+        s2 += i;
+    }
+    else if (i < 4) {
+        i += 28;
+        b2 += i;
+        m2 += i;
+        s2 += i;
+    }
+    if (b2 > 0)
+        b = lshift(b, b2);
+    if (s2 > 0)
+        S = lshift(S, s2);
+    if (k_check) {
+        if (cmp(b,S) < 0) {
+            k--;
+            b = multadd(b, 10, 0);        /* we botched the k estimate */
+            if (leftright)
+                mhi = multadd(mhi, 10, 0);
+            ilim = ilim1;
+        }
+    }
+    if (ilim <= 0 && mode > 2) {
+        if (ilim < 0 || cmp(b,S = multadd(S,5,0)) <= 0) {
+            /* no digits, fcvt style */
+        no_digits:
+            k = -1 - ndigits;
+            goto ret;
+        }
+    one_digit:
+        *s++ = '1';
+        k++;
+        goto ret;
+    }
+    if (leftright) {
+        if (m2 > 0)
+            mhi = lshift(mhi, m2);
+
+        /* Compute mlo -- check for special case
+         * that d is a normalized power of 2.
+         */
+
+        mlo = mhi;
+        if (spec_case) {
+            mhi = Balloc(mhi->k);
+            Bcopy(mhi, mlo);
+            mhi = lshift(mhi, Log2P);
+        }
+
+        for(i = 1;;i++) {
+            dig = quorem(b,S) + '0';
+            /* Do we yet have the shortest decimal string
+             * that will round to d?
+             */
+            j = cmp(b, mlo);
+            delta = diff(S, mhi);
+            j1 = delta->sign ? 1 : cmp(b, delta);
+            Bfree(delta);
+#ifndef ROUND_BIASED
+            if (j1 == 0 && !mode && !(getWord1(d) & 1)) {
+                if (dig == '9')
+                    goto round_9_up;
+                if (j > 0)
+                    dig++;
+                *s++ = dig;
+                goto ret;
+            }
+#endif
+            if (j < 0 || (j == 0 && !mode
+#ifndef ROUND_BIASED
+                          && !(getWord1(d) & 1)
+#endif
+                          )) {
+                if (j1 > 0) {
+                    b = lshift(b, 1);
+                    j1 = cmp(b, S);
+                    if ((j1 > 0 || (j1 == 0 && dig & 1))
+                        && dig++ == '9')
+                        goto round_9_up;
+                }
+                *s++ = dig;
+                goto ret;
+            }
+            if (j1 > 0) {
+                if (dig == '9') { /* possible if i == 1 */
+                round_9_up:
+                    *s++ = '9';
+                    goto roundoff;
+                }
+                *s++ = dig + 1;
+                goto ret;
+            }
+            *s++ = dig;
+            if (i == ilim)
+                break;
+            b = multadd(b, 10, 0);
+            if (mlo == mhi)
+                mlo = mhi = multadd(mhi, 10, 0);
+            else {
+                mlo = multadd(mlo, 10, 0);
+                mhi = multadd(mhi, 10, 0);
+            }
+        }
+    }
+    else
+        for(i = 1;; i++) {
+            *s++ = dig = quorem(b,S) + '0';
+            if (i >= ilim)
+                break;
+            b = multadd(b, 10, 0);
+        }
+
+    /* Round off last digit */
+
+    b = lshift(b, 1);
+    j = cmp(b, S);
+    if (j > 0 || (j == 0 && dig & 1)) {
+    roundoff:
+        while(*--s == '9')
+            if (s == s0) {
+                k++;
+                *s++ = '1';
+                goto ret;
+            }
+        ++*s++;
+    }
+    else {
+        while(*--s == '0');
+        s++;
+    }
+ ret:
+    Bfree(S);
+    if (mhi) {
+        if (mlo && mlo != mhi)
+            Bfree(mlo);
+        Bfree(mhi);
+    }
+ ret1:
+    Bfree(b);
+    if (s == s0) {                                /* don't return empty string */
+        *s++ = '0';
+        k = 0;
+    }
+    *s = 0;
+    *decpt = k + 1;
+    if (rve)
+        *rve = s;
+    return s0;
+}
+
+#endif // TQT_TQLOCALE_USES_FCVT
diff --git a/tqtinterface/qt4/src/tools/tqlocale.h b/tqtinterface/qt4/src/tools/tqlocale.h
new file mode 100644
index 0000000..362f317
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqlocale.h
@@ -0,0 +1,494 @@
+/****************************************************************************
+**
+** Declaration of the TQLocale class
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQLOCALE_H
+#define TQLOCALE_H
+
+#include "tqstring.h"
+
+struct TQLocalePrivate;
+
+class TQ_EXPORT TQLocale
+{
+    friend class TQString;
+
+public:
+    enum Language {
+        C = 1,
+        Abkhazian = 2,
+        Afan = 3,
+        Afar = 4,
+        Afrikaans = 5,
+        Albanian = 6,
+        Amharic = 7,
+        Arabic = 8,
+        Armenian = 9,
+        Assamese = 10,
+        Aymara = 11,
+        Azerbaijani = 12,
+        Bashkir = 13,
+        Basque = 14,
+        Bengali = 15,
+        Bhutani = 16,
+        Bihari = 17,
+        Bislama = 18,
+        Breton = 19,
+        Bulgarian = 20,
+        Burmese = 21,
+        Byelorussian = 22,
+        Cambodian = 23,
+        Catalan = 24,
+        Chinese = 25,
+        Corsican = 26,
+        Croatian = 27,
+        Czech = 28,
+        Danish = 29,
+        Dutch = 30,
+        English = 31,
+        Esperanto = 32,
+        Estonian = 33,
+        Faroese = 34,
+        FijiLanguage = 35,
+        Finnish = 36,
+        French = 37,
+        Frisian = 38,
+        Gaelic = 39,
+        Galician = 40,
+        Georgian = 41,
+        German = 42,
+        Greek = 43,
+        Greenlandic = 44,
+        Guarani = 45,
+        Gujarati = 46,
+        Hausa = 47,
+        Hebrew = 48,
+        Hindi = 49,
+        Hungarian = 50,
+        Icelandic = 51,
+        Indonesian = 52,
+        Interlingua = 53,
+        Interlingue = 54,
+        Inuktitut = 55,
+        Inupiak = 56,
+        Irish = 57,
+        Italian = 58,
+        Japanese = 59,
+        Javanese = 60,
+        Kannada = 61,
+        Kashmiri = 62,
+        Kazakh = 63,
+        Kinyarwanda = 64,
+        Kirghiz = 65,
+        Korean = 66,
+        Kurdish = 67,
+        Kurundi = 68,
+        Laothian = 69,
+        Latin = 70,
+        Latvian = 71,
+        Lingala = 72,
+        Lithuanian = 73,
+        Macedonian = 74,
+        Malagasy = 75,
+        Malay = 76,
+        Malayalam = 77,
+        Maltese = 78,
+        Maori = 79,
+        Marathi = 80,
+        Moldavian = 81,
+        Mongolian = 82,
+        NauruLanguage = 83,
+        Nepali = 84,
+        Norwegian = 85,
+        Occitan = 86,
+        Oriya = 87,
+        Pashto = 88,
+        Persian = 89,
+        Polish = 90,
+        Portuguese = 91,
+        Punjabi = 92,
+        Quechua = 93,
+        RhaetoRomance = 94,
+        Romanian = 95,
+        Russian = 96,
+        Samoan = 97,
+        Sangho = 98,
+        Sanskrit = 99,
+        Serbian = 100,
+        SerboCroatian = 101,
+        Sesotho = 102,
+        Setswana = 103,
+        Shona = 104,
+        Sindhi = 105,
+        Singhalese = 106,
+        Siswati = 107,
+        Slovak = 108,
+        Slovenian = 109,
+        Somali = 110,
+        Spanish = 111,
+        Sundanese = 112,
+        Swahili = 113,
+        Swedish = 114,
+        Tagalog = 115,
+        Tajik = 116,
+        Tamil = 117,
+        Tatar = 118,
+        Telugu = 119,
+        Thai = 120,
+        Tibetan = 121,
+        Tigrinya = 122,
+        TongaLanguage = 123,
+        Tsonga = 124,
+        Turkish = 125,
+        Turkmen = 126,
+        Twi = 127,
+        Uigur = 128,
+        Ukrainian = 129,
+        Urdu = 130,
+        Uzbek = 131,
+        Vietnamese = 132,
+        Volapuk = 133,
+        Welsh = 134,
+        Wolof = 135,
+        Xhosa = 136,
+        Yiddish = 137,
+        Yoruba = 138,
+        Zhuang = 139,
+        Zulu = 140,
+        LastLanguage = Zulu
+    };
+
+    enum Country {
+        AnyCountry = 0,
+        Afghanistan = 1,
+        Albania = 2,
+        Algeria = 3,
+        AmericanSamoa = 4,
+        Andorra = 5,
+        Angola = 6,
+        Anguilla = 7,
+        Antarctica = 8,
+        AntiguaAndBarbuda = 9,
+        Argentina = 10,
+        Armenia = 11,
+        Aruba = 12,
+        Australia = 13,
+        Austria = 14,
+        Azerbaijan = 15,
+        Bahamas = 16,
+        Bahrain = 17,
+        Bangladesh = 18,
+        Barbados = 19,
+        Belarus = 20,
+        Belgium = 21,
+        Belize = 22,
+        Benin = 23,
+        Bermuda = 24,
+        Bhutan = 25,
+        Bolivia = 26,
+        BosniaAndHerzegowina = 27,
+        Botswana = 28,
+        BouvetIsland = 29,
+        Brazil = 30,
+        BritishIndianOceanTerritory = 31,
+        BruneiDarussalam = 32,
+        Bulgaria = 33,
+        BurkinaFaso = 34,
+        Burundi = 35,
+        Cambodia = 36,
+        Cameroon = 37,
+        Canada = 38,
+        CapeVerde = 39,
+        CaymanIslands = 40,
+        CentralAfricanRepublic = 41,
+        Chad = 42,
+        Chile = 43,
+        China = 44,
+        ChristmasIsland = 45,
+        CocosIslands = 46,
+        Colombia = 47,
+        Comoros = 48,
+        DetqmocraticRepublicOfCongo = 49,
+        PeoplesRepublicOfCongo = 50,
+        CookIslands = 51,
+        CostaRica = 52,
+        IvoryCoast = 53,
+        Croatia = 54,
+        Cuba = 55,
+        Cyprus = 56,
+        CzechRepublic = 57,
+        Denmark = 58,
+        Djibouti = 59,
+        Dominica = 60,
+        DominicanRepublic = 61,
+        EastTimor = 62,
+        Ecuador = 63,
+        Egypt = 64,
+        ElSalvador = 65,
+        EquatorialGuinea = 66,
+        Eritrea = 67,
+        Estonia = 68,
+        Ethiopia = 69,
+        FalklandIslands = 70,
+        FaroeIslands = 71,
+        FijiCountry = 72,
+        Finland = 73,
+        France = 74,
+        MetropolitanFrance = 75,
+        FrenchGuiana = 76,
+        FrenchPolynesia = 77,
+        FrenchSouthernTerritories = 78,
+        Gabon = 79,
+        Gambia = 80,
+        Georgia = 81,
+        Germany = 82,
+        Ghana = 83,
+        Gibraltar = 84,
+        Greece = 85,
+        Greenland = 86,
+        Grenada = 87,
+        Guadeloupe = 88,
+        Guam = 89,
+        Guatemala = 90,
+        Guinea = 91,
+        GuineaBissau = 92,
+        Guyana = 93,
+        Haiti = 94,
+        HeardAndMcDonaldIslands = 95,
+        Honduras = 96,
+        HongKong = 97,
+        Hungary = 98,
+        Iceland = 99,
+        India = 100,
+        Indonesia = 101,
+        Iran = 102,
+        Iraq = 103,
+        Ireland = 104,
+        Israel = 105,
+        Italy = 106,
+        Jamaica = 107,
+        Japan = 108,
+        Jordan = 109,
+        Kazakhstan = 110,
+        Kenya = 111,
+        Kiribati = 112,
+        DetqmocraticRepublicOfKorea = 113,
+        RepublicOfKorea = 114,
+        Kuwait = 115,
+        Kyrgyzstan = 116,
+        Lao = 117,
+        Latvia = 118,
+        Lebanon = 119,
+        Lesotho = 120,
+        Liberia = 121,
+        LibyanArabJamahiriya = 122,
+        Liechtenstein = 123,
+        Lithuania = 124,
+        Luxembourg = 125,
+        Macau = 126,
+        Macedonia = 127,
+        Madagascar = 128,
+        Malawi = 129,
+        Malaysia = 130,
+        Maldives = 131,
+        Mali = 132,
+        Malta = 133,
+        MarshallIslands = 134,
+        Martinique = 135,
+        Mauritania = 136,
+        Mauritius = 137,
+        Mayotte = 138,
+        Mexico = 139,
+        Micronesia = 140,
+        Moldova = 141,
+        Monaco = 142,
+        Mongolia = 143,
+        Montserrat = 144,
+        Morocco = 145,
+        Mozambique = 146,
+        Myanmar = 147,
+        Namibia = 148,
+        NauruCountry = 149,
+        Nepal = 150,
+        Netherlands = 151,
+        NetherlandsAntilles = 152,
+        NewCaledonia = 153,
+        NewZealand = 154,
+        Nicaragua = 155,
+        Niger = 156,
+        Nigeria = 157,
+        Niue = 158,
+        NorfolkIsland = 159,
+        NorthernMarianaIslands = 160,
+        Norway = 161,
+        Oman = 162,
+        Pakistan = 163,
+        Palau = 164,
+        PalestinianTerritory = 165,
+        Panama = 166,
+        PapuaNewGuinea = 167,
+        Paraguay = 168,
+        Peru = 169,
+        Philippines = 170,
+        Pitcairn = 171,
+        Poland = 172,
+        Portugal = 173,
+        PuertoRico = 174,
+        Qatar = 175,
+        Reunion = 176,
+        Romania = 177,
+        RussianFederation = 178,
+        Rwanda = 179,
+        SaintKittsAndNevis = 180,
+        StLucia = 181,
+        StVincentAndTheGrenadines = 182,
+        Samoa = 183,
+        SanMarino = 184,
+        SaoTomeAndPrincipe = 185,
+        SaudiArabia = 186,
+        Senegal = 187,
+        Seychelles = 188,
+        SierraLeone = 189,
+        Singapore = 190,
+        Slovakia = 191,
+        Slovenia = 192,
+        SolomonIslands = 193,
+        Somalia = 194,
+        SouthAfrica = 195,
+        SouthGeorgiaAndTheSouthSandwichIslands = 196,
+        Spain = 197,
+        SriLanka = 198,
+        StHelena = 199,
+        StPierreAndMiquelon = 200,
+        Sudan = 201,
+        Suriname = 202,
+        SvalbardAndJanMayenIslands = 203,
+        Swaziland = 204,
+        Sweden = 205,
+        Switzerland = 206,
+        SyrianArabRepublic = 207,
+        Taiwan = 208,
+        Tajikistan = 209,
+        Tanzania = 210,
+        Thailand = 211,
+        Togo = 212,
+        Tokelau = 213,
+        TongaCountry = 214,
+        TrinidadAndTobago = 215,
+        Tunisia = 216,
+        Turkey = 217,
+        Turkmenistan = 218,
+        TurksAndCaicosIslands = 219,
+        Tuvalu = 220,
+        Uganda = 221,
+        Ukraine = 222,
+        UnitedArabEmirates = 223,
+        UnitedKingdom = 224,
+        UnitedStates = 225,
+        UnitedStatesMinorOutlyingIslands = 226,
+        Uruguay = 227,
+        Uzbekistan = 228,
+        Vanuatu = 229,
+        VaticanCityState = 230,
+        Venezuela = 231,
+        VietNam = 232,
+        BritishVirginIslands = 233,
+        USVirginIslands = 234,
+        WallisAndFutunaIslands = 235,
+        WesternSahara = 236,
+        Yemen = 237,
+        Yugoslavia = 238,
+        Zambia = 239,
+        Zimbabwe = 240,
+        LastCountry = Zimbabwe
+    };
+
+    TQLocale();
+    TQLocale(const TQString &name);
+    TQLocale(Language language, Country country = AnyCountry);
+    TQLocale(const TQLocale &other);
+
+    TQLocale &operator=(const TQLocale &other);
+
+    Language language() const;
+    Country country() const;
+    TQString name() const;
+
+    short toShort(const TQString &s, bool *ok = 0) const;
+    ushort toUShort(const TQString &s, bool *ok = 0) const;
+    int toInt(const TQString &s, bool *ok = 0) const;
+    uint toUInt(const TQString &s, bool *ok = 0) const;
+    TQ_LONG toLong(const TQString &s, bool *ok = 0) const;
+    TQ_ULONG toULong(const TQString &s, bool *ok = 0) const;
+    TQ_LLONG toLongLong(const TQString &s, bool *ok = 0) const;
+    TQ_ULLONG toULongLong(const TQString &s, bool *ok = 0) const;
+    float toFloat(const TQString &s, bool *ok = 0) const;
+    double toDouble(const TQString &s, bool *ok = 0) const;
+
+    TQString toString(short i) const
+    { return toString((TQ_LLONG)i); }
+    TQString toString(ushort i) const
+    { return toString((TQ_ULLONG)i); }
+    TQString toString(int i) const
+    { return toString((TQ_LLONG)i); }
+    TQString toString(uint i) const
+    { return toString((TQ_ULLONG)i); }
+#if !defined(TQ_OS_WIN64)
+    TQString toString(TQ_LONG i) const
+    { return toString((TQ_LLONG)i); }
+    TQString toString(TQ_ULONG i) const
+    { return toString((TQ_ULLONG)i); }
+#endif
+    TQString toString(TQ_LLONG i) const;
+    TQString toString(TQ_ULLONG i) const;
+    TQString toString(float i, char f = 'g', int prec = 6) const
+    { return toString((double) i, f, prec); }
+    TQString toString(double i, char f = 'g', int prec = 6) const;
+
+    static TQString languageToString(Language language);
+    static TQString countryToString(Country country);
+    static void setDefault(const TQLocale &locale);
+
+    static TQLocale c() { return TQLocale(C); }
+    static TQLocale system();
+
+private:
+    const TQLocalePrivate *d;
+    static const TQLocalePrivate *default_d;
+};
+
+#endif
diff --git a/tqtinterface/qt4/src/tools/tqlocale_p.h b/tqtinterface/qt4/src/tools/tqlocale_p.h
new file mode 100644
index 0000000..fbfc184
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqlocale_p.h
@@ -0,0 +1,131 @@
+/****************************************************************************
+**
+** Declaration of the TQLocalePrivate class
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the widgets module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQLOCALE_P_H
+#define TQLOCALE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the TQt API.  It exists for the convenience
+// of internal files.  This header file may change from version to version
+// without notice, or even be removed.
+//
+// We mean it.
+//
+//
+
+#include <tqstring.h>
+
+struct TQLocalePrivate
+{
+public:
+    const TQChar &decimal() const { return (TQChar&)m_decimal; }
+    const TQChar &group() const { return (TQChar&)m_group; }
+    const TQChar &list() const { return (TQChar&)m_list; }
+    const TQChar &percent() const { return (TQChar&)m_percent; }
+    const TQChar &zero() const { return (TQChar&)m_zero; }
+    TQChar plus() const { return TQChar('+'); }
+    const TQChar &minus() const { return (TQChar&)m_minus; }
+    const TQChar &exponential() const { return (TQChar&)m_exponential; }
+    TQString infinity() const;
+    TQString nan() const;
+
+    TQ_UINT32 languageId() const { return m_language_id; }
+    TQ_UINT32 countryId() const { return m_country_id; }
+
+    bool isDigit(TQChar d) const;
+
+    enum GroupSeparatorMode {
+    	FailOnGroupSeparators,
+	ParseGroupSeparators
+    };
+
+    enum DoubleForm {
+	DFExponent = 0,     	    	// %e or %E
+	DFDecimal,  	    	    	// %f or %F
+	DFSignificantDigits,	    	// %g or %G
+	_DFMax = DFSignificantDigits
+    };
+
+    enum Flags {
+	NoFlags	    	= 0,
+	
+	// These correspond to the options in a printf format string
+	Alternate           = 0x01,
+	ZeroPadded          = 0x02,
+	LeftAdjusted        = 0x04,
+	BlankBeforePositive = 0x08,
+	AlwaysShowSign      = 0x10,
+	ThousandsGroup      = 0x20,
+	CapitalEorX	    = 0x40 // %x, %e, %f, %g vs. %X, %E, %F, %G
+    };
+
+    TQString doubleToString(double d,
+			   int precision = -1,
+			   DoubleForm form = DFSignificantDigits,
+			   int width = -1,
+			   unsigned flags = NoFlags) const;
+    TQString longLongToString(TQ_LLONG l, int precision = -1,
+			     int base = 10,
+			     int width = -1,
+			     unsigned flags = NoFlags) const;
+    TQString unsLongLongToString(TQ_ULLONG l, int precision = -1,
+				int base = 10,
+				int width = -1,
+				unsigned flags = NoFlags) const;
+    double stringToDouble(TQString num, bool *ok, GroupSeparatorMode group_sep_mode) const;
+    TQ_LLONG stringToLongLong(TQString num, int base, bool *ok, GroupSeparatorMode group_sep_mode) const;
+    TQ_ULLONG stringToUnsLongLong(TQString num, int base, bool *ok, GroupSeparatorMode group_sep_mode) const;
+    bool removeGroupSeparators(TQString &num_str) const;
+    bool numberToCLocale(TQString &locale_num, GroupSeparatorMode group_sep_mode) const;
+
+    TQ_UINT32 m_language_id, m_country_id;
+
+    TQ_UINT16 m_decimal, m_group, m_list, m_percent,
+	m_zero, m_minus, m_exponential;
+
+    static const TQString m_infinity;
+    static const TQString m_nan;
+    static const TQChar m_plus;
+
+    static const char *systemLocaleName();
+};
+
+#endif
diff --git a/tqtinterface/qt4/src/tools/tqmap.cpp b/tqtinterface/qt4/src/tools/tqmap.cpp
new file mode 100644
index 0000000..70d6342
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqmap.cpp
@@ -0,0 +1,257 @@
+/****************************************************************************
+**
+** Implementation of TQMap
+**
+** Created : 990406
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "tqmap.h"
+
+typedef TQMapNodeBase* NodePtr;
+typedef TQMapNodeBase Node;
+
+
+void TQMapPrivateBase::rotateLeft( NodePtr x, NodePtr& root)
+{
+    NodePtr y = x->right;
+    x->right = y->left;
+    if (y->left !=0)
+	y->left->tqparent = x;
+    y->tqparent = x->tqparent;
+    if (x == root)
+	root = y;
+    else if (x == x->tqparent->left)
+	x->tqparent->left = y;
+    else
+	x->tqparent->right = y;
+    y->left = x;
+    x->tqparent = y;
+}
+
+
+void TQMapPrivateBase::rotateRight( NodePtr x, NodePtr& root )
+{
+    NodePtr y = x->left;
+    x->left = y->right;
+    if (y->right != 0)
+	y->right->tqparent = x;
+    y->tqparent = x->tqparent;
+    if (x == root)
+	root = y;
+    else if (x == x->tqparent->right)
+	x->tqparent->right = y;
+    else
+	x->tqparent->left = y;
+    y->right = x;
+    x->tqparent = y;
+}
+
+
+void TQMapPrivateBase::rebalance( NodePtr x, NodePtr& root)
+{
+    x->color = Node::Red;
+    while ( x != root && x->tqparent->color == Node::Red ) {
+	if ( x->tqparent == x->tqparent->tqparent->left ) {
+	    NodePtr y = x->tqparent->tqparent->right;
+	    if (y && y->color == Node::Red) {
+		x->tqparent->color = Node::Black;
+		y->color = Node::Black;
+		x->tqparent->tqparent->color = Node::Red;
+		x = x->tqparent->tqparent;
+	    } else {
+		if (x == x->tqparent->right) {
+		    x = x->tqparent;
+		    rotateLeft( x, root );
+		}
+		x->tqparent->color = Node::Black;
+		x->tqparent->tqparent->color = Node::Red;
+		rotateRight (x->tqparent->tqparent, root );
+	    }
+	} else {
+	    NodePtr y = x->tqparent->tqparent->left;
+	    if ( y && y->color == Node::Red ) {
+		x->tqparent->color = Node::Black;
+		y->color = Node::Black;
+		x->tqparent->tqparent->color = Node::Red;
+		x = x->tqparent->tqparent;
+	    } else {
+		if (x == x->tqparent->left) { 
+		    x = x->tqparent;
+		    rotateRight( x, root );
+		}
+		x->tqparent->color = Node::Black;
+		x->tqparent->tqparent->color = Node::Red;
+		rotateLeft( x->tqparent->tqparent, root );
+	    }
+	}
+    }
+    root->color = Node::Black;
+}
+
+
+NodePtr TQMapPrivateBase::removeAndRebalance( NodePtr z, NodePtr& root,
+					     NodePtr& leftmost,
+					     NodePtr& rightmost )
+{
+    NodePtr y = z;
+    NodePtr x;
+    NodePtr x_tqparent;
+    if (y->left == 0) {
+	x = y->right;
+    } else {
+	if (y->right == 0)
+	    x = y->left;
+	else
+	    {
+		y = y->right;
+		while (y->left != 0)
+		    y = y->left;
+		x = y->right;
+	    }
+    }
+    if (y != z) {
+	z->left->tqparent = y; 
+	y->left = z->left;
+	if (y != z->right) {
+	    x_tqparent = y->tqparent;
+	    if (x)
+		x->tqparent = y->tqparent;
+	    y->tqparent->left = x;
+	    y->right = z->right;
+	    z->right->tqparent = y;
+	} else {
+	    x_tqparent = y;  
+	}
+	if (root == z)
+	    root = y;
+	else if (z->tqparent->left == z)
+	    z->tqparent->left = y;
+	else 
+	    z->tqparent->right = y;
+	y->tqparent = z->tqparent;
+	// Swap the colors
+	Node::Color c = y->color;
+	y->color = z->color;
+	z->color = c;
+	y = z;
+    } else {       
+	x_tqparent = y->tqparent;
+	if (x)
+	    x->tqparent = y->tqparent;   
+	if (root == z)
+	    root = x;
+	else if (z->tqparent->left == z)
+	    z->tqparent->left = x;
+	else
+	    z->tqparent->right = x;
+	if ( leftmost == z ) {
+	    if (z->right == 0)
+		leftmost = z->tqparent;
+	    else
+		leftmost = x->minimum();
+	}
+	if (rightmost == z) {
+	    if (z->left == 0)
+		rightmost = z->tqparent;  
+	    else
+		rightmost = x->maximum();
+	}
+    }
+    if (y->color != Node::Red) { 
+	while (x != root && (x == 0 || x->color == Node::Black)) {
+	    if (x == x_tqparent->left) {
+		NodePtr w = x_tqparent->right;
+		if (w->color == Node::Red) {
+		    w->color = Node::Black;
+		    x_tqparent->color = Node::Red;
+		    rotateLeft(x_tqparent, root);
+		    w = x_tqparent->right;
+		}
+		if ((w->left == 0 || w->left->color == Node::Black) &&
+		    (w->right == 0 || w->right->color == Node::Black)) {
+		    w->color = Node::Red;
+		    x = x_tqparent;
+		    x_tqparent = x_tqparent->tqparent;
+		} else {
+		    if (w->right == 0 || w->right->color == Node::Black) {
+			if (w->left)
+			    w->left->color = Node::Black;
+			w->color = Node::Red;
+			rotateRight(w, root);
+			w = x_tqparent->right;
+		    }
+		    w->color = x_tqparent->color;
+		    x_tqparent->color = Node::Black;
+		    if (w->right)
+			w->right->color = Node::Black;
+		    rotateLeft(x_tqparent, root);
+		    break;
+		}
+	    } else {
+		NodePtr w = x_tqparent->left;
+		if (w->color == Node::Red) {
+		    w->color = Node::Black;
+		    x_tqparent->color = Node::Red;
+		    rotateRight(x_tqparent, root);
+		    w = x_tqparent->left;
+		}
+		if ((w->right == 0 || w->right->color == Node::Black) &&
+		    (w->left == 0 || w->left->color == Node::Black)) {
+		    w->color = Node::Red;
+		    x = x_tqparent;
+		    x_tqparent = x_tqparent->tqparent;
+		} else {
+		    if (w->left == 0 || w->left->color == Node::Black) {
+			if (w->right) 
+			    w->right->color = Node::Black;
+			w->color = Node::Red;
+			rotateLeft(w, root);
+			w = x_tqparent->left;
+		    }
+		    w->color = x_tqparent->color;
+		    x_tqparent->color = Node::Black;
+		    if (w->left)
+			w->left->color = Node::Black;
+		    rotateRight(x_tqparent, root);
+		    break;
+		}
+	    }
+	}
+	if (x)
+	    x->color = Node::Black;
+    }
+    return y;
+}
diff --git a/tqtinterface/qt4/src/tools/tqmap.h b/tqtinterface/qt4/src/tools/tqmap.h
new file mode 100644
index 0000000..029f4a3
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqmap.h
@@ -0,0 +1,946 @@
+/****************************************************************************
+**
+** Definition of TQMap class
+**
+** Created : 990406
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQMAP_H
+#define TQMAP_H
+
+#include "tqtglobaldefines.h"
+
+#ifndef TQT_H
+#include "tqglobal.h"
+#include "tqshared.h"
+#include "tqdatastream.h"
+#include "tqpair.h"
+#include "tqvaluelist.h"
+#endif // TQT_H
+
+#ifdef USE_QT4
+
+#include <Qt/qmap.h>
+
+#endif // USE_QT4
+
+#ifndef TQT_NO_STL
+#include <iterator>
+#include <map>
+#endif
+
+//#define TQT_CHECK_MAP_RANGE
+
+struct TQ_EXPORT TQMapNodeBase
+{
+    enum Color { Red, Black };
+
+    TQMapNodeBase* left;
+    TQMapNodeBase* right;
+    TQMapNodeBase* tqparent;
+
+    Color color;
+
+    TQMapNodeBase* minimum() {
+	TQMapNodeBase* x = this;
+	while ( x->left )
+	    x = x->left;
+	return x;
+    }
+
+    TQMapNodeBase* maximum() {
+	TQMapNodeBase* x = this;
+	while ( x->right )
+	    x = x->right;
+	return x;
+    }
+};
+
+
+template <class K, class T>
+struct TQMapNode : public TQMapNodeBase
+{
+    TQMapNode( const K& _key, const T& _data ) { data = _data; key = _key; }
+    TQMapNode( const K& _key )	   { key = _key; }
+    TQMapNode( const TQMapNode<K,T>& _n ) { key = _n.key; data = _n.data; }
+    TQMapNode() { }
+    T data;
+    K key;
+};
+
+
+template<class K, class T>
+class TQMapIterator
+{
+ public:
+    /**
+     * Typedefs
+     */
+    typedef TQMapNode< K, T >* NodePtr;
+#ifndef TQT_NO_STL
+    typedef std::bidirectional_iterator_tag  iterator_category;
+#endif
+    typedef T          value_type;
+#ifndef TQT_NO_STL
+    typedef ptrdiff_t  difference_type;
+#else
+    typedef int difference_type;
+#endif
+    typedef T*         pointer;
+    typedef T&         reference;
+
+    /**
+     * Variables
+     */
+    TQMapNode<K,T>* node;
+
+    /**
+     * Functions
+     */
+    TQMapIterator() : node( 0 ) {}
+    TQMapIterator( TQMapNode<K,T>* p ) : node( p ) {}
+    TQMapIterator( const TQMapIterator<K,T>& it ) : node( it.node ) {}
+
+    bool operator==( const TQMapIterator<K,T>& it ) const { return node == it.node; }
+    bool operator!=( const TQMapIterator<K,T>& it ) const { return node != it.node; }
+    T& operator*() { return node->data; }
+    const T& operator*() const { return node->data; }
+    // UDT for T = x*
+    // T* operator->() const { return &node->data; }
+
+    const K& key() const { return node->key; }
+    T& data() { return node->data; }
+    const T& data() const { return node->data; }
+
+private:
+    int inc();
+    int dec();
+
+public:
+    TQMapIterator<K,T>& operator++() {
+	inc();
+	return *this;
+    }
+
+    TQMapIterator<K,T> operator++(int) {
+	TQMapIterator<K,T> tmp = *this;
+	inc();
+	return tmp;
+    }
+
+    TQMapIterator<K,T>& operator--() {
+	dec();
+	return *this;
+    }
+
+    TQMapIterator<K,T> operator--(int) {
+	TQMapIterator<K,T> tmp = *this;
+	dec();
+	return tmp;
+    }
+};
+
+template <class K, class T>
+TQ_INLINE_TEMPLATES int TQMapIterator<K,T>::inc()
+{
+    TQMapNodeBase* tmp = node;
+    if ( tmp->right ) {
+	tmp = tmp->right;
+	while ( tmp->left )
+	    tmp = tmp->left;
+    } else {
+	TQMapNodeBase* y = tmp->tqparent;
+	while (tmp == y->right) {
+	    tmp = y;
+	    y = y->tqparent;
+	}
+	if (tmp->right != y)
+	    tmp = y;
+    }
+    node = (NodePtr)tmp;
+    return 0;
+}
+
+template <class K, class T>
+TQ_INLINE_TEMPLATES int TQMapIterator<K,T>::dec()
+{
+    TQMapNodeBase* tmp = node;
+    if (tmp->color == TQMapNodeBase::Red &&
+	tmp->tqparent->tqparent == tmp ) {
+	tmp = tmp->right;
+    } else if (tmp->left != 0) {
+	TQMapNodeBase* y = tmp->left;
+	while ( y->right )
+	    y = y->right;
+	tmp = y;
+    } else {
+	TQMapNodeBase* y = tmp->tqparent;
+	while (tmp == y->left) {
+	    tmp = y;
+	    y = y->tqparent;
+	}
+	tmp = y;
+    }
+    node = (NodePtr)tmp;
+    return 0;
+}
+
+template<class K, class T>
+class TQMapConstIterator
+{
+ public:
+    /**
+     * Typedefs
+     */
+    typedef TQMapNode< K, T >* NodePtr;
+#ifndef TQT_NO_STL
+    typedef std::bidirectional_iterator_tag  iterator_category;
+#endif
+    typedef T          value_type;
+#ifndef TQT_NO_STL
+    typedef ptrdiff_t  difference_type;
+#else
+    typedef int difference_type;
+#endif
+    typedef const T*   pointer;
+    typedef const T&   reference;
+
+
+    /**
+     * Variables
+     */
+    TQMapNode<K,T>* node;
+
+    /**
+     * Functions
+     */
+    TQMapConstIterator() : node( 0 ) {}
+    TQMapConstIterator( TQMapNode<K,T>* p ) : node( p ) {}
+    TQMapConstIterator( const TQMapConstIterator<K,T>& it ) : node( it.node ) {}
+    TQMapConstIterator( const TQMapIterator<K,T>& it ) : node( it.node ) {}
+
+    bool operator==( const TQMapConstIterator<K,T>& it ) const { return node == it.node; }
+    bool operator!=( const TQMapConstIterator<K,T>& it ) const { return node != it.node; }
+    const T& operator*()  const { return node->data; }
+    // UDT for T = x*
+    // const T* operator->() const { return &node->data; }
+
+    const K& key() const { return node->key; }
+    const T& data() const { return node->data; }
+
+private:
+    int inc();
+    int dec();
+
+public:
+    TQMapConstIterator<K,T>& operator++() {
+	inc();
+	return *this;
+    }
+
+    TQMapConstIterator<K,T> operator++(int) {
+	TQMapConstIterator<K,T> tmp = *this;
+	inc();
+	return tmp;
+    }
+
+    TQMapConstIterator<K,T>& operator--() {
+	dec();
+	return *this;
+    }
+
+    TQMapConstIterator<K,T> operator--(int) {
+	TQMapConstIterator<K,T> tmp = *this;
+	dec();
+	return tmp;
+    }
+};
+
+template <class K, class T>
+TQ_INLINE_TEMPLATES int TQMapConstIterator<K,T>::inc()
+{
+    TQMapNodeBase* tmp = node;
+    if ( tmp->right ) {
+	tmp = tmp->right;
+	while ( tmp->left )
+	    tmp = tmp->left;
+    } else {
+	TQMapNodeBase* y = tmp->tqparent;
+	while (tmp == y->right) {
+	    tmp = y;
+	    y = y->tqparent;
+	}
+	if (tmp->right != y)
+	    tmp = y;
+    }
+    node = (NodePtr)tmp;
+    return 0;
+}
+
+template <class K, class T>
+TQ_INLINE_TEMPLATES int TQMapConstIterator<K,T>::dec()
+{
+    TQMapNodeBase* tmp = node;
+    if (tmp->color == TQMapNodeBase::Red &&
+	tmp->tqparent->tqparent == tmp ) {
+	tmp = tmp->right;
+    } else if (tmp->left != 0) {
+	TQMapNodeBase* y = tmp->left;
+	while ( y->right )
+	    y = y->right;
+	tmp = y;
+    } else {
+	TQMapNodeBase* y = tmp->tqparent;
+	while (tmp == y->left) {
+	    tmp = y;
+	    y = y->tqparent;
+	}
+	tmp = y;
+    }
+    node = (NodePtr)tmp;
+    return 0;
+}
+
+// ### 4.0: rename to something without Private in it. Not really internal.
+class TQ_EXPORT TQMapPrivateBase : public TQShared
+{
+public:
+    TQMapPrivateBase() {
+	node_count = 0;
+    }
+    TQMapPrivateBase( const TQMapPrivateBase* _map) {
+	node_count = _map->node_count;
+    }
+
+    /**
+     * Implementations of basic tree algorithms
+     */
+    void rotateLeft( TQMapNodeBase* x, TQMapNodeBase*& root);
+    void rotateRight( TQMapNodeBase* x, TQMapNodeBase*& root );
+    void rebalance( TQMapNodeBase* x, TQMapNodeBase*& root );
+    TQMapNodeBase* removeAndRebalance( TQMapNodeBase* z, TQMapNodeBase*& root,
+				      TQMapNodeBase*& leftmost,
+				      TQMapNodeBase*& rightmost );
+
+    /**
+     * Variables
+     */
+    int node_count;
+};
+
+
+template <class Key, class T>
+class TQMapPrivate : public TQMapPrivateBase
+{
+public:
+    /**
+     * Typedefs
+     */
+    typedef TQMapIterator< Key, T > Iterator;
+    typedef TQMapConstIterator< Key, T > ConstIterator;
+    typedef TQMapNode< Key, T > Node;
+    typedef TQMapNode< Key, T >* NodePtr;
+
+    /**
+     * Functions
+     */
+    TQMapPrivate();
+    TQMapPrivate( const TQMapPrivate< Key, T >* _map );
+    ~TQMapPrivate() { clear(); delete header; }
+
+    NodePtr copy( NodePtr p );
+    void clear();
+    void clear( NodePtr p );
+
+    Iterator begin()	{ return Iterator( (NodePtr)(header->left ) ); }
+    Iterator end()	{ return Iterator( header ); }
+    ConstIterator begin() const { return ConstIterator( (NodePtr)(header->left ) ); }
+    ConstIterator end() const { return ConstIterator( header ); }
+
+    ConstIterator find(const Key& k) const;
+    ConstIterator tqfind(const Key& k) const;
+
+    void remove( Iterator it ) {
+	NodePtr del = (NodePtr) removeAndRebalance( it.node, header->tqparent, header->left, header->right );
+	delete del;
+	--node_count;
+    }
+
+#ifdef TQT_TQMAP_DEBUG
+    void inorder( TQMapNodeBase* x = 0, int level = 0 ){
+	if ( !x )
+	    x = header->tqparent;
+	if ( x->left )
+	    inorder( x->left, level + 1 );
+    //cout << level << " Key=" << key(x) << " Value=" << ((NodePtr)x)->data << endl;
+	if ( x->right )
+	    inorder( x->right, level + 1 );
+    }
+#endif
+
+#if 0
+    Iterator insertMulti(const Key& v){
+	TQMapNodeBase* y = header;
+	TQMapNodeBase* x = header->tqparent;
+	while (x != 0){
+	    y = x;
+	    x = ( v < key(x) ) ? x->left : x->right;
+	}
+	return insert(x, y, v);
+    }
+#endif
+
+    Iterator insertSingle( const Key& k );
+    Iterator insert( TQMapNodeBase* x, TQMapNodeBase* y, const Key& k );
+
+protected:
+    /**
+     * Helpers
+     */
+    const Key& key( TQMapNodeBase* b ) const { return ((NodePtr)b)->key; }
+
+    /**
+     * Variables
+     */
+    NodePtr header;
+};
+
+
+template <class Key, class T>
+TQ_INLINE_TEMPLATES TQMapPrivate<Key,T>::TQMapPrivate() {
+    header = new Node;
+    header->color = TQMapNodeBase::Red; // Mark the header
+    header->tqparent = 0;
+    header->left = header->right = header;
+}
+template <class Key, class T>
+TQ_INLINE_TEMPLATES TQMapPrivate<Key,T>::TQMapPrivate( const TQMapPrivate< Key, T >* _map ) : TQMapPrivateBase( _map ) {
+    header = new Node;
+    header->color = TQMapNodeBase::Red; // Mark the header
+    if ( _map->header->tqparent == 0 ) {
+	header->tqparent = 0;
+	header->left = header->right = header;
+    } else {
+	header->tqparent = copy( (NodePtr)(_map->header->tqparent) );
+	header->tqparent->tqparent = header;
+	header->left = header->tqparent->minimum();
+	header->right = header->tqparent->maximum();
+    }
+}
+
+template <class Key, class T>
+TQ_INLINE_TEMPLATES TQ_TYPENAME TQMapPrivate<Key,T>::NodePtr TQMapPrivate<Key,T>::copy( TQ_TYPENAME TQMapPrivate<Key,T>::NodePtr p )
+{
+    if ( !p )
+	return 0;
+    NodePtr n = new Node( *p );
+    n->color = p->color;
+    if ( p->left ) {
+	n->left = copy( (NodePtr)(p->left) );
+	n->left->tqparent = n;
+    } else {
+	n->left = 0;
+    }
+    if ( p->right ) {
+	n->right = copy( (NodePtr)(p->right) );
+	n->right->tqparent = n;
+    } else {
+	n->right = 0;
+    }
+    return n;
+}
+
+template <class Key, class T>
+TQ_INLINE_TEMPLATES void TQMapPrivate<Key,T>::clear()
+{
+    clear( (NodePtr)(header->tqparent) );
+    header->color = TQMapNodeBase::Red;
+    header->tqparent = 0;
+    header->left = header->right = header;
+    node_count = 0;
+}
+
+template <class Key, class T>
+TQ_INLINE_TEMPLATES void TQMapPrivate<Key,T>::clear( TQ_TYPENAME TQMapPrivate<Key,T>::NodePtr p )
+{
+    while ( p != 0 ) {
+	clear( (NodePtr)p->right );
+	NodePtr y = (NodePtr)p->left;
+	delete p;
+	p = y;
+    }
+}
+
+template <class Key, class T>
+TQ_INLINE_TEMPLATES TQ_TYPENAME TQMapPrivate<Key,T>::ConstIterator TQMapPrivate<Key,T>::find(const Key& k) const
+{
+    return tqfind(k);
+}
+
+template <class Key, class T>
+TQ_INLINE_TEMPLATES TQ_TYPENAME TQMapPrivate<Key,T>::ConstIterator TQMapPrivate<Key,T>::tqfind(const Key& k) const
+{
+    TQMapNodeBase* y = header;        // Last node
+    TQMapNodeBase* x = header->tqparent; // Root node.
+
+    while ( x != 0 ) {
+	// If as k <= key(x) go left
+	if ( !( key(x) < k ) ) {
+	    y = x;
+	    x = x->left;
+	} else {
+	    x = x->right;
+	}
+    }
+
+    // Was k bigger/smaller then the biggest/smallest
+    // element of the tree ? Return end()
+    if ( y == header || k < key(y) )
+	return ConstIterator( header );
+    return ConstIterator( (NodePtr)y );
+}
+
+template <class Key, class T>
+TQ_INLINE_TEMPLATES TQ_TYPENAME TQMapPrivate<Key,T>::Iterator TQMapPrivate<Key,T>::insertSingle( const Key& k )
+{
+    // Search correct position in the tree
+    TQMapNodeBase* y = header;
+    TQMapNodeBase* x = header->tqparent;
+    bool result = TRUE;
+    while ( x != 0 ) {
+	result = ( k < key(x) );
+	y = x;
+	x = result ? x->left : x->right;
+    }
+    // Get iterator on the last not empty one
+    Iterator j( (NodePtr)y );
+    if ( result ) {
+	// Smaller then the leftmost one ?
+	if ( j == begin() ) {
+	    return insert(x, y, k );
+	} else {
+	    // Perhaps daddy is the right one ?
+	    --j;
+	}
+    }
+    // Really bigger ?
+    if ( (j.node->key) < k )
+	return insert(x, y, k );
+    // We are going to tqreplace a node
+    return j;
+}
+
+
+template <class Key, class T>
+TQ_INLINE_TEMPLATES TQ_TYPENAME TQMapPrivate<Key,T>::Iterator TQMapPrivate<Key,T>::insert( TQMapNodeBase* x, TQMapNodeBase* y, const Key& k )
+{
+    NodePtr z = new Node( k );
+    if (y == header || x != 0 || k < key(y) ) {
+	y->left = z;                // also makes leftmost = z when y == header
+	if ( y == header ) {
+	    header->tqparent = z;
+	    header->right = z;
+	} else if ( y == header->left )
+	    header->left = z;           // maintain leftmost pointing to min node
+    } else {
+	y->right = z;
+	if ( y == header->right )
+	    header->right = z;          // maintain rightmost pointing to max node
+    }
+    z->tqparent = y;
+    z->left = 0;
+    z->right = 0;
+    rebalance( z, header->tqparent );
+    ++node_count;
+    return Iterator(z);
+}
+
+
+#ifdef TQT_CHECK_RANGE
+# if !defined( TQT_NO_DEBUG ) && defined( TQT_CHECK_MAP_RANGE )
+#  define TQT_CHECK_INVALID_MAP_ELEMENT if ( empty() ) qWarning( "TQMap: Warning invalid element" )
+#  define TQT_CHECK_INVALID_MAP_ELEMENT_FATAL TQ_ASSERT( !empty() );
+# else
+#  define TQT_CHECK_INVALID_MAP_ELEMENT
+#  define TQT_CHECK_INVALID_MAP_ELEMENT_FATAL
+# endif
+#else
+# define TQT_CHECK_INVALID_MAP_ELEMENT
+# define TQT_CHECK_INVALID_MAP_ELEMENT_FATAL
+#endif
+
+template <class T> class TQDeepCopy;
+
+template<class Key, class T>
+class TQMap
+{
+public:
+    /**
+     * Typedefs
+     */
+    typedef Key key_type;
+    typedef T mapped_type;
+    typedef TQPair<const key_type, mapped_type> value_type;
+    typedef value_type* pointer;
+    typedef const value_type* const_pointer;
+    typedef value_type& reference;
+    typedef const value_type& const_reference;
+#ifndef TQT_NO_STL
+    typedef ptrdiff_t  difference_type;
+#else
+    typedef int difference_type;
+#endif
+    typedef size_t      size_type;
+    typedef TQMapIterator<Key,T> iterator;
+    typedef TQMapConstIterator<Key,T> const_iterator;
+    typedef TQPair<iterator,bool> insert_pair;
+
+    typedef TQMapIterator< Key, T > Iterator;
+    typedef TQMapConstIterator< Key, T > ConstIterator;
+    typedef T ValueType;
+    typedef TQMapPrivate< Key, T > Priv;
+
+    /**
+     * API
+     */
+    TQMap()
+    {
+	sh = new TQMapPrivate< Key, T >;
+    }
+    TQMap( const TQMap<Key,T>& m )
+    {
+	sh = m.sh; sh->ref();
+    }
+
+#ifndef TQT_NO_STL
+    TQMap( const std::map<Key,T>& m )
+    {
+	sh = new TQMapPrivate<Key,T>;
+	TQ_TYPENAME std::map<Key,T>::const_iterator it = m.begin();
+	for ( ; it != m.end(); ++it ) {
+	    value_type p( (*it).first, (*it).second );
+	    insert( p );
+	}
+    }
+#endif
+    ~TQMap()
+    {
+	if ( sh->deref() )
+	    delete sh;
+    }
+    TQMap<Key,T>& operator= ( const TQMap<Key,T>& m );
+#ifndef TQT_NO_STL
+    TQMap<Key,T>& operator= ( const std::map<Key,T>& m )
+    {
+	clear();
+	TQ_TYPENAME std::map<Key,T>::const_iterator it = m.begin();
+	for ( ; it != m.end(); ++it ) {
+	    value_type p( (*it).first, (*it).second );
+	    insert( p );
+	}
+	return *this;
+    }
+#endif
+
+#ifdef USE_QT4
+    // Interoperability
+    TQMap(const QMap<Key,T>& m)
+    {
+        QMapIterator<Key,T> i(m);
+        while (i.hasNext()) {
+            i.next();
+            insert(i.key(), i.value());
+        }
+    }
+    TQMap<Key,T>& operator= (const QMap<Key,T>& m)
+    {
+        this->clear();
+        QMapIterator<Key,T> i(m);
+        while (i.hasNext()) {
+            i.next();
+            insert(i.key(), i.value());
+        }
+        return *this;
+    }
+
+    // FIXME BROKEN!
+    operator QMap<Key,T>();
+    operator QMap<Key,T>() const;
+#endif // USE_QT4
+
+    iterator begin() { detach(); return sh->begin(); }
+    iterator end() { detach(); return sh->end(); }
+    const_iterator begin() const { return ((const Priv*)sh)->begin(); }
+    const_iterator end() const { return ((const Priv*)sh)->end(); }
+    const_iterator constBegin() const { return begin(); }
+    const_iterator constEnd() const { return end(); }
+
+    iterator tqreplace( const Key& k, const T& v )
+    {
+	remove( k );
+	return insert( k, v );
+    }
+
+    size_type size() const
+    {
+	return sh->node_count;
+    }
+    bool empty() const
+    {
+	return sh->node_count == 0;
+    }
+    TQPair<iterator,bool> insert( const value_type& x );
+
+    void erase( iterator it )
+    {
+	detach();
+	sh->remove( it );
+    }
+    void erase( const key_type& k );
+    size_type count( const key_type& k ) const;
+    T& operator[] ( const Key& k );
+    void clear();
+
+    iterator tqfind ( const Key& k )
+    {
+	detach();
+	return iterator( sh->tqfind( k ).node );
+    }
+    const_iterator tqfind ( const Key& k ) const {	return sh->tqfind( k ); }
+
+    iterator find ( const Key& k ) { return tqfind(k); }
+    const_iterator find ( const Key& k ) const { return tqfind(k); }
+
+    const T& operator[] ( const Key& k ) const
+	{ TQT_CHECK_INVALID_MAP_ELEMENT; return sh->tqfind( k ).data(); }
+    bool tqcontains ( const Key& k ) const
+	{ return tqfind( k ) != end(); }
+	//{ return sh->tqfind( k ) != ((const Priv*)sh)->end(); }
+
+    size_type count() const { return sh->node_count; }
+
+    TQValueList<Key> keys() const {
+	TQValueList<Key> r;
+	for (const_iterator i=begin(); i!=end(); ++i)
+	    r.append(i.key());
+	return r;
+    }
+
+    TQValueList<T> values() const {
+	TQValueList<T> r;
+	for (const_iterator i=begin(); i!=end(); ++i)
+	    r.append(*i);
+	return r;
+    }
+
+    bool isEmpty() const { return sh->node_count == 0; }
+
+    iterator insert( const Key& key, const T& value, bool overwrite = TRUE );
+    void remove( iterator it ) { detach(); sh->remove( it ); }
+    void remove( const Key& k );
+
+#if defined(TQ_FULL_TEMPLATE_INSTANTIATION)
+    bool operator==( const TQMap<Key,T>& ) const { return FALSE; }
+#ifndef TQT_NO_STL
+    bool operator==( const std::map<Key,T>& ) const { return FALSE; }
+#endif
+#endif
+
+protected:
+    /**
+     * Helpers
+     */
+    void detach() {  if ( sh->count > 1 ) detachInternal(); }
+
+    Priv* sh;
+private:
+    void detachInternal();
+
+    friend class TQDeepCopy< TQMap<Key,T> >;
+};
+
+#ifdef USE_QT4
+
+// Interoperability
+template<class Key, class T>
+TQMap<Key,T>::operator QMap<Key,T>() {
+        QMap<Key,T> map;
+        iterator it;
+        for ( it = this->begin(); it != this->end(); ++it) {
+            map.insert(it.key(), it.data());
+        }
+        return map;
+}
+
+// Interoperability
+template<class Key, class T>
+TQMap<Key,T>::operator QMap<Key,T>() const {
+        QMap<Key,T> map;
+        const_iterator it;
+        for ( it = this->begin(); it != this->end(); ++it) {
+            map.insert(it.key(), it.data());
+        }
+        return map;
+}
+
+#endif // USE_QT4
+
+template<class Key, class T>
+TQ_INLINE_TEMPLATES TQMap<Key,T>& TQMap<Key,T>::operator= ( const TQMap<Key,T>& m )
+{
+    m.sh->ref();
+    if ( sh->deref() )
+	delete sh;
+    sh = m.sh;
+    return *this;
+}
+
+template<class Key, class T>
+TQ_INLINE_TEMPLATES TQ_TYPENAME TQMap<Key,T>::insert_pair TQMap<Key,T>::insert( const TQ_TYPENAME TQMap<Key,T>::value_type& x )
+{
+    detach();
+    size_type n = size();
+    iterator it = sh->insertSingle( x.first );
+    bool inserted = FALSE;
+    if ( n < size() ) {
+	inserted = TRUE;
+	it.data() = x.second;
+    }
+    return TQPair<iterator,bool>( it, inserted );
+}
+
+template<class Key, class T>
+TQ_INLINE_TEMPLATES void TQMap<Key,T>::erase( const Key& k )
+{
+    detach();
+    iterator it( sh->tqfind( k ).node );
+    if ( it != end() )
+	sh->remove( it );
+}
+
+template<class Key, class T>
+TQ_INLINE_TEMPLATES TQ_TYPENAME TQMap<Key,T>::size_type TQMap<Key,T>::count( const Key& k ) const
+{
+    const_iterator it( sh->tqfind( k ).node );
+    if ( it != end() ) {
+	size_type c = 0;
+	while ( it != end() ) {
+	    ++it;
+	    ++c;
+	}
+	return c;
+    }
+    return 0;
+}
+
+template<class Key, class T>
+TQ_INLINE_TEMPLATES T& TQMap<Key,T>::operator[] ( const Key& k )
+{
+    detach();
+    TQMapNode<Key,T>* p = sh->tqfind( k ).node;
+    if ( p != sh->end().node )
+	return p->data;
+    return insert( k, T() ).data();
+}
+
+template<class Key, class T>
+TQ_INLINE_TEMPLATES void TQMap<Key,T>::clear()
+{
+    if ( sh->count == 1 )
+	sh->clear();
+    else {
+	sh->deref();
+	sh = new TQMapPrivate<Key,T>;
+    }
+}
+
+template<class Key, class T>
+TQ_INLINE_TEMPLATES TQ_TYPENAME TQMap<Key,T>::iterator TQMap<Key,T>::insert( const Key& key, const T& value, bool overwrite )
+{
+    detach();
+    size_type n = size();
+    iterator it = sh->insertSingle( key );
+    if ( overwrite || n < size() )
+	it.data() = value;
+    return it;
+}
+
+template<class Key, class T>
+TQ_INLINE_TEMPLATES void TQMap<Key,T>::remove( const Key& k )
+{
+    detach();
+    iterator it( sh->tqfind( k ).node );
+    if ( it != end() )
+	sh->remove( it );
+}
+
+template<class Key, class T>
+TQ_INLINE_TEMPLATES void TQMap<Key,T>::detachInternal()
+{
+    sh->deref(); sh = new TQMapPrivate<Key,T>( sh );
+}
+
+
+#ifndef TQT_NO_DATASTREAM
+template<class Key, class T>
+TQ_INLINE_TEMPLATES TQDataStream& operator>>( TQDataStream& s, TQMap<Key,T>& m ) {
+    m.clear();
+    TQ_UINT32 c;
+    s >> c;
+    for( TQ_UINT32 i = 0; i < c; ++i ) {
+	Key k; T t;
+	s >> k >> t;
+	m.insert( k, t );
+	if ( s.atEnd() )
+	    break;
+    }
+    return s;
+}
+
+
+template<class Key, class T>
+TQ_INLINE_TEMPLATES TQDataStream& operator<<( TQDataStream& s, const TQMap<Key,T>& m ) {
+    s << (TQ_UINT32)m.size();
+    TQMapConstIterator<Key,T> it = m.begin();
+    for( ; it != m.end(); ++it )
+	s << it.key() << it.data();
+    return s;
+}
+#endif
+
+#define TQ_DEFINED_TQMAP
+#include "tqwinexport.h"
+#endif // TQMAP_H
diff --git a/tqtinterface/qt4/src/tools/tqmemarray.h b/tqtinterface/qt4/src/tools/tqmemarray.h
new file mode 100644
index 0000000..99e00b0
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqmemarray.h
@@ -0,0 +1,123 @@
+/****************************************************************************
+**
+** Definition of TQMemArray template/macro class
+**
+** Created : 930906
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQMEMARRAY_H
+#define TQMEMARRAY_H
+
+#ifndef TQT_H
+#include "tqgarray.h"
+#endif // TQT_H
+
+
+template<class type>
+class TQMemArray : public TQGArray
+{
+public:
+    typedef type* Iterator;
+    typedef const type* ConstIterator;
+    typedef type ValueType;
+
+protected:
+    TQMemArray( int, int ) : TQGArray( 0, 0 ) {}
+
+public:
+    TQMemArray() {}
+    TQMemArray( int size ) : TQGArray(size*sizeof(type)) {} // ### 4.0 TQ_EXPLICIT
+    TQMemArray( const TQMemArray<type> &a ) : TQGArray(a) {}
+   ~TQMemArray() {}
+    TQMemArray<type> &operator=(const TQMemArray<type> &a)
+				{ return (TQMemArray<type>&)TQGArray::assign(a); }
+    type *data()    const	{ return (type *)TQGArray::data(); }
+    uint  nrefs()   const	{ return TQGArray::nrefs(); }
+    uint  size()    const	{ return TQGArray::size()/sizeof(type); }
+    uint  count()   const	{ return size(); }
+    bool  isEmpty() const	{ return TQGArray::size() == 0; }
+    bool  isNull()  const	{ return TQGArray::data() == 0; }
+    bool  resize( uint size )	{ return TQGArray::resize(size*sizeof(type)); }
+    bool  resize( uint size, Optimization optim ) { return TQGArray::resize(size*sizeof(type), optim); }
+    bool  truncate( uint pos )	{ return TQGArray::resize(pos*sizeof(type)); }
+    bool  fill( const type &d, int size = -1 )
+	{ return TQGArray::fill((char*)&d,size,sizeof(type) ); }
+    void  detach()		{ TQGArray::detach(); }
+    TQMemArray<type>   copy() const
+	{ TQMemArray<type> tmp; return tmp.duplicate(*this); }
+    TQMemArray<type>& assign( const TQMemArray<type>& a )
+	{ return (TQMemArray<type>&)TQGArray::assign(a); }
+    TQMemArray<type>& assign( const type *a, uint n )
+	{ return (TQMemArray<type>&)TQGArray::assign((char*)a,n*sizeof(type)); }
+    TQMemArray<type>& duplicate( const TQMemArray<type>& a )
+	{ return (TQMemArray<type>&)TQGArray::duplicate(a); }
+    TQMemArray<type>& duplicate( const type *a, uint n )
+	{ return (TQMemArray<type>&)TQGArray::duplicate((char*)a,n*sizeof(type)); }
+    TQMemArray<type>& setRawData( const type *a, uint n )
+	{ return (TQMemArray<type>&)TQGArray::setRawData((char*)a,
+						     n*sizeof(type)); }
+    void resetRawData( const type *a, uint n )
+	{ TQGArray::resetRawData((char*)a,n*sizeof(type)); }
+    int	 tqfind( const type &d, uint i=0 ) const
+	{ return TQGArray::tqfind((char*)&d,i,sizeof(type)); }
+    int	 tqcontains( const type &d ) const
+	{ return TQGArray::tqcontains((char*)&d,sizeof(type)); }
+    void sort() { TQGArray::sort(sizeof(type)); }
+    int  bsearch( const type &d ) const
+	{ return TQGArray::bsearch((const char*)&d,sizeof(type)); }
+    // ### TQt 4.0: maybe provide uint overload as work-around for MSVC bug
+    type& operator[]( int i ) const
+	{ return (type &)(*(type *)TQGArray::at(i*sizeof(type))); }
+    type& at( uint i ) const
+	{ return (type &)(*(type *)TQGArray::at(i*sizeof(type))); }
+    type& tqat( uint i ) const
+	{ return (type &)(*(type *)TQGArray::at(i*sizeof(type))); }
+	 operator const type*() const { return (const type *)TQGArray::data(); }
+    bool operator==( const TQMemArray<type> &a ) const { return isEqual(a); }
+    bool operator!=( const TQMemArray<type> &a ) const { return !isEqual(a); }
+    Iterator begin() { return data(); }
+    Iterator end() { return data() + size(); }
+    ConstIterator begin() const { return data(); }
+    ConstIterator end() const { return data() + size(); }
+};
+
+#ifndef TQT_NO_COMPAT
+#define TQArray TQMemArray
+#endif
+
+#define TQ_DEFINED_TQMEMARRAY
+#include "tqwinexport.h"
+#endif // TQARRAY_H
diff --git a/tqtinterface/qt4/src/tools/tqmutex.h b/tqtinterface/qt4/src/tools/tqmutex.h
new file mode 100644
index 0000000..2d0d8b3
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqmutex.h
@@ -0,0 +1,114 @@
+/****************************************************************************
+**
+** Definition of TQMutex class
+**
+** Created : 931107
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQMUTEX_H
+#define TQMUTEX_H
+
+#ifndef TQT_H
+#include "tqglobal.h"
+#endif // TQT_H
+
+#if defined(TQT_THREAD_SUPPORT)
+
+class TQMutexPrivate;
+
+const int TQ_MUTEX_NORMAL = 0;
+const int TQ_MUTEX_RECURSIVE = 1;
+
+class TQ_EXPORT TQMutex
+{
+    friend class TQThread;
+    friend class TQWaitCondition;
+    friend class TQWaitConditionPrivate;
+
+public:
+    TQMutex(bool recursive = FALSE);
+    virtual ~TQMutex();
+
+    void lock();
+    void unlock();
+    bool locked();
+    bool tryLock();
+
+private:
+    TQMutexPrivate * d;
+
+#if defined(TQ_DISABLE_COPY)
+    TQMutex( const TQMutex & );
+    TQMutex &operator=( const TQMutex & );
+#endif
+};
+
+class TQ_EXPORT TQMutexLocker
+{
+public:
+    TQMutexLocker( TQMutex * );
+    ~TQMutexLocker();
+
+    TQMutex *mutex() const;
+
+private:
+    TQMutex *mtx;
+
+#if defined(TQ_DISABLE_COPY)
+    TQMutexLocker( const TQMutexLocker & );
+    TQMutexLocker &operator=( const TQMutexLocker & );
+#endif
+};
+
+inline TQMutexLocker::TQMutexLocker( TQMutex *m )
+    : mtx( m )
+{
+    if ( mtx ) mtx->lock();
+}
+
+inline TQMutexLocker::~TQMutexLocker()
+{
+    if ( mtx ) mtx->unlock();
+}
+
+inline TQMutex *TQMutexLocker::mutex() const
+{
+    return mtx;
+}
+
+#endif
+
+#endif
diff --git a/tqtinterface/qt4/src/tools/tqmutex_p.h b/tqtinterface/qt4/src/tools/tqmutex_p.h
new file mode 100644
index 0000000..0397d3e
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqmutex_p.h
@@ -0,0 +1,73 @@
+/****************************************************************************
+**
+** TQMutex private class declarations
+**
+** Created : 20012507
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef    TQMUTEX_P_H
+#define    TQMUTEX_P_H
+
+#ifndef TQT_H
+#endif // TQT_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the TQt API.  It exists for the convenience
+// of qmutex_unix.cpp and qmutex_win.cpp.  This header file may change
+// from version to version without notice, or even be removed.
+//
+// We mean it.
+//
+
+class TQMutexPrivate {
+public:
+    // TQ_MUTEX_T is defined in the various *.cpp files
+    TQ_MUTEX_T handle;
+
+    virtual ~TQMutexPrivate();
+
+    virtual void lock() = 0;
+    virtual void unlock() = 0;
+    virtual bool locked() = 0;
+    virtual bool trylock() = 0;
+    virtual int type() const = 0;
+};
+
+
+#endif // TQMUTEX_P_H
diff --git a/tqtinterface/qt4/src/tools/tqmutex_unix.cpp b/tqtinterface/qt4/src/tools/tqmutex_unix.cpp
new file mode 100644
index 0000000..540a128
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqmutex_unix.cpp
@@ -0,0 +1,695 @@
+/****************************************************************************
+**
+** TQMutex class for Unix
+**
+** Created : 20010725
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#if defined(TQT_THREAD_SUPPORT)
+
+#include "tqplatformdefs.h"
+
+typedef pthread_mutex_t     TQ_MUTEX_T;
+
+// POSIX threads mutex types
+#if ((defined(PTHREAD_MUTEX_RECURSIVE) && defined(PTHREAD_MUTEX_DEFAULT)) || \
+     defined(TQ_OS_FREEBSD)) && !defined(TQ_OS_UNIXWARE) && !defined(TQ_OS_SOLARIS) && \
+    !defined(TQ_OS_MAC)
+// POSIX 1003.1c-1995 - We love this OS
+#  define TQ_MUTEX_SET_TYPE(a, b) pthread_mutexattr_settype((a), (b))
+#  if defined(TQT_CHECK_RANGE)
+#    define TQ_NORMAL_MUTEX_TYPE PTHREAD_MUTEX_ERRORCHECK
+#  else
+#    define TQ_NORMAL_MUTEX_TYPE PTHREAD_MUTEX_DEFAULT
+#  endif
+#  define TQ_RECURSIVE_MUTEX_TYPE PTHREAD_MUTEX_RECURSIVE
+#elif defined(MUTEX_NONRECURSIVE_NP) && defined(MUTEX_RECURSIVE_NP)
+// POSIX 1003.4a pthreads draft extensions
+#  define TQ_MUTEX_SET_TYPE(a, b) pthread_mutexattr_setkind_np((a), (b));
+#  define TQ_NORMAL_MUTEX_TYPE MUTEX_NONRECURSIVE_NP
+#  define TQ_RECURSIVE_MUTEX_TYPE MUTEX_RECURSIVE_NP
+#else
+// Unknown mutex types - skip them
+#  define TQ_MUTEX_SET_TYPE(a, b)
+#  undef  TQ_NORMAL_MUTEX_TYPE
+#  undef  TQ_RECURSIVE_MUTEX_TYPE
+#endif
+
+#include "tqmutex.h"
+#include "tqmutex_p.h"
+
+#include <errno.h>
+#include <string.h>
+
+
+// Private class declarations
+
+class TQRealMutexPrivate : public TQMutexPrivate {
+public:
+    TQRealMutexPrivate(bool = FALSE);
+
+    void lock();
+    void unlock();
+    bool locked();
+    bool trylock();
+    int type() const;
+
+    bool recursive;
+};
+
+#ifndef    TQ_RECURSIVE_MUTEX_TYPE
+class TQRecursiveMutexPrivate : public TQMutexPrivate
+{
+public:
+    TQRecursiveMutexPrivate();
+    ~TQRecursiveMutexPrivate();
+
+    void lock();
+    void unlock();
+    bool locked();
+    bool trylock();
+    int type() const;
+
+    int count;
+    unsigned long owner;
+    pthread_mutex_t handle2;
+};
+#endif // !TQ_RECURSIVE_MUTEX_TYPE
+
+
+// Private class implementation
+
+// base destructor
+TQMutexPrivate::~TQMutexPrivate()
+{
+    int ret = pthread_mutex_destroy(&handle);
+
+#ifdef TQT_CHECK_RANGE
+    if ( ret )
+	qWarning( "Mutex destroy failure: %s", strerror( ret ) );
+#endif
+}
+
+// real mutex class
+TQRealMutexPrivate::TQRealMutexPrivate(bool recurs)
+    : recursive(recurs)
+{
+    pthread_mutexattr_t attr;
+    pthread_mutexattr_init(&attr);
+    TQ_MUTEX_SET_TYPE(&attr, recursive ? TQ_RECURSIVE_MUTEX_TYPE : TQ_NORMAL_MUTEX_TYPE);
+    TQ_UNUSED(recursive);
+    int ret = pthread_mutex_init(&handle, &attr);
+    pthread_mutexattr_destroy(&attr);
+
+#ifdef TQT_CHECK_RANGE
+    if( ret )
+	qWarning( "Mutex init failure: %s", strerror( ret ) );
+#endif // TQT_CHECK_RANGE
+}
+
+void TQRealMutexPrivate::lock()
+{
+    int ret = pthread_mutex_lock(&handle);
+
+#ifdef TQT_CHECK_RANGE
+    if (ret)
+	qWarning("Mutex lock failure: %s", strerror(ret));
+#endif
+}
+
+void TQRealMutexPrivate::unlock()
+{
+    int ret = pthread_mutex_unlock(&handle);
+
+#ifdef TQT_CHECK_RANGE
+    if (ret)
+	qWarning("Mutex unlock failure: %s", strerror(ret));
+#endif
+}
+
+bool TQRealMutexPrivate::locked()
+{
+    int ret = pthread_mutex_trylock(&handle);
+
+    if (ret == EBUSY) {
+	return TRUE;
+    } else if (ret) {
+#ifdef TQT_CHECK_RANGE
+	qWarning("Mutex locktest failure: %s", strerror(ret));
+#endif
+    } else
+	pthread_mutex_unlock(&handle);
+
+    return FALSE;
+}
+
+bool TQRealMutexPrivate::trylock()
+{
+    int ret = pthread_mutex_trylock(&handle);
+
+    if (ret == EBUSY) {
+	return FALSE;
+    } else if (ret) {
+#ifdef TQT_CHECK_RANGE
+	qWarning("Mutex trylock failure: %s", strerror(ret));
+#endif
+	return FALSE;
+    }
+
+    return TRUE;
+}
+
+int TQRealMutexPrivate::type() const
+{
+    return recursive ? TQ_MUTEX_RECURSIVE : TQ_MUTEX_NORMAL;
+}
+
+
+#ifndef    TQ_RECURSIVE_MUTEX_TYPE
+TQRecursiveMutexPrivate::TQRecursiveMutexPrivate()
+    : count(0), owner(0)
+{
+    pthread_mutexattr_t attr;
+    pthread_mutexattr_init(&attr);
+    TQ_MUTEX_SET_TYPE(&attr, TQ_NORMAL_MUTEX_TYPE);
+    int ret = pthread_mutex_init(&handle, &attr);
+    pthread_mutexattr_destroy(&attr);
+
+#  ifdef TQT_CHECK_RANGE
+    if (ret)
+	qWarning( "Mutex init failure: %s", strerror(ret) );
+#  endif
+
+    pthread_mutexattr_init(&attr);
+    ret = pthread_mutex_init( &handle2, &attr );
+    pthread_mutexattr_destroy(&attr);
+
+#  ifdef TQT_CHECK_RANGE
+    if (ret)
+	qWarning( "Mutex init failure: %s", strerror(ret) );
+#  endif
+}
+
+TQRecursiveMutexPrivate::~TQRecursiveMutexPrivate()
+{
+    int ret = pthread_mutex_destroy(&handle2);
+
+#  ifdef TQT_CHECK_RANGE
+    if (ret)
+	qWarning( "Mutex destroy failure: %s", strerror(ret) );
+#  endif
+}
+
+void TQRecursiveMutexPrivate::lock()
+{
+    pthread_mutex_lock(&handle2);
+
+    if (count > 0 && owner == (unsigned long) pthread_self()) {
+	count++;
+    } else {
+	pthread_mutex_unlock(&handle2);
+	pthread_mutex_lock(&handle);
+	pthread_mutex_lock(&handle2);
+	count = 1;
+	owner = (unsigned long) pthread_self();
+    }
+
+    pthread_mutex_unlock(&handle2);
+}
+
+void TQRecursiveMutexPrivate::unlock()
+{
+    pthread_mutex_lock(&handle2);
+
+    if (owner == (unsigned long) pthread_self()) {
+	// do nothing if the count is already 0... to reflect the behaviour described
+	// in the docs
+	if (count && (--count) < 1) {
+	    count = 0;
+	    pthread_mutex_unlock(&handle);
+	}
+    } else {
+#ifdef TQT_CHECK_RANGE
+	qWarning("TQMutex::unlock: unlock from different thread than locker");
+	qWarning("                was locked by %d, unlock attempt from %d",
+		 (int)owner, (int)pthread_self());
+#endif
+    }
+
+    pthread_mutex_unlock(&handle2);
+}
+
+bool TQRecursiveMutexPrivate::locked()
+{
+    pthread_mutex_lock(&handle2);
+
+    bool ret;
+    int code = pthread_mutex_trylock(&handle);
+
+    if (code == EBUSY) {
+	ret = TRUE;
+    } else {
+#ifdef TQT_CHECK_RANGE
+	if (code)
+	    qWarning("Mutex trylock failure: %s", strerror(code));
+#endif
+
+	pthread_mutex_unlock(&handle);
+	ret = FALSE;
+    }
+
+    pthread_mutex_unlock(&handle2);
+
+    return ret;
+}
+
+bool TQRecursiveMutexPrivate::trylock()
+{
+    bool ret = TRUE;
+
+    pthread_mutex_lock(&handle2);
+
+    if ( count > 0 && owner == (unsigned long) pthread_self() ) {
+	count++;
+    } else {
+        int code = pthread_mutex_trylock(&handle);
+
+	if (code == EBUSY) {
+	    ret = FALSE;
+	} else if (code) {
+#ifdef TQT_CHECK_RANGE
+	    qWarning("Mutex trylock failure: %s", strerror(code));
+#endif
+	    ret = FALSE;
+	} else {
+	    count = 1;
+	    owner = (unsigned long) pthread_self();
+	}
+    }
+
+    pthread_mutex_unlock(&handle2);
+
+    return ret;
+}
+
+int TQRecursiveMutexPrivate::type() const
+{
+    return TQ_MUTEX_RECURSIVE;
+}
+
+#endif // !TQ_RECURSIVE_MUTEX_TYPE
+
+
+/*!
+    \class TQMutex tqmutex.h
+    \threadsafe
+    \brief The TQMutex class provides access serialization between threads.
+
+    \ingroup thread
+    \ingroup environment
+
+    The purpose of a TQMutex is to protect an object, data structure or
+    section of code so that only one thread can access it at a time
+    (This is similar to the Java \c synchronized keyword). For
+    example, say there is a method which prints a message to the user
+    on two lines:
+
+    \code
+    int number = 6;
+
+    void method1()
+    {
+	number *= 5;
+	number /= 4;
+    }
+
+    void method2()
+    {
+	number *= 3;
+	number /= 2;
+    }
+    \endcode
+
+    If these two methods are called in succession, the following happens:
+
+    \code
+    // method1()
+    number *= 5;	// number is now 30
+    number /= 4;	// number is now 7
+
+    // method2()
+    number *= 3;	// nubmer is now 21
+    number /= 2;	// number is now 10
+    \endcode
+
+    If these two methods are called simultaneously from two threads then the
+    following sequence could result:
+
+    \code
+    // Thread 1 calls method1()
+    number *= 5;	// number is now 30
+
+    // Thread 2 calls method2().
+    //
+    // Most likely Thread 1 has been put to sleep by the operating
+    // system to allow Thread 2 to run.
+    number *= 3;	// number is now 90
+    number /= 2;	// number is now 45
+
+    // Thread 1 finishes executing.
+    number /= 4;	// number is now 11, instead of 10
+    \endcode
+
+    If we add a mutex, we should get the result we want:
+
+    \code
+    TQMutex mutex;
+    int number = 6;
+
+    void method1()
+    {
+	mutex.lock();
+	number *= 5;
+	number /= 4;
+	mutex.unlock();
+    }
+
+    void method2()
+    {
+	mutex.lock();
+	number *= 3;
+	number /= 2;
+	mutex.unlock();
+    }
+    \endcode
+
+    Then only one thread can modify \c number at any given time and
+    the result is correct. This is a trivial example, of course, but
+    applies to any other case where things need to happen in a
+    particular sequence.
+
+    When you call lock() in a thread, other threads that try to call
+    lock() in the same place will block until the thread that got the
+    lock calls unlock(). A non-blocking alternative to lock() is
+    tryLock().
+*/
+
+/*!
+    Constructs a new mutex. The mutex is created in an unlocked state.
+    A recursive mutex is created if \a recursive is TRUE; a normal
+    mutex is created if \a recursive is FALSE (the default). With a
+    recursive mutex, a thread can lock the same mutex multiple times
+    and it will not be unlocked until a corresponding number of
+    unlock() calls have been made.
+*/
+TQMutex::TQMutex(bool recursive)
+{
+#ifndef    TQ_RECURSIVE_MUTEX_TYPE
+    if ( recursive )
+	d = new TQRecursiveMutexPrivate();
+    else
+#endif // !TQ_RECURSIVE_MUTEX_TYPE
+	d = new TQRealMutexPrivate(recursive);
+}
+
+/*!
+    Destroys the mutex.
+
+    \warning If you destroy a mutex that still holds a lock the
+    resultant behavior is undefined.
+*/
+TQMutex::~TQMutex()
+{
+    delete d;
+}
+
+/*!
+    Attempt to lock the mutex. If another thread has locked the mutex
+    then this call will \e block until that thread has unlocked it.
+
+    \sa unlock(), locked()
+*/
+void TQMutex::lock()
+{
+    d->lock();
+}
+
+/*!
+    Unlocks the mutex. Attempting to unlock a mutex in a different
+    thread to the one that locked it results in an error. Unlocking a
+    mutex that is not locked results in undefined behaviour (varies
+    between different Operating Systems' thread implementations).
+
+    \sa lock(), locked()
+*/
+void TQMutex::unlock()
+{
+    d->unlock();
+}
+
+/*!
+    Returns TRUE if the mutex is locked by another thread; otherwise
+    returns FALSE.
+
+    \warning Due to differing implementations of recursive mutexes on
+    various platforms, calling this function from the same thread that
+    previously locked the mutex will return undefined results.
+
+    \sa lock(), unlock()
+*/
+bool TQMutex::locked()
+{
+    return d->locked();
+}
+
+/*!
+    Attempt to lock the mutex. If the lock was obtained, this function
+    returns TRUE. If another thread has locked the mutex, this
+    function returns FALSE, instead of waiting for the mutex to become
+    available, i.e. it does not block.
+
+    If the lock was obtained, the mutex must be unlocked with unlock()
+    before another thread can successfully lock it.
+
+    \sa lock(), unlock(), locked()
+*/
+bool TQMutex::tryLock()
+{
+    return d->trylock();
+}
+
+/*!
+    \class TQMutexLocker tqmutex.h
+    \brief The TQMutexLocker class simplifies locking and unlocking TQMutexes.
+
+    \threadsafe
+
+    \ingroup thread
+    \ingroup environment
+
+    The purpose of TQMutexLocker is to simplify TQMutex locking and
+    unlocking. Locking and unlocking a TQMutex in complex functions and
+    statements or in exception handling code is error prone and
+    difficult to debug. TQMutexLocker should be used in such situations
+    to ensure that the state of the mutex is well defined and always
+    locked and unlocked properly.
+
+    TQMutexLocker should be created within a function where a TQMutex
+    needs to be locked. The mutex is locked when TQMutexLocker is
+    created, and unlocked when TQMutexLocker is destroyed.
+
+    For example, this complex function locks a TQMutex upon entering
+    the function and unlocks the mutex at all the exit points:
+
+    \code
+    int complexFunction( int flag )
+    {
+	mutex.lock();
+
+	int return_value = 0;
+
+	switch ( flag ) {
+	case 0:
+	case 1:
+	    {
+		mutex.unlock();
+		return moreComplexFunction( flag );
+	    }
+
+	case 2:
+	    {
+		int status = anotherFunction();
+		if ( status < 0 ) {
+		    mutex.unlock();
+		    return -2;
+		}
+		return_value = status + flag;
+		break;
+	    }
+
+	default:
+	    {
+		if ( flag > 10 ) {
+		    mutex.unlock();
+		    return -1;
+		}
+		break;
+	    }
+	}
+
+	mutex.unlock();
+	return return_value;
+    }
+    \endcode
+
+    This example function will get more complicated as it is
+    developed, which increases the likelihood that errors will occur.
+
+    Using TQMutexLocker greatly simplifies the code, and makes it more
+    readable:
+
+    \code
+    int complexFunction( int flag )
+    {
+	TQMutexLocker locker( &mutex );
+
+	int return_value = 0;
+
+	switch ( flag ) {
+	case 0:
+	case 1:
+	    {
+		return moreComplexFunction( flag );
+	    }
+
+	case 2:
+	    {
+		int status = anotherFunction();
+		if ( status < 0 )
+		    return -2;
+		return_value = status + flag;
+		break;
+	    }
+
+	default:
+	    {
+		if ( flag > 10 )
+		    return -1;
+		break;
+	    }
+	}
+
+	return return_value;
+    }
+    \endcode
+
+    Now, the mutex will always be unlocked when the TQMutexLocker
+    object is destroyed (when the function returns since \c locker is
+    an auto variable). Note that the mutex will be unlocked after
+    the call to moreComplexFunction() in this example, avoiding
+    possible bugs caused by unlocking the mutex too early, as in
+    the first example.
+
+    The same principle applies to code that throws and catches
+    exceptions. An exception that is not caught in the function that
+    has locked the mutex has no way of unlocking the mutex before the
+    exception is passed up the stack to the calling function.
+
+    TQMutexLocker also provides a mutex() member function that returns
+    the mutex on which the TQMutexLocker is operating. This is useful
+    for code that needs access to the mutex, such as
+    TQWaitCondition::wait(). For example:
+
+    \code
+    class SignalWaiter
+    {
+    private:
+	TQMutexLocker locker;
+
+    public:
+	SignalWaiter( TQMutex *mutex )
+	    : locker( mutex )
+	{
+	}
+
+	void waitForSignal()
+	{
+	    ...
+	    ...
+	    ...
+
+	    while ( ! signalled )
+		waitcondition.wait( locker.mutex() );
+
+	    ...
+	    ...
+	    ...
+	}
+    };
+    \endcode
+
+    \sa TQMutex, TQWaitCondition
+*/
+
+/*!
+    \fn TQMutexLocker::TQMutexLocker( TQMutex *mutex )
+
+    Constructs a TQMutexLocker and locks \a mutex. The mutex will be
+    unlocked when the TQMutexLocker is destroyed. If \a mutex is zero,
+    TQMutexLocker does nothing.
+
+    \sa TQMutex::lock()
+*/
+
+/*!
+    \fn TQMutexLocker::~TQMutexLocker()
+
+    Destroys the TQMutexLocker and unlocks the mutex which was locked
+    in the constructor.
+
+    \sa TQMutexLocker::TQMutexLocker(), TQMutex::unlock()
+*/
+
+/*!
+    \fn TQMutex *TQMutexLocker::mutex() const
+
+    Returns a pointer to the mutex which was locked in the
+    constructor.
+
+    \sa TQMutexLocker::TQMutexLocker()
+*/
+
+#endif // TQT_THREAD_SUPPORT
diff --git a/tqtinterface/qt4/src/tools/tqmutexpool.cpp b/tqtinterface/qt4/src/tools/tqmutexpool.cpp
new file mode 100644
index 0000000..3b14922
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqmutexpool.cpp
@@ -0,0 +1,155 @@
+/****************************************************************************
+**
+** ...
+**
+** Copyright (C) 2005-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "tqmutexpool_p.h"
+
+#ifdef TQT_THREAD_SUPPORT
+
+#include <tqthread.h>
+
+TQ_EXPORT TQMutexPool *tqt_global_mutexpool = 0;
+
+
+/*!
+    \class TQMutexPool qmutexpool_p.h
+    \brief The TQMutexPool class provides a pool of TQMutex objects.
+
+    \internal
+
+    \ingroup thread
+
+    TQMutexPool is a convenience class that provides access to a fixed
+    number of TQMutex objects.
+
+    Typical use of a TQMutexPool is in situations where it is not
+    possible or feasible to use one TQMutex for every protected object.
+    The mutex pool will return a mutex based on the address of the
+    object that needs protection.
+
+    For example, consider this simple class:
+
+    \code
+    class Number {
+    public:
+	Number( double n ) : num ( n ) { }
+
+	void setNumber( double n ) { num = n; }
+	double number() const { return num; }
+
+    private:
+	double num;
+    };
+    \endcode
+
+    Adding a TQMutex member to the Number class does not make sense,
+    because it is so small. However, in order to ensure that access to
+    each Number is protected, you need to use a mutex. In this case, a
+    TQMutexPool would be ideal.
+
+    Code to calculate the square of a number would then look something
+    like this:
+
+    \code
+    void calcSquare( Number *num )
+    {
+	TQMutexLocker locker( mutexpool.get( num ) );
+	num.setNumber( num.number() * num.number() );
+    }
+    \endcode
+
+    This function will safely calculate the square of a number, since
+    it uses a mutex from a TQMutexPool. The mutex is locked and
+    unlocked automatically by the TQMutexLocker class. See the
+    TQMutexLocker documentation for more details.
+*/
+
+/*!
+    Constructs  a TQMutexPool, reserving space for \a size TQMutexes. If
+    \a recursive is TRUE, all TQMutexes in the pool will be recursive
+    mutexes; otherwise they will all be non-recursive (the default).
+
+    The TQMutexes are created when needed, and deleted when the
+    TQMutexPool is destructed.
+*/
+TQMutexPool::TQMutexPool( bool recursive, int size )
+    : mutex( FALSE ), count( size ), recurs( recursive )
+{
+    mutexes = new TQMutex*[count];
+    for ( int index = 0; index < count; ++index ) {
+	mutexes[index] = 0;
+    }
+}
+
+/*!
+    Destructs a TQMutexPool. All TQMutexes that were created by the pool
+    are deleted.
+*/
+TQMutexPool::~TQMutexPool()
+{
+    TQMutexLocker locker( &mutex );
+    for ( int index = 0; index < count; ++index ) {
+	delete mutexes[index];
+	mutexes[index] = 0;
+    }
+    delete [] mutexes;
+    mutexes = 0;
+}
+
+/*!
+    Returns a TQMutex from the pool. TQMutexPool uses the value \a
+    address to determine which mutex is retured from the pool.
+*/
+TQMutex *TQMutexPool::get( void *address )
+{
+    int index = (int) ( (unsigned long) address % count );
+
+    if ( ! mutexes[index] ) {
+	// mutex not created, create one
+
+	TQMutexLocker locker( &mutex );
+	// we need to check once again that the mutex hasn't been created, since
+	// 2 threads could be trying to create a mutex as the same index...
+	if ( ! mutexes[index] ) {
+	    mutexes[index] = new TQMutex( recurs );
+	}
+    }
+
+    return mutexes[index];
+}
+
+#endif
diff --git a/tqtinterface/qt4/src/tools/tqmutexpool_p.h b/tqtinterface/qt4/src/tools/tqmutexpool_p.h
new file mode 100644
index 0000000..4293274
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqmutexpool_p.h
@@ -0,0 +1,80 @@
+/****************************************************************************
+**
+** ...
+**
+** Copyright (C) 2005-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQMUTEXPOOL_P_H
+#define TQMUTEXPOOL_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the TQt API.  It exists for the convenience
+// of TQSettings. This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+//
+
+#ifdef TQT_THREAD_SUPPORT
+
+#ifndef TQT_H
+#include "tqmutex.h"
+#include "tqmemarray.h"
+#endif // TQT_H
+
+class TQ_EXPORT TQMutexPool
+{
+public:
+    TQMutexPool( bool recursive = FALSE, int size = 17 );
+    ~TQMutexPool();
+
+    TQMutex *get( void *address );
+
+private:
+    TQMutex mutex;
+    TQMutex **mutexes;
+    int count;
+    bool recurs;
+};
+
+extern TQ_EXPORT TQMutexPool *tqt_global_mutexpool;
+
+#endif // TQT_THREAD_SUPPORT
+
+#endif // TQMUTEXPOOL_P_H
diff --git a/tqtinterface/qt4/src/tools/tqpair.h b/tqtinterface/qt4/src/tools/tqpair.h
new file mode 100644
index 0000000..0f1d743
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqpair.h
@@ -0,0 +1,109 @@
+/****************************************************************************
+**
+** Definition of TQPair class
+**
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQPAIR_H
+#define TQPAIR_H
+
+#ifndef TQT_H
+#include "tqglobal.h"
+#include "tqdatastream.h"
+#endif // TQT_H
+
+template <class T1, class T2>
+struct TQPair
+{
+    typedef T1 first_type;
+    typedef T2 second_type;
+
+    TQPair()
+	: first( T1() ), second( T2() )
+    {}
+    TQPair( const T1& t1, const T2& t2 )
+	: first( t1 ), second( t2 )
+    {}
+
+    TQPair<T1, T2>& operator=(const TQPair<T1, T2>& other)
+    {
+	if (this != &other) {
+	    first = other.first;
+	    second = other.second;
+	}
+	return *this;
+    }
+
+    T1 first;
+    T2 second;
+};
+
+template <class T1, class T2>
+TQ_INLINE_TEMPLATES bool operator==( const TQPair<T1, T2>& x, const TQPair<T1, T2>& y )
+{
+    return x.first == y.first && x.second == y.second;
+}
+
+template <class T1, class T2>
+TQ_INLINE_TEMPLATES bool operator<( const TQPair<T1, T2>& x, const TQPair<T1, T2>& y )
+{
+    return x.first < y.first ||
+	   ( !( y.first < x.first ) && x.second < y.second );
+}
+
+template <class T1, class T2>
+TQ_INLINE_TEMPLATES TQPair<T1, T2> tqMakePair( const T1& x, const T2& y )
+{
+    return TQPair<T1, T2>( x, y );
+}
+
+#ifndef TQT_NO_DATASTREAM
+template <class T1, class T2>
+inline TQDataStream& operator>>( TQDataStream& s, TQPair<T1, T2>& p )
+{
+    s >> p.first >> p.second;
+    return s;
+}
+
+template <class T1, class T2>
+inline TQDataStream& operator<<( TQDataStream& s, const TQPair<T1, T2>& p )
+{
+    s << p.first << p.second;
+    return s;
+}
+#endif
+
+#endif
diff --git a/tqtinterface/qt4/src/tools/tqpluginmanager_p.h b/tqtinterface/qt4/src/tools/tqpluginmanager_p.h
new file mode 100644
index 0000000..58b9b26
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqpluginmanager_p.h
@@ -0,0 +1,74 @@
+/****************************************************************************
+**
+** Definition of TQPluginManager class
+**
+** Created : 000101
+**
+** Copyright (C) 2000-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQPLUGINMANAGER_P_H
+#define TQPLUGINMANAGER_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the TQt API.  It exists for the convenience
+// of a number of TQt sources files.  This header file may change from
+// version to version without notice, or even be removed.
+//
+// We mean it.
+//
+//
+
+#include "tqgpluginmanager_p.h"
+
+#ifndef TQT_NO_COMPONENT
+
+template<class Type>
+class TQPluginManager : public TQGPluginManager
+{
+public:
+    TQPluginManager( const TQUuid& id, const QStringList& paths = TQString::null, const TQString &suffix = TQString::null, bool cs = TRUE )
+	: TQGPluginManager( id, TQT_TQSTRINGLIST_OBJECT(paths), suffix, cs ) {}
+    TQRESULT queryInterface(const TQString& feature, Type** iface) const
+    {
+	return queryUnknownInterface( feature, (TQUnknownInterface**)iface );
+    }
+};
+
+#endif //TQT_NO_COMPONENT
+
+#endif //TQPLUGINMANAGER_P_H
diff --git a/tqtinterface/qt4/src/tools/tqptrcollection.cpp b/tqtinterface/qt4/src/tools/tqptrcollection.cpp
new file mode 100644
index 0000000..38bbeef
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqptrcollection.cpp
@@ -0,0 +1,183 @@
+/****************************************************************************
+**
+** Implementation of base class for all pointer based collection classes
+**
+** Created : 920820
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "tqptrcollection.h"
+
+/*!
+    \class TQPtrCollection tqptrcollection.h
+    \reentrant
+    \brief The TQPtrCollection class is the base class of most pointer-based TQt collections.
+
+    \ingroup collection
+    \ingroup tools
+
+    The TQPtrCollection class is an abstract base class for the TQt
+    \link collection.html collection classes\endlink TQDict, TQPtrList,
+    etc. TQt also includes value based collections, e.g. TQValueList,
+    TQMap, etc.
+
+    A TQPtrCollection only knows about the number of objects in the
+    collection and the deletion strategy (see setAutoDelete()).
+
+    A collection is implemented using the \c Item (generic collection
+    item) type, which is a \c void*. The template classes that create
+    the real collections cast the \c Item to the required type.
+*/
+
+
+/*!
+    \enum TQPtrCollection::Item
+
+    This type is the generic "item" in a TQPtrCollection.
+*/
+
+
+/*!
+    \fn TQPtrCollection::TQPtrCollection()
+
+    Constructs a collection. The constructor is protected because
+    TQPtrCollection is an abstract class.
+*/
+
+/*!
+    \fn TQPtrCollection::TQPtrCollection( const TQPtrCollection & source )
+
+    Constructs a copy of \a source with autoDelete() set to FALSE. The
+    constructor is protected because TQPtrCollection is an abstract
+    class.
+
+    Note that if \a source has autoDelete turned on, copying it will
+    risk memory leaks, reading freed memory, or both.
+*/
+
+/*!
+    \fn TQPtrCollection::~TQPtrCollection()
+
+    Destroys the collection. The destructor is protected because
+    TQPtrCollection is an abstract class.
+*/
+
+
+/*!
+    \fn bool TQPtrCollection::autoDelete() const
+
+    Returns the setting of the auto-delete option. The default is FALSE.
+
+    \sa setAutoDelete()
+*/
+
+/*!
+    \fn void TQPtrCollection::setAutoDelete( bool enable )
+
+    Sets the collection to auto-delete its contents if \a enable is
+    TRUE and to never delete them if \a enable is FALSE.
+
+    If auto-deleting is turned on, all the items in a collection are
+    deleted when the collection itself is deleted. This is convenient
+    if the collection has the only pointer to the items.
+
+    The default setting is FALSE, for safety. If you turn it on, be
+    careful about copying the collection - you might tqfind yourself
+    with two collections deleting the same items.
+
+    Note that the auto-delete setting may also affect other functions
+    in subclasses. For example, a subclass that has a remove()
+    function will remove the item from its data structure, and if
+    auto-delete is enabled, will also delete the item.
+
+    \sa autoDelete()
+*/
+
+
+/*!
+    \fn virtual uint TQPtrCollection::count() const
+
+    Returns the number of objects in the collection.
+*/
+
+/*!
+    \fn virtual void TQPtrCollection::clear()
+
+    Removes all objects from the collection. The objects will be
+    deleted if auto-delete has been enabled.
+
+    \sa setAutoDelete()
+*/
+
+/*!
+    \fn void TQPtrCollection::deleteItem( Item d )
+
+    Reimplement this function if you want to be able to delete items.
+
+    Deletes an item that is about to be removed from the collection.
+
+    This function has to reimplemented in the collection template
+    classes, and should \e only delete item \a d if auto-delete has
+    been enabled.
+
+    \warning If you reimplement this function you must also
+    reimplement the destructor and call the virtual function clear()
+    from your destructor. This is due to the way virtual functions and
+    destructors work in C++: Virtual functions in derived classes
+    cannot be called from a destructor. If you do not do this, your
+    deleteItem() function will not be called when the container is
+    destroyed.
+
+    \sa newItem(), setAutoDelete()
+*/
+
+/*!
+    Virtual function that creates a copy of an object that is about to
+    be inserted into the collection.
+
+    The default implementation returns the \a d pointer, i.e. no copy
+    is made.
+
+    This function is seldom reimplemented in the collection template
+    classes. It is not common practice to make a copy of something
+    that is being inserted.
+
+    \sa deleteItem()
+*/
+
+TQPtrCollection::Item TQPtrCollection::newItem( Item d )
+{
+    return d;					// just return reference
+}
diff --git a/tqtinterface/qt4/src/tools/tqptrcollection.h b/tqtinterface/qt4/src/tools/tqptrcollection.h
new file mode 100644
index 0000000..86bc2e2
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqptrcollection.h
@@ -0,0 +1,80 @@
+/****************************************************************************
+**
+** Definition of base class for all pointer based collection classes
+**
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQPTRCOLLECTION_H
+#define TQPTRCOLLECTION_H
+
+#ifndef TQT_H
+#include "tqglobal.h"
+#endif // TQT_H
+
+
+class TQGVector;
+class TQGList;
+class TQGDict;
+
+
+class TQ_EXPORT TQPtrCollection			// inherited by all collections
+{
+public:
+    bool autoDelete()	const	       { return del_item; }
+    void setAutoDelete( bool enable )  { del_item = enable; }
+
+    virtual uint  count() const = 0;
+    virtual void  clear() = 0;			// delete all objects
+
+    typedef void *Item;				// generic collection item
+
+protected:
+    TQPtrCollection() { del_item = FALSE; }		// no deletion of objects
+    TQPtrCollection(const TQPtrCollection &) { del_item = FALSE; }
+    virtual ~TQPtrCollection() {}
+
+    bool del_item;				// default FALSE
+
+    virtual Item     newItem( Item );		// create object
+    virtual void     deleteItem( Item ) = 0;	// delete object
+};
+
+
+#ifndef TQT_NO_COMPAT
+#define TQCollection TQPtrCollection
+#endif
+
+#endif // TQPTRCOLLECTION_H
diff --git a/tqtinterface/qt4/src/tools/tqptrdict.h b/tqtinterface/qt4/src/tools/tqptrdict.h
new file mode 100644
index 0000000..908907d
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqptrdict.h
@@ -0,0 +1,118 @@
+/****************************************************************************
+**
+** Definition of TQPtrDict template class
+**
+** Created : 970415
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQPTRDICT_H
+#define TQPTRDICT_H
+
+#ifndef TQT_H
+#include "tqgdict.h"
+#endif // TQT_H
+
+template<class type>
+class TQPtrDict
+#ifdef TQ_TQDOC
+	: public TQPtrCollection
+#else
+	: public TQGDict
+#endif
+{
+public:
+    TQPtrDict(int size=17) : TQGDict(size,PtrKey,0,0) {}
+    TQPtrDict( const TQPtrDict<type> &d ) : TQGDict(d) {}
+   ~TQPtrDict()				{ clear(); }
+    TQPtrDict<type> &operator=(const TQPtrDict<type> &d)
+			{ return (TQPtrDict<type>&)TQGDict::operator=(d); }
+    uint  count()   const		{ return TQGDict::count(); }
+    uint  size()    const		{ return TQGDict::size(); }
+    bool  isEmpty() const		{ return TQGDict::count() == 0; }
+    void  insert( void *k, const type *d )
+					{ TQGDict::look_ptr(k,(Item)d,1); }
+    void  tqreplace( void *k, const type *d )
+					{ TQGDict::look_ptr(k,(Item)d,2); }
+    bool  remove( void *k )		{ return TQGDict::remove_ptr(k); }
+    type *take( void *k )		{ return (type*)TQGDict::take_ptr(k); }
+    type *tqfind( void *k ) const
+		{ return (type *)((TQGDict*)this)->TQGDict::look_ptr(k,0,0); }
+    type *operator[]( void *k ) const
+		{ return (type *)((TQGDict*)this)->TQGDict::look_ptr(k,0,0); }
+    void  clear()			{ TQGDict::clear(); }
+    void  resize( uint n )		{ TQGDict::resize(n); }
+    void  statistics() const		{ TQGDict::statistics(); }
+
+#ifdef TQ_TQDOC
+protected:
+    virtual TQDataStream& read( TQDataStream &, TQPtrCollection::Item & );
+    virtual TQDataStream& write( TQDataStream &, TQPtrCollection::Item ) const;
+#endif
+
+private:
+    void  deleteItem( Item d );
+};
+
+#if !defined(TQ_BROKEN_TEMPLATE_SPECIALIZATION)
+template<> inline void TQPtrDict<void>::deleteItem( TQPtrCollection::Item )
+{
+}
+#endif
+
+template<class type>
+inline void TQPtrDict<type>::deleteItem( TQPtrCollection::Item d )
+{
+    if ( del_item ) delete (type *)d;
+}
+
+template<class type>
+class TQPtrDictIterator : public TQGDictIterator
+{
+public:
+    TQPtrDictIterator(const TQPtrDict<type> &d) :TQGDictIterator((TQGDict &)d) {}
+   ~TQPtrDictIterator()	      {}
+    uint  count()   const     { return dict->count(); }
+    bool  isEmpty() const     { return dict->count() == 0; }
+    type *toFirst()	      { return (type *)TQGDictIterator::toFirst(); }
+    operator type *()  const  { return (type *)TQGDictIterator::get(); }
+    type *current()    const  { return (type *)TQGDictIterator::get(); }
+    void *currentKey() const  { return TQGDictIterator::getKeyPtr(); }
+    type *operator()()	      { return (type *)TQGDictIterator::operator()(); }
+    type *operator++()	      { return (type *)TQGDictIterator::operator++(); }
+    type *operator+=(uint j)  { return (type *)TQGDictIterator::operator+=(j);}
+};
+
+#endif // TQPTRDICT_H
diff --git a/tqtinterface/qt4/src/tools/tqptrlist.h b/tqtinterface/qt4/src/tools/tqptrlist.h
new file mode 100644
index 0000000..2839df6
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqptrlist.h
@@ -0,0 +1,197 @@
+/****************************************************************************
+**
+** Definition of TQPtrList template/macro class
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQPTRLIST_H
+#define TQPTRLIST_H
+
+#ifndef TQT_H
+#include "tqglist.h"
+#endif // TQT_H
+
+template<class type>
+class TQPtrListStdIterator : public TQGListStdIterator
+{
+public:
+    inline TQPtrListStdIterator( TQLNode* n ): TQGListStdIterator(n) {}
+    type *operator*() { return node ? (type *)node->getData() : 0; }
+    inline TQPtrListStdIterator<type> operator++()
+    { node = next(); return *this; }
+    inline TQPtrListStdIterator<type> operator++(int)
+    { TQLNode* n = node; node = next(); return TQPtrListStdIterator<type>( n ); }
+    inline bool operator==( const TQPtrListStdIterator<type>& it ) const { return node == it.node; }
+    inline bool operator!=( const TQPtrListStdIterator<type>& it ) const { return node != it.node; }
+};
+
+
+template<class type>
+class TQPtrList
+#ifdef TQ_TQDOC
+	: public TQPtrCollection
+#else
+	: public TQGList
+#endif
+{
+public:
+
+    TQPtrList()				{}
+    TQPtrList( const TQPtrList<type> &l ) : TQGList(l) {}
+    ~TQPtrList()				{ clear(); }
+    TQPtrList<type> &operator=(const TQPtrList<type> &l)
+			{ return (TQPtrList<type>&)TQGList::operator=(l); }
+    bool operator==( const TQPtrList<type> &list ) const
+    { return TQGList::operator==( list ); }
+    bool operator!=( const TQPtrList<type> &list ) const
+    { return !TQGList::operator==( list ); }
+    uint  count()   const		{ return TQGList::count(); }
+    bool  isEmpty() const		{ return TQGList::count() == 0; }
+    bool  insert( uint i, const type *d){ return TQGList::insertAt(i,(TQPtrCollection::Item)d); }
+    void  inSort( const type *d )	{ TQGList::inSort((TQPtrCollection::Item)d); }
+    void  prepend( const type *d )	{ TQGList::insertAt(0,(TQPtrCollection::Item)d); }
+    void  append( const type *d )	{ TQGList::append((TQPtrCollection::Item)d); }
+    bool  remove( uint i )		{ return TQGList::removeAt(i); }
+    bool  remove()			{ return TQGList::remove((TQPtrCollection::Item)0); }
+    bool  remove( const type *d )	{ return TQGList::remove((TQPtrCollection::Item)d); }
+    bool  removeRef( const type *d )	{ return TQGList::removeRef((TQPtrCollection::Item)d); }
+    void  removeNode( TQLNode *n )	{ TQGList::removeNode(n); }
+    bool  removeFirst()			{ return TQGList::removeFirst(); }
+    bool  removeLast()			{ return TQGList::removeLast(); }
+    type *take( uint i )		{ return (type *)TQGList::takeAt(i); }
+    type *take()			{ return (type *)TQGList::take(); }
+    type *takeNode( TQLNode *n )		{ return (type *)TQGList::takeNode(n); }
+    void  clear()			{ TQGList::clear(); }
+    void  sort()			{ TQGList::sort(); }
+    int	  tqfind( const type *d )		{ return TQGList::tqfind((TQPtrCollection::Item)d); }
+    int	  tqfindNext( const type *d )	{ return TQGList::tqfind((TQPtrCollection::Item)d,FALSE); }
+    int	  tqfindRef( const type *d )	{ return TQGList::tqfindRef((TQPtrCollection::Item)d); }
+    int	  tqfindNextRef( const type *d ){ return TQGList::tqfindRef((TQPtrCollection::Item)d,FALSE);}
+    uint  tqcontains( const type *d ) const { return TQGList::tqcontains((TQPtrCollection::Item)d); }
+    uint  tqcontainsRef( const type *d ) const
+					{ return TQGList::tqcontainsRef((TQPtrCollection::Item)d); }
+    bool tqreplace( uint i, const type *d ) { return TQGList::tqreplaceAt( i, (TQPtrCollection::Item)d ); }
+    type *at( uint i )			{ return (type *)TQGList::at(i); }
+    type *tqat( uint i )		{ return (type *)TQGList::at(i); }
+    int	  at() const			{ return TQGList::at(); }
+    int	  tqat() const			{ return TQGList::at(); }
+    type *current()  const		{ return (type *)TQGList::get(); }
+    TQLNode *currentNode()  const	{ return TQGList::currentNode(); }
+    type *getFirst() const		{ return (type *)TQGList::cfirst(); }
+    type *getLast()  const		{ return (type *)TQGList::clast(); }
+    type *first()			{ return (type *)TQGList::first(); }
+    type *last()			{ return (type *)TQGList::last(); }
+    type *next()			{ return (type *)TQGList::next(); }
+    type *prev()			{ return (type *)TQGList::prev(); }
+    void  toVector( TQGVector *vec )const{ TQGList::toVector(vec); }
+
+
+    // standard iterators
+    typedef TQPtrListStdIterator<type> Iterator;
+    typedef TQPtrListStdIterator<type> ConstIterator;
+    inline Iterator begin() { return TQGList::begin(); }
+    inline ConstIterator begin() const { return TQGList::begin(); }
+    inline ConstIterator constBegin() const { return TQGList::begin(); }
+    inline Iterator end() { return TQGList::end(); }
+    inline ConstIterator end() const { return TQGList::end(); }
+    inline ConstIterator constEnd() const { return TQGList::end(); }
+    inline Iterator erase( Iterator it ) { return TQGList::erase( it ); }
+    // stl syntax compatibility
+    typedef Iterator iterator;
+    typedef ConstIterator const_iterator;
+
+
+#ifdef TQ_TQDOC
+protected:
+    virtual int compareItems( TQPtrCollection::Item, TQPtrCollection::Item );
+    virtual TQDataStream& read( TQDataStream&, TQPtrCollection::Item& );
+    virtual TQDataStream& write( TQDataStream&, TQPtrCollection::Item ) const;
+#endif
+
+private:
+    void  deleteItem( Item d );
+};
+
+#if !defined(TQ_BROKEN_TEMPLATE_SPECIALIZATION)
+template<> inline void TQPtrList<void>::deleteItem( TQPtrCollection::Item )
+{
+}
+#endif
+
+template<class type> inline void TQPtrList<type>::deleteItem( TQPtrCollection::Item d )
+{
+    if ( del_item ) delete (type *)d;
+}
+
+template<class type>
+class TQPtrListIterator : public TQGListIterator
+{
+public:
+    TQPtrListIterator(const TQPtrList<type> &l) :TQGListIterator((TQGList &)l) {}
+   ~TQPtrListIterator()	      {}
+    uint  count()   const     { return list->count(); }
+    bool  isEmpty() const     { return list->count() == 0; }
+    bool  atFirst() const     { return TQGListIterator::atFirst(); }
+    bool  atLast()  const     { return TQGListIterator::atLast(); }
+    type *toFirst()	      { return (type *)TQGListIterator::toFirst(); }
+    type *toLast()	      { return (type *)TQGListIterator::toLast(); }
+    operator type *() const   { return (type *)TQGListIterator::get(); }
+    type *operator*()         { return (type *)TQGListIterator::get(); }
+
+    // No good, since TQPtrList<char> (ie. TQStrList fails...
+    //
+    // MSVC++ gives warning
+    // Sunpro C++ 4.1 gives error
+    //    type *operator->()        { return (type *)TQGListIterator::get(); }
+
+    type *current()   const   { return (type *)TQGListIterator::get(); }
+    type *operator()()	      { return (type *)TQGListIterator::operator()();}
+    type *operator++()	      { return (type *)TQGListIterator::operator++(); }
+    type *operator+=(uint j)  { return (type *)TQGListIterator::operator+=(j);}
+    type *operator--()	      { return (type *)TQGListIterator::operator--(); }
+    type *operator-=(uint j)  { return (type *)TQGListIterator::operator-=(j);}
+    TQPtrListIterator<type>& operator=(const TQPtrListIterator<type>&it)
+			      { TQGListIterator::operator=(it); return *this; }
+};
+
+#ifndef TQT_NO_COMPAT
+#define TQList TQPtrList
+#define TQListIterator TQPtrListIterator
+#endif
+
+#define TQ_DEFINED_TQPTRLIST
+#include "tqwinexport.h"
+
+#endif // TQPTRLIST_H
diff --git a/tqtinterface/qt4/src/tools/tqptrqueue.h b/tqtinterface/qt4/src/tools/tqptrqueue.h
new file mode 100644
index 0000000..d7122cd
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqptrqueue.h
@@ -0,0 +1,94 @@
+/****************************************************************************
+**
+** Definition of TQPtrQueue template/macro class
+**
+** Created : 920917
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQPTRTQUEUE_H
+#define TQPTRTQUEUE_H
+
+#ifndef TQT_H
+#include "tqglist.h"
+#endif // TQT_H
+
+template<class type>
+class TQPtrQueue : protected TQGList
+{
+public:
+    TQPtrQueue()				{}
+    TQPtrQueue( const TQPtrQueue<type> &q ) : TQGList(q) {}
+    ~TQPtrQueue()			{ clear(); }
+    TQPtrQueue<type>& operator=(const TQPtrQueue<type> &q)
+			{ return (TQPtrQueue<type>&)TQGList::operator=(q); }
+    bool  autoDelete() const		{ return TQPtrCollection::autoDelete(); }
+    void  setAutoDelete( bool del )	{ TQPtrCollection::setAutoDelete(del); }
+    uint  count()   const		{ return TQGList::count(); }
+    bool  isEmpty() const		{ return TQGList::count() == 0; }
+    void  enqueue( const type *d )	{ TQGList::append(Item(d)); }
+    type *dequeue()			{ return (type *)TQGList::takeFirst();}
+    bool  remove()			{ return TQGList::removeFirst(); }
+    void  clear()			{ TQGList::clear(); }
+    type *head()    const		{ return (type *)TQGList::cfirst(); }
+	  operator type *() const	{ return (type *)TQGList::cfirst(); }
+    type *current() const		{ return (type *)TQGList::cfirst(); }
+
+#ifdef TQ_TQDOC
+protected:
+    virtual TQDataStream& read( TQDataStream&, TQPtrCollection::Item& );
+    virtual TQDataStream& write( TQDataStream&, TQPtrCollection::Item ) const;
+#endif
+
+private:
+    void  deleteItem( Item d );
+};
+
+#if !defined(TQ_BROKEN_TEMPLATE_SPECIALIZATION)
+template<> inline void TQPtrQueue<void>::deleteItem( TQPtrCollection::Item )
+{
+}
+#endif
+
+template<class type> inline void TQPtrQueue<type>::deleteItem( TQPtrCollection::Item d )
+{
+    if ( del_item ) delete (type *)d;
+}
+
+#ifndef TQT_NO_COMPAT
+#define TQQueue TQPtrQueue
+#endif
+
+#endif // TQPTRTQUEUE_H
diff --git a/tqtinterface/qt4/src/tools/tqptrstack.h b/tqtinterface/qt4/src/tools/tqptrstack.h
new file mode 100644
index 0000000..1ab0d65
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqptrstack.h
@@ -0,0 +1,94 @@
+/****************************************************************************
+**
+** Definition of TQPtrStack pointer based template class
+**
+** Created : 920917
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQPTRSTACK_H
+#define TQPTRSTACK_H
+
+#ifndef TQT_H
+#include "tqglist.h"
+#endif // TQT_H
+
+template<class type>
+class TQPtrStack : protected TQGList
+{
+public:
+    TQPtrStack()				{ }
+    TQPtrStack( const TQPtrStack<type> &s ) : TQGList( s ) { }
+    ~TQPtrStack()			{ clear(); }
+    TQPtrStack<type> &operator=(const TQPtrStack<type> &s)
+			{ return (TQPtrStack<type>&)TQGList::operator=(s); }
+    bool  autoDelete() const		{ return TQPtrCollection::autoDelete(); }
+    void  setAutoDelete( bool del )	{ TQPtrCollection::setAutoDelete(del); }
+    uint  count()   const		{ return TQGList::count(); }
+    bool  isEmpty() const		{ return TQGList::count() == 0; }
+    void  push( const type *d )		{ TQGList::insertAt(0,Item(d)); }
+    type *pop()				{ return (type *)TQGList::takeFirst(); }
+    bool  remove()			{ return TQGList::removeFirst(); }
+    void  clear()			{ TQGList::clear(); }
+    type *top()	    const		{ return (type *)TQGList::cfirst(); }
+	  operator type *() const	{ return (type *)TQGList::cfirst(); }
+    type *current() const		{ return (type *)TQGList::cfirst(); }
+
+#ifdef TQ_TQDOC
+protected:
+    virtual TQDataStream& read( TQDataStream&, TQPtrCollection::Item& );
+    virtual TQDataStream& write( TQDataStream&, TQPtrCollection::Item ) const;
+#endif
+
+private:
+    void  deleteItem( Item d );
+};
+
+#if !defined(TQ_BROKEN_TEMPLATE_SPECIALIZATION)
+template<> inline void TQPtrStack<void>::deleteItem( TQPtrCollection::Item )
+{
+}
+#endif
+
+template<class type> inline void TQPtrStack<type>::deleteItem( TQPtrCollection::Item d )
+{
+    if ( del_item ) delete (type *)d;
+}
+
+#ifndef TQT_NO_COMPAT
+#define TQStack TQPtrStack
+#endif
+
+#endif // TQPTRSTACK_H
diff --git a/tqtinterface/qt4/src/tools/tqptrvector.h b/tqtinterface/qt4/src/tools/tqptrvector.h
new file mode 100644
index 0000000..97934d4
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqptrvector.h
@@ -0,0 +1,119 @@
+/****************************************************************************
+**
+** Definition of TQPtrVector pointer based template class
+**
+** Created : 930907
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQPTRVECTOR_H
+#define TQPTRVECTOR_H
+
+#ifndef TQT_H
+#include "tqgvector.h"
+#endif // TQT_H
+
+template<class type>
+class TQPtrVector
+#ifdef TQ_TQDOC
+	: public TQPtrCollection
+#else
+	: public TQGVector
+#endif
+{
+public:
+    TQPtrVector()				{ }
+    TQPtrVector( uint size ) : TQGVector(size) { }
+    TQPtrVector( const TQPtrVector<type> &v ) : TQGVector( v ) { }
+    ~TQPtrVector()				{ clear(); }
+    TQPtrVector<type> &operator=(const TQPtrVector<type> &v)
+			{ return (TQPtrVector<type>&)TQGVector::operator=(v); }
+    bool operator==( const TQPtrVector<type> &v ) const { return TQGVector::operator==(v); }
+    type **data()   const		{ return (type **)TQGVector::data(); }
+    uint  size()    const		{ return TQGVector::size(); }
+    uint  count()   const		{ return TQGVector::count(); }
+    bool  isEmpty() const		{ return TQGVector::count() == 0; }
+    bool  isNull()  const		{ return TQGVector::size() == 0; }
+    bool  resize( uint size )		{ return TQGVector::resize(size); }
+    bool  insert( uint i, const type *d){ return TQGVector::insert(i,(Item)d); }
+    bool  remove( uint i )		{ return TQGVector::remove(i); }
+    type *take( uint i )		{ return (type *)TQGVector::take(i); }
+    void  clear()			{ TQGVector::clear(); }
+    bool  fill( const type *d, int size=-1 )
+					{ return TQGVector::fill((Item)d,size);}
+    void  sort()			{ TQGVector::sort(); }
+    int	  bsearch( const type *d ) const{ return TQGVector::bsearch((Item)d); }
+    int	  tqfindRef( const type *d, uint i=0 ) const
+					{ return TQGVector::tqfindRef((Item)d,i);}
+    int	  tqfind( const type *d, uint i= 0 ) const
+					{ return TQGVector::tqfind((Item)d,i); }
+    uint  tqcontainsRef( const type *d ) const
+				{ return TQGVector::tqcontainsRef((Item)d); }
+    uint  tqcontains( const type *d ) const
+					{ return TQGVector::tqcontains((Item)d); }
+    type *operator[]( int i ) const	{ return (type *)TQGVector::at(i); }
+    type *at( uint i ) const		{ return (type *)TQGVector::at(i); }
+    type *tqat( uint i ) const		{ return (type *)TQGVector::at(i); }
+    void  toList( TQGList *list ) const	{ TQGVector::toList(list); }
+
+#ifdef TQ_TQDOC
+protected:
+    virtual int compareItems( TQPtrCollection::Item d1, TQPtrCollection::Item d2 );
+    virtual TQDataStream& read( TQDataStream &s, TQPtrCollection::Item &d );
+    virtual TQDataStream& write( TQDataStream &s, TQPtrCollection::Item d ) const;
+#endif
+
+private:
+    void  deleteItem( Item d );
+};
+
+#if !defined(TQ_BROKEN_TEMPLATE_SPECIALIZATION)
+template<> inline void TQPtrVector<void>::deleteItem( TQPtrCollection::Item )
+{
+}
+#endif
+
+template<class type> inline void TQPtrVector<type>::deleteItem( TQPtrCollection::Item d )
+{
+    if ( del_item ) delete (type *)d;
+}
+
+#ifndef TQT_NO_COMPAT
+#define TQVector TQPtrVector
+#endif
+
+#define TQ_DEFINED_TQPTRVECTOR
+#include "tqwinexport.h"
+#endif // TQVECTOR_H
diff --git a/tqtinterface/qt4/src/tools/tqregexp.cpp b/tqtinterface/qt4/src/tools/tqregexp.cpp
new file mode 100644
index 0000000..cac50e5
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqregexp.cpp
@@ -0,0 +1,4050 @@
+/****************************************************************************
+**
+** Implementation of TQRegExp class
+**
+** Created : 950126
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "tqregexp.h"
+
+#ifndef TQT_NO_REGEXP
+
+#include "tqmemarray.h"
+#include "tqbitarray.h"
+#include "tqcache.h"
+#include "tqcleanuphandler.h"
+#include "tqintdict.h"
+#include "tqmap.h"
+#include "tqptrvector.h"
+#include "tqstring.h"
+#include "tqtl.h"
+
+#ifdef TQT_THREAD_SUPPORT
+#include "tqthreadstorage.h"
+#include <private/tqthreadinstance_p.h>
+#endif // TQT_THREAD_SUPPORT
+
+#undef TQT_TRANSLATE_NOOP
+#define TQT_TRANSLATE_NOOP( context, sourceText ) sourceText
+
+#include <limits.h>
+
+// error strings for the regexp parser
+#define RXERR_OK         TQT_TRANSLATE_NOOP( "TQRegExp", "no error occurred" )
+#define RXERR_DISABLED   TQT_TRANSLATE_NOOP( "TQRegExp", "disabled feature used" )
+#define RXERR_CHARCLASS  TQT_TRANSLATE_NOOP( "TQRegExp", "bad char class syntax" )
+#define RXERR_LOOKAHEAD  TQT_TRANSLATE_NOOP( "TQRegExp", "bad lookahead syntax" )
+#define RXERR_REPETITION TQT_TRANSLATE_NOOP( "TQRegExp", "bad repetition syntax" )
+#define RXERR_OCTAL      TQT_TRANSLATE_NOOP( "TQRegExp", "invalid octal value" )
+#define RXERR_LEFTDELIM  TQT_TRANSLATE_NOOP( "TQRegExp", "missing left delim" )
+#define RXERR_END        TQT_TRANSLATE_NOOP( "TQRegExp", "unexpected end" )
+#define RXERR_LIMIT      TQT_TRANSLATE_NOOP( "TQRegExp", "met internal limit" )
+
+#ifdef USE_QT4
+
+/*!
+    QT4 INTEROPERABILITY
+*/
+int TQRegExp::search( const TQString& str, int offset ) const
+{
+	return indexIn( str, offset, CaretAtZero);
+}
+
+/*!
+    QT4 INTEROPERABILITY
+*/
+int TQRegExp::search( const TQString& str, int offset, CaretMode caretMode ) const
+{
+	return indexIn( str, offset, caretMode);
+}
+
+/*!
+    QT4 INTEROPERABILITY
+*/
+int TQRegExp::searchRev( const TQString& str, int offset ) const
+{
+	return lastIndexIn( str, offset, CaretAtZero);
+}
+
+/*!
+    QT4 INTEROPERABILITY
+*/
+int TQRegExp::searchRev( const TQString& str, int offset, CaretMode caretMode ) const
+{
+	return lastIndexIn( str, offset, caretMode);
+}
+
+/*!
+    QT4 INTEROPERABILITY
+*/
+bool TQRegExp::caseSensitive() const
+{
+	return caseSensitivity();
+}
+
+/*!
+    QT4 INTEROPERABILITY
+*/
+void TQRegExp::setCaseSensitive( bool sensitive )
+{
+	setCaseSensitivity( (Qt::CaseSensitivity)sensitive);
+}
+
+#else // USE_QT4
+
+/*
+  WARNING! Be sure to read qregexp.tex before modifying this file.
+*/
+
+/*!
+    \class TQRegExp tqregexp.h
+    \reentrant
+    \brief The TQRegExp class provides pattern matching using regular expressions.
+
+    \ingroup tools
+    \ingroup misc
+    \ingroup shared
+    \mainclass
+    \keyword regular expression
+
+    Regular expressions, or "regexps", provide a way to tqfind patterns
+    within text. This is useful in many contexts, for example:
+
+    \table
+    \row \i Validation
+	 \i A regexp can be used to check whether a piece of text
+	 meets some criteria, e.g. is an integer or tqcontains no
+	 whitespace.
+    \row \i Searching
+	 \i Regexps provide a much more powerful means of searching
+	 text than simple string matching does. For example we can
+	 create a regexp which says "tqfind one of the words 'mail',
+	 'letter' or 'correspondence' but not any of the words
+	 'email', 'mailman' 'mailer', 'letterbox' etc."
+    \row \i Search and Replace
+	 \i A regexp can be used to tqreplace a pattern with a piece of
+	 text, for example tqreplace all occurrences of '&' with
+	 '\&amp;' except where the '&' is already followed by 'amp;'.
+    \row \i String Splitting
+	 \i A regexp can be used to identify where a string should be
+	 split into its component fields, e.g. splitting tab-delimited
+	 strings.
+    \endtable
+
+    We present a very brief introduction to regexps, a description of
+    TQt's regexp language, some code examples, and finally the function
+    documentation itself. TQRegExp is modeled on Perl's regexp
+    language, and also fully supports Unicode. TQRegExp can also be
+    used in the weaker 'wildcard' (globbing) mode which works in a
+    similar way to command shells. A good text on regexps is \e
+    {Mastering Regular Expressions: Powerful Techniques for Perl and
+    Other Tools} by Jeffrey E. Friedl, ISBN 1565922573.
+
+    Experienced regexp users may prefer to skip the introduction and
+    go directly to the relevant information.
+
+    In case of multi-threaded programming, note that TQRegExp depends on
+    TQThreadStorage internally. For that reason, TQRegExp should only be
+    used with threads started with TQThread, i.e. not with threads
+    started with platform-specific APIs.
+
+    \tableofcontents
+
+    \section1 Introduction
+
+    Regexps are built up from expressions, quantifiers, and assertions.
+    The simplest form of expression is simply a character, e.g.
+    <b>x</b> or <b>5</b>. An expression can also be a set of
+    characters. For example, <b>[ABCD]</b>, will match an <b>A</b> or
+    a <b>B</b> or a <b>C</b> or a <b>D</b>. As a shorthand we could
+    write this as <b>[A-D]</b>. If we want to match any of the
+    captital letters in the English alphabet we can write
+    <b>[A-Z]</b>. A quantifier tells the regexp engine how many
+    occurrences of the expression we want, e.g. <b>x{1,1}</b> means
+    match an <b>x</b> which occurs at least once and at most once.
+    We'll look at assertions and more complex expressions later.
+
+    Note that in general regexps cannot be used to check for balanced
+    brackets or tags. For example if you want to match an opening html
+    \c <b> and its closing \c </b> you can only use a regexp if you
+    know that these tags are not nested; the html fragment, \c{<b>bold
+    <b>bolder</b></b>} will not match as expected. If you know the
+    maximum level of nesting it is possible to create a regexp that
+    will match correctly, but for an unknown level of nesting, regexps
+    will fail.
+
+    We'll start by writing a regexp to match integers in the range 0
+    to 99. We will require at least one digit so we will start with
+    <b>[0-9]{1,1}</b> which means match a digit exactly once. This
+    regexp alone will match integers in the range 0 to 9. To match one
+    or two digits we can increase the maximum number of occurrences so
+    the regexp becomes <b>[0-9]{1,2}</b> meaning match a digit at
+    least once and at most twice. However, this regexp as it stands
+    will not match correctly. This regexp will match one or two digits
+    \e within a string. To ensure that we match against the whole
+    string we must use the anchor assertions. We need <b>^</b> (caret)
+    which when it is the first character in the regexp means that the
+    regexp must match from the beginning of the string. And we also
+    need <b>$</b> (dollar) which when it is the last character in the
+    regexp means that the regexp must match until the end of the
+    string. So now our regexp is <b>^[0-9]{1,2}$</b>. Note that
+    assertions, such as <b>^</b> and <b>$</b>, do not match any
+    characters.
+
+    If you've seen regexps elsewhere they may have looked different from
+    the ones above. This is because some sets of characters and some
+    quantifiers are so common that they have special symbols to
+    represent them. <b>[0-9]</b> can be tqreplaced with the symbol
+    <b>\d</b>. The quantifier to match exactly one occurrence,
+    <b>{1,1}</b>, can be tqreplaced with the expression itself. This means
+    that <b>x{1,1}</b> is exactly the same as <b>x</b> alone. So our 0
+    to 99 matcher could be written <b>^\d{1,2}$</b>. Another way of
+    writing it would be <b>^\d\d{0,1}$</b>, i.e. from the start of the
+    string match a digit followed by zero or one digits. In practice
+    most people would write it <b>^\d\d?$</b>. The <b>?</b> is a
+    shorthand for the quantifier <b>{0,1}</b>, i.e. a minimum of no
+    occurrences a maximum of one occurrence. This is used to make an
+    expression optional. The regexp <b>^\d\d?$</b> means "from the
+    beginning of the string match one digit followed by zero or one
+    digits and then the end of the string".
+
+    Our second example is matching the words 'mail', 'letter' or
+    'correspondence' but without matching 'email', 'mailman',
+    'mailer', 'letterbox' etc. We'll start by just matching 'mail'. In
+    full the regexp is, <b>m{1,1}a{1,1}i{1,1}l{1,1}</b>, but since
+    each expression itself is automatically quantified by <b>{1,1}</b>
+    we can simply write this as <b>mail</b>; an 'm' followed by an 'a'
+    followed by an 'i' followed by an 'l'. The symbol '|' (bar) is
+    used for \e alternation, so our regexp now becomes
+    <b>mail|letter|correspondence</b> which means match 'mail' \e or
+    'letter' \e or 'correspondence'. Whilst this regexp will tqfind the
+    words we want it will also tqfind words we don't want such as
+    'email'. We will start by putting our regexp in parentheses,
+    <b>(mail|letter|correspondence)</b>. Parentheses have two effects,
+    firstly they group expressions together and secondly they identify
+    parts of the regexp that we wish to \link #capturing-text capture
+    \endlink. Our regexp still matches any of the three words but now
+    they are grouped together as a unit. This is useful for building
+    up more complex regexps. It is also useful because it allows us to
+    examine which of the words actually matched. We need to use
+    another assertion, this time <b>\b</b> "word boundary":
+    <b>\b(mail|letter|correspondence)\b</b>. This regexp means "match
+    a word boundary followed by the expression in parentheses followed
+    by another word boundary". The <b>\b</b> assertion matches at a \e
+    position in the regexp not a \e character in the regexp. A word
+    boundary is any non-word character such as a space a newline or
+    the beginning or end of the string.
+
+    For our third example we want to tqreplace ampersands with the HTML
+    entity '\&amp;'. The regexp to match is simple: <b>\&</b>, i.e.
+    match one ampersand. Unfortunately this will mess up our text if
+    some of the ampersands have already been turned into HTML
+    entities. So what we really want to say is tqreplace an ampersand
+    providing it is not followed by 'amp;'. For this we need the
+    negative lookahead assertion and our regexp becomes:
+    <b>\&(?!amp;)</b>. The negative lookahead assertion is introduced
+    with '(?!' and finishes at the ')'. It means that the text it
+    tqcontains, 'amp;' in our example, must \e not follow the expression
+    that preceeds it.
+
+    Regexps provide a rich language that can be used in a variety of
+    ways. For example suppose we want to count all the occurrences of
+    'Eric' and 'Eirik' in a string. Two valid regexps to match these
+    are <b>\\b(Eric|Eirik)\\b</b> and <b>\\bEi?ri[ck]\\b</b>. We need
+    the word boundary '\b' so we don't get 'Ericsson' etc. The second
+    regexp actually matches more than we want, 'Eric', 'Erik', 'Eiric'
+    and 'Eirik'.
+
+    We will implement some the examples above in the
+    \link #code-examples code examples \endlink section.
+
+    \target characters-and-abbreviations-for-sets-of-characters
+    \section1 Characters and Abbreviations for Sets of Characters
+
+    \table
+    \header \i Element \i Meaning
+    \row \i <b>c</b>
+	 \i Any character represents itself unless it has a special
+	 regexp meaning. Thus <b>c</b> matches the character \e c.
+    \row \i <b>\\c</b>
+	 \i A character that follows a backslash matches the character
+	 itself except where mentioned below. For example if you
+	 wished to match a literal caret at the beginning of a string
+	 you would write <b>\^</b>.
+    \row \i <b>\\a</b>
+	 \i This matches the ASCII bell character (BEL, 0x07).
+    \row \i <b>\\f</b>
+	 \i This matches the ASCII form feed character (FF, 0x0C).
+    \row \i <b>\\n</b>
+	 \i This matches the ASCII line feed character (LF, 0x0A, Unix newline).
+    \row \i <b>\\r</b>
+	 \i This matches the ASCII carriage return character (CR, 0x0D).
+    \row \i <b>\\t</b>
+	 \i This matches the ASCII horizontal tab character (HT, 0x09).
+    \row \i <b>\\v</b>
+	 \i This matches the ASCII vertical tab character (VT, 0x0B).
+    \row \i <b>\\xhhhh</b>
+	 \i This matches the Unicode character corresponding to the
+	 hexadecimal number hhhh (between 0x0000 and 0xFFFF). \0ooo
+	 (i.e., \zero ooo) matches the ASCII/Latin-1 character
+	 corresponding to the octal number ooo (between 0 and 0377).
+    \row \i <b>. (dot)</b>
+	 \i This matches any character (including newline).
+    \row \i <b>\\d</b>
+	 \i This matches a digit (TQChar::isDigit()).
+    \row \i <b>\\D</b>
+	 \i This matches a non-digit.
+    \row \i <b>\\s</b>
+	 \i This matches a whitespace (TQChar::isSpace()).
+    \row \i <b>\\S</b>
+	 \i This matches a non-whitespace.
+    \row \i <b>\\w</b>
+	 \i This matches a word character (TQChar::isLetterOrNumber() or '_').
+    \row \i <b>\\W</b>
+	 \i This matches a non-word character.
+    \row \i <b>\\n</b>
+	 \i The n-th \link #capturing-text backreference \endlink,
+	 e.g. \1, \2, etc.
+    \endtable
+
+    \e {Note that the C++ compiler transforms backslashes in strings
+    so to include a <b>\\</b> in a regexp you will need to enter it
+    twice, i.e. <b>\\\\</b>.}
+
+    \target sets-of-characters
+    \section1 Sets of Characters
+
+    Square brackets are used to match any character in the set of
+    characters contained within the square brackets. All the character
+    set abbreviations described above can be used within square
+    brackets. Apart from the character set abbreviations and the
+    following two exceptions no characters have special meanings in
+    square brackets.
+
+    \table
+    \row \i <b>^</b>
+	 \i The caret negates the character set if it occurs as the
+	 first character, i.e. immediately after the opening square
+	 bracket. For example, <b>[abc]</b> matches 'a' or 'b' or 'c',
+	 but <b>[^abc]</b> matches anything \e except 'a' or 'b' or
+	 'c'.
+    \row \i <b>-</b>
+	 \i The dash is used to indicate a range of characters, for
+	 example <b>[W-Z]</b> matches 'W' or 'X' or 'Y' or 'Z'.
+    \endtable
+
+    Using the predefined character set abbreviations is more portable
+    than using character ranges across platforms and languages. For
+    example, <b>[0-9]</b> matches a digit in Western alphabets but
+    <b>\d</b> matches a digit in \e any alphabet.
+
+    Note that in most regexp literature sets of characters are called
+    "character classes".
+
+    \target quantifiers
+    \section1 Quantifiers
+
+    By default an expression is automatically quantified by
+    <b>{1,1}</b>, i.e. it should occur exactly once. In the following
+    list <b>\e {E}</b> stands for any expression. An expression is a
+    character or an abbreviation for a set of characters or a set of
+    characters in square brackets or any parenthesised expression.
+
+    \table
+    \row \i <b>\e {E}?</b>
+	 \i Matches zero or one occurrence of \e E. This quantifier
+	 means "the previous expression is optional" since it will
+	 match whether or not the expression occurs in the string. It
+	 is the same as <b>\e {E}{0,1}</b>. For example <b>dents?</b>
+	 will match 'dent' and 'dents'.
+
+    \row \i <b>\e {E}+</b>
+	 \i Matches one or more occurrences of \e E. This is the same
+	 as <b>\e {E}{1,MAXINT}</b>. For example, <b>0+</b> will match
+	 '0', '00', '000', etc.
+
+    \row \i <b>\e {E}*</b>
+	 \i Matches zero or more occurrences of \e E. This is the same
+	 as <b>\e {E}{0,MAXINT}</b>. The <b>*</b> quantifier is often
+	 used by a mistake. Since it matches \e zero or more
+	 occurrences it will match no occurrences at all. For example
+	 if we want to match strings that end in whitespace and use
+	 the regexp <b>\s*$</b> we would get a match on every string.
+	 This is because we have said tqfind zero or more whitespace
+	 followed by the end of string, so even strings that don't end
+	 in whitespace will match. The regexp we want in this case is
+	 <b>\s+$</b> to match strings that have at least one
+	 whitespace at the end.
+
+    \row \i <b>\e {E}{n}</b>
+	 \i Matches exactly \e n occurrences of the expression. This
+	 is the same as repeating the expression \e n times. For
+	 example, <b>x{5}</b> is the same as <b>xxxxx</b>. It is also
+	 the same as <b>\e {E}{n,n}</b>, e.g. <b>x{5,5}</b>.
+
+    \row \i <b>\e {E}{n,}</b>
+	 \i Matches at least \e n occurrences of the expression. This
+	 is the same as <b>\e {E}{n,MAXINT}</b>.
+
+    \row \i <b>\e {E}{,m}</b>
+	 \i Matches at most \e m occurrences of the expression. This
+	 is the same as <b>\e {E}{0,m}</b>.
+
+    \row \i <b>\e {E}{n,m}</b>
+	 \i Matches at least \e n occurrences of the expression and at
+	 most \e m occurrences of the expression.
+    \endtable
+
+    (MAXINT is implementation dependent but will not be smaller than
+    1024.)
+
+    If we wish to apply a quantifier to more than just the preceding
+    character we can use parentheses to group characters together in
+    an expression. For example, <b>tag+</b> matches a 't' followed by
+    an 'a' followed by at least one 'g', whereas <b>(tag)+</b> matches
+    at least one occurrence of 'tag'.
+
+    Note that quantifiers are "greedy". They will match as much text
+    as they can. For example, <b>0+</b> will match as many zeros as it
+    can from the first zero it tqfinds, e.g. '2.<u>000</u>5'.
+    Quantifiers can be made non-greedy, see setMinimal().
+
+    \target capturing-text
+    \section1 Capturing Text
+
+    Parentheses allow us to group elements together so that we can
+    quantify and capture them. For example if we have the expression
+    <b>mail|letter|correspondence</b> that matches a string we know
+    that \e one of the words matched but not which one. Using
+    parentheses allows us to "capture" whatever is matched within
+    their bounds, so if we used <b>(mail|letter|correspondence)</b>
+    and matched this regexp against the string "I sent you some email"
+    we can use the cap() or capturedTexts() functions to extract the
+    matched characters, in this case 'mail'.
+
+    We can use captured text within the regexp itself. To refer to the
+    captured text we use \e backreferences which are indexed from 1,
+    the same as for cap(). For example we could search for duplicate
+    words in a string using <b>\b(\w+)\W+\1\b</b> which means match a
+    word boundary followed by one or more word characters followed by
+    one or more non-word characters followed by the same text as the
+    first parenthesised expression followed by a word boundary.
+
+    If we want to use parentheses purely for grouping and not for
+    capturing we can use the non-capturing syntax, e.g.
+    <b>(?:green|blue)</b>. Non-capturing parentheses begin '(?:' and
+    end ')'. In this example we match either 'green' or 'blue' but we
+    do not capture the match so we only know whether or not we matched
+    but not which color we actually found. Using non-capturing
+    parentheses is more efficient than using capturing parentheses
+    since the regexp engine has to do less book-keeping.
+
+    Both capturing and non-capturing parentheses may be nested.
+
+    \target assertions
+    \section1 Assertions
+
+    Assertions make some statement about the text at the point where
+    they occur in the regexp but they do not match any characters. In
+    the following list <b>\e {E}</b> stands for any expression.
+
+    \table
+    \row \i <b>^</b>
+	 \i The caret signifies the beginning of the string. If you
+	 wish to match a literal \c{^} you must escape it by
+	 writing <b>&#92;^</b>. For example, <b>^#include</b> will only
+	 match strings which \e begin with the characters '#include'.
+	 (When the caret is the first character of a character set it
+	 has a special meaning, see \link #sets-of-characters Sets of
+	 Characters \endlink.)
+
+    \row \i <b>$</b>
+	 \i The dollar signifies the end of the string. For example
+	 <b>\d\s*$</b> will match strings which end with a digit
+	 optionally followed by whitespace. If you wish to match a
+	 literal \c{$} you must escape it by writing
+	 <b>&#92;$</b>.
+
+    \row \i <b>\\b</b>
+	 \i A word boundary. For example the regexp
+	 <b>\\bOK\\b</b> means match immediately after a word
+	 boundary (e.g. start of string or whitespace) the letter 'O'
+	 then the letter 'K' immediately before another word boundary
+	 (e.g. end of string or whitespace). But note that the
+	 assertion does not actually match any whitespace so if we
+	 write <b>(\\bOK\\b)</b> and we have a match it will only
+	 contain 'OK' even if the string is "Its <u>OK</u> now".
+
+    \row \i <b>\\B</b>
+	 \i A non-word boundary. This assertion is true wherever
+	 <b>\\b</b> is false. For example if we searched for
+	 <b>\\Bon\\B</b> in "Left on" the match would fail (space
+	 and end of string aren't non-word boundaries), but it would
+	 match in "t<u>on</u>ne".
+
+    \row \i <b>(?=\e E)</b>
+	 \i Positive lookahead. This assertion is true if the
+	 expression matches at this point in the regexp. For example,
+	 <b>const(?=\\s+char)</b> matches 'const' whenever it is
+	 followed by 'char', as in 'static <u>const</u> char *'.
+	 (Compare with <b>const\\s+char</b>, which matches 'static
+	 <u>const char</u> *'.)
+
+    \row \i <b>(?!\e E)</b>
+	 \i Negative lookahead. This assertion is true if the
+	 expression does not match at this point in the regexp. For
+	 example, <b>const(?!\\s+char)</b> matches 'const' \e except
+	 when it is followed by 'char'.
+    \endtable
+
+    \target wildcard-matching
+    \section1 Wildcard Matching (globbing)
+
+    Most command shells such as \e bash or \e cmd.exe support "file
+    globbing", the ability to identify a group of files by using
+    wildcards. The setWildcard() function is used to switch between
+    regexp and wildcard mode. Wildcard matching is much simpler than
+    full regexps and has only four features:
+
+    \table
+    \row \i <b>c</b>
+	 \i Any character represents itself apart from those mentioned
+	 below. Thus <b>c</b> matches the character \e c.
+    \row \i <b>?</b>
+	 \i This matches any single character. It is the same as
+	 <b>.</b> in full regexps.
+    \row \i <b>*</b>
+	 \i This matches zero or more of any characters. It is the
+	 same as <b>.*</b> in full regexps.
+    \row \i <b>[...]</b>
+	 \i Sets of characters can be represented in square brackets,
+	 similar to full regexps. Within the character class, like
+	 outside, backslash has no special meaning.
+    \endtable
+
+    For example if we are in wildcard mode and have strings which
+    contain filenames we could identify HTML files with <b>*.html</b>.
+    This will match zero or more characters followed by a dot followed
+    by 'h', 't', 'm' and 'l'.
+
+    \target perl-users
+    \section1 Notes for Perl Users
+
+    Most of the character class abbreviations supported by Perl are
+    supported by TQRegExp, see \link
+    #characters-and-abbreviations-for-sets-of-characters characters
+    and abbreviations for sets of characters \endlink.
+
+    In TQRegExp, apart from within character classes, \c{^} always
+    signifies the start of the string, so carets must always be
+    escaped unless used for that purpose. In Perl the meaning of caret
+    varies automagically depending on where it occurs so escaping it
+    is rarely necessary. The same applies to \c{$} which in
+    TQRegExp always signifies the end of the string.
+
+    TQRegExp's quantifiers are the same as Perl's greedy quantifiers.
+    Non-greedy matching cannot be applied to individual quantifiers,
+    but can be applied to all the quantifiers in the pattern. For
+    example, to match the Perl regexp <b>ro+?m</b> requires:
+    \code
+    TQRegExp rx( "ro+m" );
+    rx.setMinimal( TRUE );
+    \endcode
+
+    The equivalent of Perl's \c{/i} option is
+    setCaseSensitive(FALSE).
+
+    Perl's \c{/g} option can be emulated using a \link
+    #cap_in_a_loop loop \endlink.
+
+    In TQRegExp <b>.</b> matches any character, therefore all TQRegExp
+    regexps have the equivalent of Perl's \c{/s} option. TQRegExp
+    does not have an equivalent to Perl's \c{/m} option, but this
+    can be emulated in various ways for example by splitting the input
+    into lines or by looping with a regexp that searches for newlines.
+
+    Because TQRegExp is string oriented there are no \A, \Z or \z
+    assertions. The \G assertion is not supported but can be emulated
+    in a loop.
+
+    Perl's $& is cap(0) or capturedTexts()[0]. There are no TQRegExp
+    equivalents for $`, $' or $+. Perl's capturing variables, $1, $2,
+    ... correspond to cap(1) or capturedTexts()[1], cap(2) or
+    capturedTexts()[2], etc.
+
+    To substitute a pattern use TQString::tqreplace().
+
+    Perl's extended \c{/x} syntax is not supported, nor are
+    directives, e.g. (?i), or regexp comments, e.g. (?#comment). On
+    the other hand, C++'s rules for literal strings can be used to
+    achieve the same:
+    \code
+    TQRegExp mark( "\\b" // word boundary
+		  "[Mm]ark" // the word we want to match
+		);
+    \endcode
+
+    Both zero-width positive and zero-width negative lookahead
+    assertions (?=pattern) and (?!pattern) are supported with the same
+    syntax as Perl. Perl's lookbehind assertions, "independent"
+    subexpressions and conditional expressions are not supported.
+
+    Non-capturing parentheses are also supported, with the same
+    (?:pattern) syntax.
+
+    See TQStringList::split() and TQStringList::join() for equivalents
+    to Perl's split and join functions.
+
+    Note: because C++ transforms \\'s they must be written \e twice in
+    code, e.g. <b>\\b</b> must be written <b>\\\\b</b>.
+
+    \target code-examples
+    \section1 Code Examples
+
+    \code
+    TQRegExp rx( "^\\d\\d?$" );  // match integers 0 to 99
+    rx.search( "123" );         // returns -1 (no match)
+    rx.search( "-6" );          // returns -1 (no match)
+    rx.search( "6" );           // returns 0 (matched as position 0)
+    \endcode
+
+    The third string matches '<u>6</u>'. This is a simple validation
+    regexp for integers in the range 0 to 99.
+
+    \code
+    TQRegExp rx( "^\\S+$" );     // match strings without whitespace
+    rx.search( "Hello world" ); // returns -1 (no match)
+    rx.search( "This_is-OK" );  // returns 0 (matched at position 0)
+    \endcode
+
+    The second string matches '<u>This_is-OK</u>'. We've used the
+    character set abbreviation '\S' (non-whitespace) and the anchors
+    to match strings which contain no whitespace.
+
+    In the following example we match strings containing 'mail' or
+    'letter' or 'correspondence' but only match whole words i.e. not
+    'email'
+
+    \code
+    TQRegExp rx( "\\b(mail|letter|correspondence)\\b" );
+    rx.search( "I sent you an email" );     // returns -1 (no match)
+    rx.search( "Please write the letter" ); // returns 17
+    \endcode
+
+    The second string matches "Please write the <u>letter</u>". The
+    word 'letter' is also captured (because of the parentheses). We
+    can see what text we've captured like this:
+
+    \code
+    TQString captured = rx.cap( 1 ); // captured == "letter"
+    \endcode
+
+    This will capture the text from the first set of capturing
+    parentheses (counting capturing left parentheses from left to
+    right). The parentheses are counted from 1 since cap( 0 ) is the
+    whole matched regexp (equivalent to '&' in most regexp engines).
+
+    \code
+    TQRegExp rx( "&(?!amp;)" );      // match ampersands but not &amp;
+    TQString line1 = "This & that";
+    line1.tqreplace( rx, "&amp;" );
+    // line1 == "This &amp; that"
+    TQString line2 = "His &amp; hers & theirs";
+    line2.tqreplace( rx, "&amp;" );
+    // line2 == "His &amp; hers &amp; theirs"
+    \endcode
+
+    Here we've passed the TQRegExp to TQString's tqreplace() function to
+    tqreplace the matched text with new text.
+
+    \code
+    TQString str = "One Eric another Eirik, and an Ericsson."
+		    " How many Eiriks, Eric?";
+    TQRegExp rx( "\\b(Eric|Eirik)\\b" ); // match Eric or Eirik
+    int pos = 0;    // where we are in the string
+    int count = 0;  // how many Eric and Eirik's we've counted
+    while ( pos >= 0 ) {
+	pos = rx.search( str, pos );
+	if ( pos >= 0 ) {
+	    pos++;      // move along in str
+	    count++;    // count our Eric or Eirik
+	}
+    }
+    \endcode
+
+    We've used the search() function to repeatedly match the regexp in
+    the string. Note that instead of moving forward by one character
+    at a time \c pos++ we could have written \c {pos +=
+    rx.matchedLength()} to skip over the already matched string. The
+    count will equal 3, matching 'One <u>Eric</u> another
+    <u>Eirik</u>, and an Ericsson. How many Eiriks, <u>Eric</u>?'; it
+    doesn't match 'Ericsson' or 'Eiriks' because they are not bounded
+    by non-word boundaries.
+
+    One common use of regexps is to split lines of delimited data into
+    their component fields.
+
+    \code
+    str = "Trolltech AS\twww.trolltech.com\tNorway";
+    TQString company, web, country;
+    rx.setPattern( "^([^\t]+)\t([^\t]+)\t([^\t]+)$" );
+    if ( rx.search( str ) != -1 ) {
+	company = rx.cap( 1 );
+	web = rx.cap( 2 );
+	country = rx.cap( 3 );
+    }
+    \endcode
+
+    In this example our input lines have the format company name, web
+    address and country. Unfortunately the regexp is rather long and
+    not very versatile -- the code will break if we add any more
+    fields. A simpler and better solution is to look for the
+    separator, '\t' in this case, and take the surrounding text. The
+    TQStringList split() function can take a separator string or regexp
+    as an argument and split a string accordingly.
+
+    \code
+    TQStringList field = TQStringList::split( "\t", str );
+    \endcode
+
+    Here field[0] is the company, field[1] the web address and so on.
+
+    To imitate the matching of a shell we can use wildcard mode.
+
+    \code
+    TQRegExp rx( "*.html" );         // invalid regexp: * doesn't quantify anything
+    rx.setWildcard( TRUE );         // now it's a valid wildcard regexp
+    rx.exactMatch( "index.html" );  // returns TRUE
+    rx.exactMatch( "default.htm" ); // returns FALSE
+    rx.exactMatch( "readme.txt" );  // returns FALSE
+    \endcode
+
+    Wildcard matching can be convenient because of its simplicity, but
+    any wildcard regexp can be defined using full regexps, e.g.
+    <b>.*\.html$</b>. Notice that we can't match both \c .html and \c
+    .htm files with a wildcard unless we use <b>*.htm*</b> which will
+    also match 'test.html.bak'. A full regexp gives us the precision
+    we need, <b>.*\\.html?$</b>.
+
+    TQRegExp can match case insensitively using setCaseSensitive(), and
+    can use non-greedy matching, see setMinimal(). By default TQRegExp
+    uses full regexps but this can be changed with setWildcard().
+    Searching can be forward with search() or backward with
+    searchRev(). Captured text can be accessed using capturedTexts()
+    which returns a string list of all captured strings, or using
+    cap() which returns the captured string for the given index. The
+    pos() function takes a match index and returns the position in the
+    string where the match was made (or -1 if there was no match).
+
+    \sa TQRegExpValidator TQString TQStringList
+
+    \target member-function-documentation
+*/
+
+const int NumBadChars = 64;
+#define BadChar( ch ) ( (ch).tqunicode() % NumBadChars )
+
+const int NoOccurrence = INT_MAX;
+const int EmptyCapture = INT_MAX;
+const int InftyLen = INT_MAX;
+const int InftyRep = 1025;
+const int EOS = -1;
+
+static bool isWord( TQChar ch )
+{
+    return ch.isLetterOrNumber() || ch == TQChar( '_' );
+}
+
+/*
+  Merges two TQMemArrays of ints and puts the result into the first
+  one.
+*/
+static void mergeInto( TQMemArray<int> *a, const TQMemArray<int>& b )
+{
+    int asize = a->size();
+    int bsize = b.size();
+    if ( asize == 0 ) {
+	*a = b.copy();
+#ifndef TQT_NO_REGEXP_OPTIM
+    } else if ( bsize == 1 && (*a)[asize - 1] < b[0] ) {
+	a->resize( asize + 1 );
+	(*a)[asize] = b[0];
+#endif
+    } else if ( bsize >= 1 ) {
+	int csize = asize + bsize;
+	TQMemArray<int> c( csize );
+	int i = 0, j = 0, k = 0;
+	while ( i < asize ) {
+	    if ( j < bsize ) {
+		if ( (*a)[i] == b[j] ) {
+		    i++;
+		    csize--;
+		} else if ( (*a)[i] < b[j] ) {
+		    c[k++] = (*a)[i++];
+		} else {
+		    c[k++] = b[j++];
+		}
+	    } else {
+		memcpy( c.data() + k, (*a).data() + i,
+			(asize - i) * sizeof(int) );
+		break;
+	    }
+	}
+	c.resize( csize );
+	if ( j < bsize )
+	    memcpy( c.data() + k, b.data() + j, (bsize - j) * sizeof(int) );
+	*a = c;
+    }
+}
+
+/*
+  Merges two disjoint TQMaps of (int, int) pairs and puts the result
+  into the first one.
+*/
+static void mergeInto( TQMap<int, int> *a, const TQMap<int, int>& b )
+{
+    TQMap<int, int>::ConstIterator it;
+    for ( it = b.begin(); it != b.end(); ++it )
+	a->insert( it.key(), *it );
+}
+
+/*
+  Returns the value associated to key k in TQMap m of (int, int)
+  pairs, or 0 if no such value is explicitly present.
+*/
+static int at( const TQMap<int, int>& m, int k )
+{
+    TQMap<int, int>::ConstIterator it = m.tqfind( k );
+    if ( it == m.end() )
+	return 0;
+    else
+	return *it;
+}
+
+#ifndef TQT_NO_REGEXP_WILDCARD
+/*
+  Translates a wildcard pattern to an equivalent regular expression
+  pattern (e.g., *.cpp to .*\.cpp).
+*/
+static TQString wc2rx( const TQString& wc_str )
+{
+    int wclen = wc_str.length();
+    TQString rx = TQString::tqfromLatin1( "" );
+    int i = 0;
+    const TQChar *wc = wc_str.tqunicode();
+    while ( i < wclen ) {
+	TQChar c = wc[i++];
+	switch ( c.tqunicode() ) {
+	case '*':
+	    rx += TQString::tqfromLatin1( ".*" );
+	    break;
+	case '?':
+	    rx += TQChar( '.' );
+	    break;
+	case '$':
+	case '(':
+	case ')':
+	case '+':
+	case '.':
+	case '\\':
+	case '^':
+	case '{':
+	case '|':
+	case '}':
+	    rx += TQChar( '\\' );
+	    rx += c;
+	    break;
+	case '[':
+	    rx += c;
+	    if ( wc[i] == TQChar('^') )
+		rx += wc[i++];
+	    if ( i < wclen ) {
+		if ( rx[i] == ']' )
+		    rx += wc[i++];
+		while ( i < wclen && wc[i] != TQChar(']') ) {
+		    if ( wc[i] == '\\' )
+			rx += TQChar( '\\' );
+		    rx += wc[i++];
+		}
+	    }
+	    break;
+	default:
+	    rx += c;
+	}
+    }
+    return rx;
+}
+#endif
+
+/*
+  The class TQRegExpEngine encapsulates a modified nondeterministic
+  finite automaton (NFA).
+*/
+class TQRegExpEngine : public TQShared
+{
+public:
+#ifndef TQT_NO_REGEXP_CCLASS
+    /*
+      The class CharClass represents a set of characters, such as can
+      be found in regular expressions (e.g., [a-z] denotes the set
+      {a, b, ..., z}).
+    */
+    class CharClass
+    {
+    public:
+	CharClass();
+	CharClass( const CharClass& cc ) { operator=( cc ); }
+
+	CharClass& operator=( const CharClass& cc );
+
+	void clear();
+	bool negative() const { return n; }
+	void setNegative( bool negative );
+	void addCategories( int cats );
+	void addRange( ushort from, ushort to );
+	void addSingleton( ushort ch ) { addRange( ch, ch ); }
+
+	bool in( TQChar ch ) const;
+#ifndef TQT_NO_REGEXP_OPTIM
+	const TQMemArray<int>& firstOccurrence() const { return occ1; }
+#endif
+
+#if defined(TQT_DEBUG)
+	void dump() const;
+#endif
+
+    private:
+	/*
+	  The struct Range represents a range of characters (e.g.,
+	  [0-9] denotes range 48 to 57).
+	*/
+	struct Range
+	{
+	    ushort from; // 48
+	    ushort to; // 57
+	};
+
+	int c; // character classes
+	TQMemArray<Range> r; // character ranges
+	bool n; // negative?
+#ifndef TQT_NO_REGEXP_OPTIM
+	TQMemArray<int> occ1; // first-occurrence array
+#endif
+    };
+#else
+    struct CharClass
+    {
+	int dummy;
+
+#ifndef TQT_NO_REGEXP_OPTIM
+	CharClass() { occ1.fill( 0, NumBadChars ); }
+
+	const TQMemArray<int>& firstOccurrence() const { return occ1; }
+	TQMemArray<int> occ1;
+#endif
+    };
+#endif
+
+    TQRegExpEngine( bool caseSensitive ) { setup( caseSensitive ); }
+    TQRegExpEngine( const TQString& rx, bool caseSensitive );
+#ifndef TQT_NO_REGEXP_OPTIM
+    ~TQRegExpEngine();
+#endif
+
+    bool isValid() const { return valid; }
+    bool caseSensitive() const { return cs; }
+    const TQString& errorString() const { return yyError; }
+    int numCaptures() const { return officialncap; }
+    void match( const TQString& str, int pos, bool minimal, bool oneTest,
+		int caretIndex, TQMemArray<int>& captured );
+    int partialMatchLength() const { return mmOneTestMatchedLen; }
+
+    int createState( TQChar ch );
+    int createState( const CharClass& cc );
+#ifndef TQT_NO_REGEXP_BACKREF
+    int createState( int bref );
+#endif
+
+    void addCatTransitions( const TQMemArray<int>& from,
+			    const TQMemArray<int>& to );
+#ifndef TQT_NO_REGEXP_CAPTURE
+    void addPlusTransitions( const TQMemArray<int>& from,
+			     const TQMemArray<int>& to, int atom );
+#endif
+
+#ifndef TQT_NO_REGEXP_ANCHOR_ALT
+    int anchorAlternation( int a, int b );
+    int anchorConcatenation( int a, int b );
+#else
+    int anchorAlternation( int a, int b ) { return a & b; }
+    int anchorConcatenation( int a, int b ) { return a | b; }
+#endif
+    void addAnchors( int from, int to, int a );
+
+#ifndef TQT_NO_REGEXP_OPTIM
+    void heuristicallyChooseHeuristic();
+#endif
+
+#if defined(TQT_DEBUG)
+    void dump() const;
+#endif
+
+private:
+    enum { CharClassBit = 0x10000, BackRefBit = 0x20000 };
+
+    /*
+      The struct State represents one state in a modified NFA. The
+      input characters matched are stored in the state instead of on
+      the transitions, something possible for an automaton
+      constructed from a regular expression.
+    */
+    struct State
+    {
+#ifndef TQT_NO_REGEXP_CAPTURE
+	int atom; // which atom does this state belong to?
+#endif
+	int match; // what does it match? (see CharClassBit and BackRefBit)
+	TQMemArray<int> outs; // out-transitions
+	TQMap<int, int> *reenter; // atoms reentered when transiting out
+	TQMap<int, int> *anchors; // anchors met when transiting out
+
+#ifndef TQT_NO_REGEXP_CAPTURE
+	State( int a, int m )
+	    : atom( a ), match( m ), reenter( 0 ), anchors( 0 ) { }
+#else
+	State( int m )
+	    : match( m ), reenter( 0 ), anchors( 0 ) { }
+#endif
+	~State() { delete reenter; delete anchors; }
+    };
+
+#ifndef TQT_NO_REGEXP_LOOKAHEAD
+    /*
+      The struct Lookahead represents a lookahead a la Perl (e.g.,
+      (?=foo) and (?!bar)).
+    */
+    struct Lookahead
+    {
+	TQRegExpEngine *eng; // NFA representing the embedded regular expression
+	bool neg; // negative lookahead?
+
+	Lookahead( TQRegExpEngine *eng0, bool neg0 )
+	    : eng( eng0 ), neg( neg0 ) { }
+	~Lookahead() { delete eng; }
+    };
+#endif
+
+#ifndef TQT_NO_REGEXP_CAPTURE
+    /*
+      The struct Atom represents one node in the hierarchy of regular
+      expression atoms.
+    */
+    struct Atom
+    {
+	int tqparent; // index of tqparent in array of atoms
+	int capture; // index of capture, from 1 to ncap
+    };
+#endif
+
+#ifndef TQT_NO_REGEXP_ANCHOR_ALT
+    /*
+      The struct AnchorAlternation represents a pair of anchors with
+      OR semantics.
+    */
+    struct AnchorAlternation
+    {
+	int a; // this anchor...
+	int b; // ...or this one
+    };
+#endif
+
+    enum { InitialState = 0, FinalState = 1 };
+    void setup( bool caseSensitive );
+    int setupState( int match );
+
+    /*
+      Let's hope that 13 lookaheads and 14 back-references are
+      enough.
+     */
+    enum { MaxLookaheads = 13, MaxBackRefs = 14 };
+    enum { Anchor_Dollar = 0x00000001, Anchor_Caret = 0x00000002,
+	   Anchor_Word = 0x00000004, Anchor_NonWord = 0x00000008,
+	   Anchor_FirstLookahead = 0x00000010,
+	   Anchor_BackRef1Empty = Anchor_FirstLookahead << MaxLookaheads,
+	   Anchor_BackRef0Empty = Anchor_BackRef1Empty >> 1,
+	   Anchor_Alternation = Anchor_BackRef1Empty << MaxBackRefs,
+
+	   Anchor_LookaheadMask = ( Anchor_FirstLookahead - 1 ) ^
+		   ( (Anchor_FirstLookahead << MaxLookaheads) - 1 ) };
+#ifndef TQT_NO_REGEXP_CAPTURE
+    int startAtom( bool capture );
+    void finishAtom( int atom ) { cf = f[atom].tqparent; }
+#endif
+
+#ifndef TQT_NO_REGEXP_LOOKAHEAD
+    int addLookahead( TQRegExpEngine *eng, bool negative );
+#endif
+
+#ifndef TQT_NO_REGEXP_CAPTURE
+    bool isBetterCapture( const int *begin1, const int *end1, const int *begin2,
+			  const int *end2 );
+#endif
+    bool testAnchor( int i, int a, const int *capBegin );
+
+#ifndef TQT_NO_REGEXP_OPTIM
+    bool goodStringMatch();
+    bool badCharMatch();
+#else
+    bool bruteMatch();
+#endif
+    bool matchHere();
+
+    TQPtrVector<State> s; // array of states
+    int ns; // number of states
+#ifndef TQT_NO_REGEXP_CAPTURE
+    TQMemArray<Atom> f; // atom hierarchy
+    int nf; // number of atoms
+    int cf; // current atom
+#endif
+    int officialncap; // number of captures, seen from the outside
+    int ncap; // number of captures, seen from the inside
+#ifndef TQT_NO_REGEXP_CCLASS
+    TQPtrVector<CharClass> cl; // array of character classes
+#endif
+#ifndef TQT_NO_REGEXP_LOOKAHEAD
+    TQPtrVector<Lookahead> ahead; // array of lookaheads
+#endif
+#ifndef TQT_NO_REGEXP_ANCHOR_ALT
+    TQMemArray<AnchorAlternation> aa; // array of (a, b) pairs of anchors
+#endif
+#ifndef TQT_NO_REGEXP_OPTIM
+    bool caretAnchored; // does the regexp start with ^?
+    bool trivial; // is the good-string all that needs to match?
+#endif
+    bool valid; // is the regular expression valid?
+    bool cs; // case sensitive?
+#ifndef TQT_NO_REGEXP_BACKREF
+    int nbrefs; // number of back-references
+#endif
+
+#ifndef TQT_NO_REGEXP_OPTIM
+    bool useGoodStringHeuristic; // use goodStringMatch? otherwise badCharMatch
+
+    int goodEarlyStart; // the index where goodStr can first occur in a match
+    int goodLateStart; // the index where goodStr can last occur in a match
+    TQString goodStr; // the string that any match has to contain
+
+    int minl; // the minimum length of a match
+    TQMemArray<int> occ1; // first-occurrence array
+#endif
+
+    /*
+      The class Box is an abstraction for a regular expression
+      fragment. It can also be seen as one node in the syntax tree of
+      a regular expression with synthetized attributes.
+
+      Its interface is ugly for performance reasons.
+    */
+    class Box
+    {
+    public:
+	Box( TQRegExpEngine *engine );
+	Box( const Box& b ) { operator=( b ); }
+
+	Box& operator=( const Box& b );
+
+	void clear() { operator=( Box(eng) ); }
+	void set( TQChar ch );
+	void set( const CharClass& cc );
+#ifndef TQT_NO_REGEXP_BACKREF
+	void set( int bref );
+#endif
+
+	void cat( const Box& b );
+	void orx( const Box& b );
+	void plus( int atom );
+	void opt();
+	void catAnchor( int a );
+#ifndef TQT_NO_REGEXP_OPTIM
+	void setupHeuristics();
+#endif
+
+#if defined(TQT_DEBUG)
+	void dump() const;
+#endif
+
+    private:
+	void addAnchorsToEngine( const Box& to ) const;
+
+	TQRegExpEngine *eng; // the automaton under construction
+	TQMemArray<int> ls; // the left states (firstpos)
+	TQMemArray<int> rs; // the right states (lastpos)
+	TQMap<int, int> lanchors; // the left anchors
+	TQMap<int, int> ranchors; // the right anchors
+	int skipanchors; // the anchors to match if the box is skipped
+
+#ifndef TQT_NO_REGEXP_OPTIM
+	int earlyStart; // the index where str can first occur
+	int lateStart; // the index where str can last occur
+	TQString str; // a string that has to occur in any match
+	TQString leftStr; // a string occurring at the left of this box
+	TQString rightStr; // a string occurring at the right of this box
+	int maxl; // the maximum length of this box (possibly InftyLen)
+#endif
+
+	int minl; // the minimum length of this box
+#ifndef TQT_NO_REGEXP_OPTIM
+	TQMemArray<int> occ1; // first-occurrence array
+#endif
+    };
+    friend class Box;
+
+    /*
+      This is the lexical analyzer for regular expressions.
+    */
+    enum { Tok_Eos, Tok_Dollar, Tok_LeftParen, Tok_MagicLeftParen,
+	   Tok_PosLookahead, Tok_NegLookahead, Tok_RightParen, Tok_CharClass,
+	   Tok_Caret, Tok_Quantifier, Tok_Bar, Tok_Word, Tok_NonWord,
+	   Tok_Char = 0x10000, Tok_BackRef = 0x20000 };
+    int getChar();
+    int getEscape();
+#ifndef TQT_NO_REGEXP_INTERVAL
+    int getRep( int def );
+#endif
+#ifndef TQT_NO_REGEXP_LOOKAHEAD
+    void skipChars( int n );
+#endif
+    void error( const char *msg );
+    void startTokenizer( const TQChar *rx, int len );
+    int getToken();
+
+    const TQChar *yyIn; // a pointer to the input regular expression pattern
+    int yyPos0; // the position of yyTok in the input pattern
+    int yyPos; // the position of the next character to read
+    int yyLen; // the length of yyIn
+    int yyCh; // the last character read
+    CharClass *yyCharClass; // attribute for Tok_CharClass tokens
+    int yyMinRep; // attribute for Tok_Quantifier
+    int yyMaxRep; // ditto
+    TQString yyError; // syntax error or overflow during parsing?
+
+    /*
+      This is the syntactic analyzer for regular expressions.
+    */
+    int parse( const TQChar *rx, int len );
+    void parseAtom( Box *box );
+    void parseFactor( Box *box );
+    void parseTerm( Box *box );
+    void parseExpression( Box *box );
+
+    int yyTok; // the last token read
+    bool yyMayCapture; // set this to FALSE to disable capturing
+
+    /*
+      This is the engine state during matching.
+    */
+    const TQString *mmStr; // a pointer to the input TQString
+    const TQChar *mmIn; // a pointer to the input string data
+    int mmPos; // the current position in the string
+    int mmCaretPos;
+    int mmLen; // the length of the input string
+    bool mmMinimal; // minimal matching?
+    TQMemArray<int> mmBigArray; // big TQMemArray<int> array
+    int *mmInNextStack; // is state is mmNextStack?
+    int *mmCurStack; // stack of current states
+    int *mmNextStack; // stack of next states
+    int *mmCurCapBegin; // start of current states' captures
+    int *mmNextCapBegin; // start of next states' captures
+    int *mmCurCapEnd; // end of current states' captures
+    int *mmNextCapEnd; // end of next states' captures
+    int *mmTempCapBegin; // start of temporary captures
+    int *mmTempCapEnd; // end of temporary captures
+    int *mmCapBegin; // start of captures for a next state
+    int *mmCapEnd; // end of captures for a next state
+    int *mmSlideTab; // bump-along slide table for bad-character heuristic
+    int mmSlideTabSize; // size of slide table
+#ifndef TQT_NO_REGEXP_BACKREF
+    TQIntDict<int> mmSleeping; // dictionary of back-reference sleepers
+#endif
+    int mmMatchLen; // length of match
+    int mmOneTestMatchedLen; // length of partial match
+};
+
+TQRegExpEngine::TQRegExpEngine( const TQString& rx, bool caseSensitive )
+#ifndef TQT_NO_REGEXP_BACKREF
+    : mmSleeping( 101 )
+#endif
+{
+    setup( caseSensitive );
+    valid = ( parse(rx.tqunicode(), rx.length()) == (int) rx.length() );
+    if ( !valid ) {
+#ifndef TQT_NO_REGEXP_OPTIM
+	trivial = FALSE;
+#endif
+	error( RXERR_LEFTDELIM );
+    }
+}
+
+#ifndef TQT_NO_REGEXP_OPTIM
+TQRegExpEngine::~TQRegExpEngine()
+{
+}
+#endif
+
+/*
+  Tries to match in str and returns an array of (begin, length) pairs
+  for captured text. If there is no match, all pairs are (-1, -1).
+*/
+void TQRegExpEngine::match( const TQString& str, int pos, bool minimal,
+			   bool oneTest, int caretIndex,
+			   TQMemArray<int>& captured )
+{
+    bool matched = FALSE;
+
+#ifndef TQT_NO_REGEXP_OPTIM
+    if ( trivial && !oneTest ) {
+	mmPos = str.tqfind( goodStr, pos, cs );
+	mmMatchLen = goodStr.length();
+	matched = ( mmPos != -1 );
+    } else
+#endif
+    {
+	mmStr = &str;
+	mmIn = str.tqunicode();
+	if ( mmIn == 0 )
+	    mmIn = &TQChar::null;
+	mmPos = pos;
+	mmCaretPos = caretIndex;
+	mmLen = str.length();
+	mmMinimal = minimal;
+	mmMatchLen = 0;
+	mmOneTestMatchedLen = 0;
+
+	if ( valid && mmPos >= 0 && mmPos <= mmLen ) {
+#ifndef TQT_NO_REGEXP_OPTIM
+	    if ( oneTest ) {
+		matched = matchHere();
+	    } else {
+		if ( mmPos <= mmLen - minl ) {
+		    if ( caretAnchored ) {
+			matched = matchHere();
+		    } else if ( useGoodStringHeuristic ) {
+			matched = goodStringMatch();
+		    } else {
+			matched = badCharMatch();
+		    }
+		}
+	    }
+#else
+	    matched = oneTest ? matchHere() : bruteMatch();
+#endif
+	}
+    }
+
+    int capturedSize = 2 + 2 * officialncap;
+    captured.detach();
+    captured.resize( capturedSize );
+    if ( matched ) {
+	captured[0] = mmPos;
+	captured[1] = mmMatchLen;
+	for ( int j = 0; j < officialncap; j++ ) {
+	    int len = mmCapEnd[j] - mmCapBegin[j];
+	    captured[2 + 2 * j] = len > 0 ? mmPos + mmCapBegin[j] : 0;
+	    captured[2 + 2 * j + 1] = len;
+	}
+    } else {
+	// we rely on 2's complement here
+	memset( captured.data(), -1, capturedSize * sizeof(int) );
+    }
+}
+
+/*
+  The three following functions add one state to the automaton and
+  return the number of the state.
+*/
+
+int TQRegExpEngine::createState( TQChar ch )
+{
+    return setupState( ch.tqunicode() );
+}
+
+int TQRegExpEngine::createState( const CharClass& cc )
+{
+#ifndef TQT_NO_REGEXP_CCLASS
+    int n = cl.size();
+    cl.resize( n + 1 );
+    cl.insert( n, new CharClass(cc) );
+    return setupState( CharClassBit | n );
+#else
+    TQ_UNUSED( cc );
+    return setupState( CharClassBit );
+#endif
+}
+
+#ifndef TQT_NO_REGEXP_BACKREF
+int TQRegExpEngine::createState( int bref )
+{
+    if ( bref > nbrefs ) {
+	nbrefs = bref;
+	if ( nbrefs > MaxBackRefs ) {
+	    error( RXERR_LIMIT );
+	    return 0;
+	}
+    }
+    return setupState( BackRefBit | bref );
+}
+#endif
+
+/*
+  The two following functions add a transition between all pairs of
+  states (i, j) where i is fond in from, and j is found in to.
+
+  Cat-transitions are distinguished from plus-transitions for
+  capturing.
+*/
+
+void TQRegExpEngine::addCatTransitions( const TQMemArray<int>& from,
+				       const TQMemArray<int>& to )
+{
+    for ( int i = 0; i < (int) from.size(); i++ ) {
+	State *st = s[from[i]];
+	mergeInto( &st->outs, to );
+    }
+}
+
+#ifndef TQT_NO_REGEXP_CAPTURE
+void TQRegExpEngine::addPlusTransitions( const TQMemArray<int>& from,
+					const TQMemArray<int>& to, int atom )
+{
+    for ( int i = 0; i < (int) from.size(); i++ ) {
+	State *st = s[from[i]];
+	TQMemArray<int> oldOuts = st->outs.copy();
+	mergeInto( &st->outs, to );
+	if ( f[atom].capture >= 0 ) {
+	    if ( st->reenter == 0 )
+		st->reenter = new TQMap<int, int>;
+	    for ( int j = 0; j < (int) to.size(); j++ ) {
+		if ( !st->reenter->tqcontains(to[j]) &&
+		     oldOuts.bsearch(to[j]) < 0 )
+		    st->reenter->insert( to[j], atom );
+	    }
+	}
+    }
+}
+#endif
+
+#ifndef TQT_NO_REGEXP_ANCHOR_ALT
+/*
+  Returns an anchor that means a OR b.
+*/
+int TQRegExpEngine::anchorAlternation( int a, int b )
+{
+    if ( ((a & b) == a || (a & b) == b) && ((a | b) & Anchor_Alternation) == 0 )
+	return a & b;
+
+    int n = aa.size();
+#ifndef TQT_NO_REGEXP_OPTIM
+    if ( n > 0 && aa[n - 1].a == a && aa[n - 1].b == b )
+	return Anchor_Alternation | ( n - 1 );
+#endif
+
+    aa.resize( n + 1 );
+    aa[n].a = a;
+    aa[n].b = b;
+    return Anchor_Alternation | n;
+}
+
+/*
+  Returns an anchor that means a AND b.
+*/
+int TQRegExpEngine::anchorConcatenation( int a, int b )
+{
+    if ( ((a | b) & Anchor_Alternation) == 0 )
+	return a | b;
+    if ( (b & Anchor_Alternation) != 0 )
+	tqSwap( a, b );
+
+    int aprime = anchorConcatenation( aa[a ^ Anchor_Alternation].a, b );
+    int bprime = anchorConcatenation( aa[a ^ Anchor_Alternation].b, b );
+    return anchorAlternation( aprime, bprime );
+}
+#endif
+
+/*
+  Adds anchor a on a transition caracterised by its from state and
+  its to state.
+*/
+void TQRegExpEngine::addAnchors( int from, int to, int a )
+{
+    State *st = s[from];
+    if ( st->anchors == 0 )
+	st->anchors = new TQMap<int, int>;
+    if ( st->anchors->tqcontains(to) )
+	a = anchorAlternation( (*st->anchors)[to], a );
+    st->anchors->insert( to, a );
+}
+
+#ifndef TQT_NO_REGEXP_OPTIM
+/*
+  This function chooses between the good-string and the bad-character
+  heuristics. It computes two scores and chooses the heuristic with
+  the highest score.
+
+  Here are some common-sense constraints on the scores that should be
+  respected if the formulas are ever modified: (1) If goodStr is
+  empty, the good-string heuristic scores 0. (2) If the regular
+  expression is trivial, the good-string heuristic should be used.
+  (3) If the search is case insensitive, the good-string heuristic
+  should be used, unless it scores 0. (Case insensitivity turns all
+  entries of occ1 to 0.) (4) If (goodLateStart - goodEarlyStart) is
+  big, the good-string heuristic should score less.
+*/
+void TQRegExpEngine::heuristicallyChooseHeuristic()
+{
+    if ( minl == 0 ) {
+	useGoodStringHeuristic = FALSE;
+    } else if ( trivial ) {
+	useGoodStringHeuristic = TRUE;
+    } else {
+	/*
+	  Magic formula: The good string has to constitute a good
+	  proportion of the minimum-length string, and appear at a
+	  more-or-less known index.
+	*/
+	int goodStringScore = ( 64 * goodStr.length() / minl ) -
+			      ( goodLateStart - goodEarlyStart );
+	/*
+	  Less magic formula: We pick some characters at random, and
+	  check whether they are good or bad.
+	*/
+	int badCharScore = 0;
+	int step = TQMAX( 1, NumBadChars / 32 );
+	for ( int i = 1; i < NumBadChars; i += step ) {
+	    if ( occ1[i] == NoOccurrence )
+		badCharScore += minl;
+	    else
+		badCharScore += occ1[i];
+	}
+	badCharScore /= minl;
+	useGoodStringHeuristic = ( goodStringScore > badCharScore );
+    }
+}
+#endif
+
+#if defined(TQT_DEBUG)
+void TQRegExpEngine::dump() const
+{
+    int i, j;
+    qDebug( "Case %ssensitive engine", cs ? "" : "in" );
+    qDebug( "  States" );
+    for ( i = 0; i < ns; i++ ) {
+	qDebug( "  %d%s", i,
+		i == InitialState ? " (initial)" :
+		i == FinalState ? " (final)" : "" );
+#ifndef TQT_NO_REGEXP_CAPTURE
+	qDebug( "    in atom %d", s[i]->atom );
+#endif
+	int m = s[i]->match;
+	if ( (m & CharClassBit) != 0 ) {
+	    qDebug( "    match character class %d", m ^ CharClassBit );
+#ifndef TQT_NO_REGEXP_CCLASS
+	    cl[m ^ CharClassBit]->dump();
+#else
+	    qDebug( "    negative character class" );
+#endif
+	} else if ( (m & BackRefBit) != 0 ) {
+	    qDebug( "    match back-reference %d", m ^ BackRefBit );
+	} else if ( m >= 0x20 && m <= 0x7e ) {
+	    qDebug( "    match 0x%.4x (%c)", m, m );
+	} else {
+	    qDebug( "    match 0x%.4x", m );
+	}
+	for ( j = 0; j < (int) s[i]->outs.size(); j++ ) {
+	    int next = s[i]->outs[j];
+	    qDebug( "    -> %d", next );
+	    if ( s[i]->reenter != 0 && s[i]->reenter->tqcontains(next) )
+		qDebug( "       [reenter %d]", (*s[i]->reenter)[next] );
+	    if ( s[i]->anchors != 0 && at(*s[i]->anchors, next) != 0 )
+		qDebug( "       [anchors 0x%.8x]", (*s[i]->anchors)[next] );
+	}
+    }
+#ifndef TQT_NO_REGEXP_CAPTURE
+    if ( nf > 0 ) {
+	qDebug( "  Atom    Parent  Capture" );
+	for ( i = 0; i < nf; i++ )
+	    qDebug( "  %6d  %6d  %6d", i, f[i].tqparent, f[i].capture );
+    }
+#endif
+#ifndef TQT_NO_REGEXP_ANCHOR_ALT
+    for ( i = 0; i < (int) aa.size(); i++ )
+	qDebug( "  Anchor alternation 0x%.8x: 0x%.8x 0x%.9x", i, aa[i].a,
+		aa[i].b );
+#endif
+}
+#endif
+
+void TQRegExpEngine::setup( bool caseSensitive )
+{
+    s.setAutoDelete( TRUE );
+    s.resize( 32 );
+    ns = 0;
+#ifndef TQT_NO_REGEXP_CAPTURE
+    f.resize( 32 );
+    nf = 0;
+    cf = -1;
+#endif
+    officialncap = 0;
+    ncap = 0;
+#ifndef TQT_NO_REGEXP_CCLASS
+    cl.setAutoDelete( TRUE );
+#endif
+#ifndef TQT_NO_REGEXP_LOOKAHEAD
+    ahead.setAutoDelete( TRUE );
+#endif
+#ifndef TQT_NO_REGEXP_OPTIM
+    caretAnchored = TRUE;
+    trivial = TRUE;
+#endif
+    valid = FALSE;
+    cs = caseSensitive;
+#ifndef TQT_NO_REGEXP_BACKREF
+    nbrefs = 0;
+#endif
+#ifndef TQT_NO_REGEXP_OPTIM
+    useGoodStringHeuristic = TRUE;
+    minl = 0;
+    occ1.fill( 0, NumBadChars );
+#endif
+}
+
+int TQRegExpEngine::setupState( int match )
+{
+    if ( (ns & (ns + 1)) == 0 && ns + 1 >= (int) s.size() )
+	s.resize( (ns + 1) << 1 );
+#ifndef TQT_NO_REGEXP_CAPTURE
+    s.insert( ns, new State(cf, match) );
+#else
+    s.insert( ns, new State(match) );
+#endif
+    return ns++;
+}
+
+#ifndef TQT_NO_REGEXP_CAPTURE
+/*
+  Functions startAtom() and finishAtom() should be called to delimit
+  atoms. When a state is created, it is assigned to the current atom.
+  The information is later used for capturing.
+*/
+int TQRegExpEngine::startAtom( bool capture )
+{
+    if ( (nf & (nf + 1)) == 0 && nf + 1 >= (int) f.size() )
+	f.resize( (nf + 1) << 1 );
+    f[nf].tqparent = cf;
+    cf = nf++;
+    f[cf].capture = capture ? ncap++ : -1;
+    return cf;
+}
+#endif
+
+#ifndef TQT_NO_REGEXP_LOOKAHEAD
+/*
+  Creates a lookahead anchor.
+*/
+int TQRegExpEngine::addLookahead( TQRegExpEngine *eng, bool negative )
+{
+    int n = ahead.size();
+    if ( n == MaxLookaheads ) {
+	error( RXERR_LIMIT );
+	return 0;
+    }
+    ahead.resize( n + 1 );
+    ahead.insert( n, new Lookahead(eng, negative) );
+    return Anchor_FirstLookahead << n;
+}
+#endif
+
+#ifndef TQT_NO_REGEXP_CAPTURE
+/*
+  We want the longest leftmost captures.
+*/
+bool TQRegExpEngine::isBetterCapture( const int *begin1, const int *end1,
+				     const int *begin2, const int *end2 )
+{
+    for ( int i = 0; i < ncap; i++ ) {
+	int delta = begin2[i] - begin1[i]; // it has to start early...
+	if ( delta == 0 )
+	    delta = end1[i] - end2[i]; // ...and end late (like a party)
+
+	if ( delta != 0 )
+	    return delta > 0;
+    }
+    return FALSE;
+}
+#endif
+
+/*
+  Returns TRUE if anchor a matches at position mmPos + i in the input
+  string, otherwise FALSE.
+*/
+bool TQRegExpEngine::testAnchor( int i, int a, const int *capBegin )
+{
+    int j;
+
+#ifndef TQT_NO_REGEXP_ANCHOR_ALT
+    if ( (a & Anchor_Alternation) != 0 ) {
+	return testAnchor( i, aa[a ^ Anchor_Alternation].a, capBegin ) ||
+	       testAnchor( i, aa[a ^ Anchor_Alternation].b, capBegin );
+    }
+#endif
+
+    if ( (a & Anchor_Caret) != 0 ) {
+	if ( mmPos + i != mmCaretPos )
+	    return FALSE;
+    }
+    if ( (a & Anchor_Dollar) != 0 ) {
+	if ( mmPos + i != mmLen )
+	    return FALSE;
+    }
+#ifndef TQT_NO_REGEXP_ESCAPE
+    if ( (a & (Anchor_Word | Anchor_NonWord)) != 0 ) {
+	bool before = FALSE;
+	bool after = FALSE;
+	if ( mmPos + i != 0 )
+	    before = isWord( mmIn[mmPos + i - 1] );
+	if ( mmPos + i != mmLen )
+	    after = isWord( mmIn[mmPos + i] );
+	if ( (a & Anchor_Word) != 0 && (before == after) )
+	    return FALSE;
+	if ( (a & Anchor_NonWord) != 0 && (before != after) )
+	    return FALSE;
+    }
+#endif
+#ifndef TQT_NO_REGEXP_LOOKAHEAD
+    if ( (a & Anchor_LookaheadMask) != 0 ) {
+	TQConstString cstr = TQConstString( (TQChar *) mmIn + mmPos + i,
+					   mmLen - mmPos - i );
+	for ( j = 0; j < (int) ahead.size(); j++ ) {
+	    if ( (a & (Anchor_FirstLookahead << j)) != 0 ) {
+		TQMemArray<int> captured;
+		ahead[j]->eng->match( cstr.string(), 0, TRUE, TRUE,
+				      mmCaretPos - mmPos - i, captured );
+		if ( (captured[0] == 0) == ahead[j]->neg )
+		    return FALSE;
+	    }
+	}
+    }
+#endif
+#ifndef TQT_NO_REGEXP_CAPTURE
+#ifndef TQT_NO_REGEXP_BACKREF
+    for ( j = 0; j < nbrefs; j++ ) {
+	if ( (a & (Anchor_BackRef1Empty << j)) != 0 ) {
+	    if ( capBegin[j] != EmptyCapture )
+		return FALSE;
+	}
+    }
+#endif
+#endif
+    return TRUE;
+}
+
+#ifndef TQT_NO_REGEXP_OPTIM
+/*
+  The three following functions are what Jeffrey Friedl would call
+  transmissions (or bump-alongs). Using one or the other should make
+  no difference except in performance.
+*/
+
+bool TQRegExpEngine::goodStringMatch()
+{
+    int k = mmPos + goodEarlyStart;
+    while ( (k = mmStr->tqfind(goodStr, k, cs)) != -1 ) {
+	int from = k - goodLateStart;
+	int to = k - goodEarlyStart;
+	if ( from > mmPos )
+	    mmPos = from;
+
+	while ( mmPos <= to ) {
+	    if ( matchHere() )
+		return TRUE;
+	    mmPos++;
+	}
+	k++;
+    }
+    return FALSE;
+}
+
+bool TQRegExpEngine::badCharMatch()
+{
+    int slideHead = 0;
+    int slideNext = 0;
+    int i;
+    int lastPos = mmLen - minl;
+    memset( mmSlideTab, 0, mmSlideTabSize * sizeof(int) );
+
+    /*
+      Set up the slide table, used for the bad-character heuristic,
+      using the table of first occurrence of each character.
+    */
+    for ( i = 0; i < minl; i++ ) {
+	int sk = occ1[BadChar(mmIn[mmPos + i])];
+	if ( sk == NoOccurrence )
+	    sk = i + 1;
+	if ( sk > 0 ) {
+	    int k = i + 1 - sk;
+	    if ( k < 0 ) {
+		sk = i + 1;
+		k = 0;
+	    }
+	    if ( sk > mmSlideTab[k] )
+		mmSlideTab[k] = sk;
+	}
+    }
+
+    if ( mmPos > lastPos )
+	return FALSE;
+
+    for ( ;; ) {
+	if ( ++slideNext >= mmSlideTabSize )
+	    slideNext = 0;
+	if ( mmSlideTab[slideHead] > 0 ) {
+	    if ( mmSlideTab[slideHead] - 1 > mmSlideTab[slideNext] )
+		mmSlideTab[slideNext] = mmSlideTab[slideHead] - 1;
+	    mmSlideTab[slideHead] = 0;
+	} else {
+	    if ( matchHere() )
+		return TRUE;
+	}
+
+	if ( mmPos == lastPos )
+	    break;
+
+	/*
+	  Update the slide table. This code has much in common with
+	  the initialization code.
+	*/
+	int sk = occ1[BadChar(mmIn[mmPos + minl])];
+	if ( sk == NoOccurrence ) {
+	    mmSlideTab[slideNext] = minl;
+	} else if ( sk > 0 ) {
+	    int k = slideNext + minl - sk;
+	    if ( k >= mmSlideTabSize )
+		k -= mmSlideTabSize;
+	    if ( sk > mmSlideTab[k] )
+		mmSlideTab[k] = sk;
+	}
+	slideHead = slideNext;
+	mmPos++;
+    }
+    return FALSE;
+}
+#else
+bool TQRegExpEngine::bruteMatch()
+{
+    while ( mmPos <= mmLen ) {
+	if ( matchHere() )
+	    return TRUE;
+	mmPos++;
+    }
+    return FALSE;
+}
+#endif
+
+/*
+  Here's the core of the engine. It tries to do a match here and now.
+*/
+bool TQRegExpEngine::matchHere()
+{
+    int ncur = 1, nnext = 0;
+    int i = 0, j, k, m;
+    bool stop = FALSE;
+
+    mmMatchLen = -1;
+    mmOneTestMatchedLen = -1;
+    mmCurStack[0] = InitialState;
+
+#ifndef TQT_NO_REGEXP_CAPTURE
+    if ( ncap > 0 ) {
+	for ( j = 0; j < ncap; j++ ) {
+	    mmCurCapBegin[j] = EmptyCapture;
+	    mmCurCapEnd[j] = EmptyCapture;
+	}
+    }
+#endif
+
+#ifndef TQT_NO_REGEXP_BACKREF
+    int *zzZ = 0;
+
+    while ( (ncur > 0 || !mmSleeping.isEmpty()) && i <= mmLen - mmPos &&
+	    !stop )
+#else
+    while ( ncur > 0 && i <= mmLen - mmPos && !stop )
+#endif
+    {
+	int ch = ( i < mmLen - mmPos ) ? mmIn[mmPos + i].tqunicode() : 0;
+	for ( j = 0; j < ncur; j++ ) {
+	    int cur = mmCurStack[j];
+	    State *scur = s[cur];
+	    TQMemArray<int>& outs = scur->outs;
+	    for ( k = 0; k < (int) outs.size(); k++ ) {
+		int next = outs[k];
+		State *snext = s[next];
+		bool in = TRUE;
+#ifndef TQT_NO_REGEXP_BACKREF
+		int needSomeSleep = 0;
+#endif
+
+		/*
+		  First, check if the anchors are anchored properly.
+		*/
+		if ( scur->anchors != 0 ) {
+		    int a = at( *scur->anchors, next );
+		    if ( a != 0 && !testAnchor(i, a, mmCurCapBegin + j * ncap) )
+			in = FALSE;
+		}
+		/*
+		  If indeed they are, check if the input character is
+		  correct for this transition.
+		*/
+		if ( in ) {
+		    m = snext->match;
+		    if ( (m & (CharClassBit | BackRefBit)) == 0 ) {
+			if ( cs )
+			    in = ( m == ch );
+			else
+			    in = ( TQChar(m).lower() == TQChar(ch).lower() );
+		    } else if ( next == FinalState ) {
+			mmMatchLen = i;
+			stop = mmMinimal;
+			in = TRUE;
+		    } else if ( (m & CharClassBit) != 0 ) {
+#ifndef TQT_NO_REGEXP_CCLASS
+			const CharClass *cc = cl[m ^ CharClassBit];
+			if ( cs )
+			    in = cc->in( ch );
+			else if ( cc->negative() )
+			    in = cc->in( TQChar(ch).lower() ) &&
+				 cc->in( TQChar(ch).upper() );
+			else
+			    in = cc->in( TQChar(ch).lower() ) ||
+				 cc->in( TQChar(ch).upper() );
+#endif
+#ifndef TQT_NO_REGEXP_BACKREF
+		    } else { /* ( (m & BackRefBit) != 0 ) */
+			int bref = m ^ BackRefBit;
+			int ell = j * ncap + ( bref - 1 );
+
+			in = bref <= ncap && mmCurCapBegin[ell] != EmptyCapture;
+			if ( in ) {
+			    if ( cs )
+				in = ( mmIn[mmPos + mmCurCapBegin[ell]]
+				       == TQChar(ch) );
+			    else
+				in = ( mmIn[mmPos + mmCurCapBegin[ell]].lower()
+				       == TQChar(ch).lower() );
+			}
+
+			if ( in ) {
+			    int delta;
+			    if ( mmCurCapEnd[ell] == EmptyCapture )
+				delta = i - mmCurCapBegin[ell];
+			    else
+				delta = mmCurCapEnd[ell] - mmCurCapBegin[ell];
+
+			    in = ( delta <= mmLen - (mmPos + i) );
+			    if ( in && delta > 1 ) {
+				int n = 1;
+				if ( cs ) {
+				    while ( n < delta ) {
+					if ( mmIn[mmPos +
+						  mmCurCapBegin[ell] + n] !=
+					     mmIn[mmPos + i + n] )
+					    break;
+					n++;
+				    }
+				} else {
+				    while ( n < delta ) {
+					TQChar a = mmIn[mmPos +
+						       mmCurCapBegin[ell] + n];
+					TQChar b = mmIn[mmPos + i + n];
+					if ( a.lower() != b.lower() )
+					    break;
+					n++;
+				    }
+				}
+				in = ( n == delta );
+				if ( in )
+				    needSomeSleep = delta - 1;
+			    }
+			}
+#endif
+		    }
+		}
+
+		/*
+		  We must now update our data structures.
+		*/
+		if ( in ) {
+#ifndef TQT_NO_REGEXP_CAPTURE
+		    int *capBegin, *capEnd;
+#endif
+		    /*
+		      If the next state was not encountered yet, all
+		      is fine.
+		    */
+		    if ( (m = mmInNextStack[next]) == -1 ) {
+			m = nnext++;
+			mmNextStack[m] = next;
+			mmInNextStack[next] = m;
+#ifndef TQT_NO_REGEXP_CAPTURE
+			capBegin = mmNextCapBegin + m * ncap;
+			capEnd = mmNextCapEnd + m * ncap;
+
+		    /*
+		      Otherwise, we'll first maintain captures in
+		      temporary arrays, and decide at the end whether
+		      it's best to keep the previous capture zones or
+		      the new ones.
+		    */
+		    } else {
+			capBegin = mmTempCapBegin;
+			capEnd = mmTempCapEnd;
+#endif
+		    }
+
+#ifndef TQT_NO_REGEXP_CAPTURE
+		    /*
+		      Updating the capture zones is much of a task.
+		    */
+		    if ( ncap > 0 ) {
+			memcpy( capBegin, mmCurCapBegin + j * ncap,
+				ncap * sizeof(int) );
+			memcpy( capEnd, mmCurCapEnd + j * ncap,
+				ncap * sizeof(int) );
+			int c = scur->atom, n = snext->atom;
+			int p = -1, q = -1;
+			int cap;
+
+			/*
+			  Lemma 1. For any x in the range [0..nf), we
+			  have f[x].tqparent < x.
+
+			  Proof. By looking at startAtom(), it is
+			  clear that cf < nf holds all the time, and
+			  thus that f[nf].tqparent < nf.
+			*/
+
+			/*
+			  If we are reentering an atom, we empty all
+			  capture zones inside it.
+			*/
+			if ( scur->reenter != 0 &&
+			     (q = at(*scur->reenter, next)) != 0 ) {
+			    TQBitArray b;
+			    b.fill( FALSE, nf );
+			    b.setBit( q, TRUE );
+			    for ( int ell = q + 1; ell < nf; ell++ ) {
+				if ( b.testBit(f[ell].tqparent) ) {
+				    b.setBit( ell, TRUE );
+				    cap = f[ell].capture;
+				    if ( cap >= 0 ) {
+					capBegin[cap] = EmptyCapture;
+					capEnd[cap] = EmptyCapture;
+				    }
+				}
+			    }
+			    p = f[q].tqparent;
+
+			/*
+			  Otherwise, close the capture zones we are
+			  leaving. We are leaving f[c].capture,
+			  f[f[c].tqparent].capture,
+			  f[f[f[c].tqparent].tqparent].capture, ...,
+			  until f[x].capture, with x such that
+			  f[x].tqparent is the youngest common ancestor
+			  for c and n.
+
+			  We go up along c's and n's ancestry until
+			  we tqfind x.
+			*/
+			} else {
+			    p = c;
+			    q = n;
+			    while ( p != q ) {
+				if ( p > q ) {
+				    cap = f[p].capture;
+				    if ( cap >= 0 ) {
+					if ( capBegin[cap] == i ) {
+					    capBegin[cap] = EmptyCapture;
+					    capEnd[cap] = EmptyCapture;
+					} else {
+					    capEnd[cap] = i;
+					}
+				    }
+				    p = f[p].tqparent;
+				} else {
+				    q = f[q].tqparent;
+				}
+			    }
+			}
+
+			/*
+			  In any case, we now open the capture zones
+			  we are entering. We work upwards from n
+			  until we reach p (the tqparent of the atom we
+			  reenter or the youngest common ancestor).
+			*/
+			while ( n > p ) {
+			    cap = f[n].capture;
+			    if ( cap >= 0 ) {
+				capBegin[cap] = i;
+				capEnd[cap] = EmptyCapture;
+			    }
+			    n = f[n].tqparent;
+			}
+			/*
+			  If the next state was already in
+			  mmNextStack, we must choose carefully which
+			  capture zones we want to keep.
+			*/
+			if ( capBegin == mmTempCapBegin &&
+			     isBetterCapture(capBegin, capEnd,
+					     mmNextCapBegin + m * ncap,
+					     mmNextCapEnd + m * ncap) ) {
+			    memcpy( mmNextCapBegin + m * ncap, capBegin,
+				    ncap * sizeof(int) );
+			    memcpy( mmNextCapEnd + m * ncap, capEnd,
+				    ncap * sizeof(int) );
+			}
+		    }
+#ifndef TQT_NO_REGEXP_BACKREF
+		    /*
+		      We are done with updating the capture zones.
+		      It's now time to put the next state to sleep,
+		      if it needs to, and to remove it from
+		      mmNextStack.
+		    */
+		    if ( needSomeSleep > 0 ) {
+			zzZ = new int[1 + 2 * ncap];
+			zzZ[0] = next;
+			if ( ncap > 0 ) {
+			    memcpy( zzZ + 1, capBegin, ncap * sizeof(int) );
+			    memcpy( zzZ + 1 + ncap, capEnd,
+				    ncap * sizeof(int) );
+			}
+			mmInNextStack[mmNextStack[--nnext]] = -1;
+			mmSleeping.insert( i + needSomeSleep, zzZ );
+		    }
+#endif
+#endif
+		}
+	    }
+	}
+#ifndef TQT_NO_REGEXP_CAPTURE
+	/*
+	  If we reached the final state, hurray! Copy the captured
+	  zone.
+	*/
+	if ( ncap > 0 && (m = mmInNextStack[FinalState]) != -1 ) {
+	    memcpy( mmCapBegin, mmNextCapBegin + m * ncap, ncap * sizeof(int) );
+	    memcpy( mmCapEnd, mmNextCapEnd + m * ncap, ncap * sizeof(int) );
+	}
+#ifndef TQT_NO_REGEXP_BACKREF
+	/*
+	  It's time to wake up the sleepers.
+	*/
+	if ( !mmSleeping.isEmpty() ) {
+	    while ( (zzZ = mmSleeping.take(i)) != 0 ) {
+		int next = zzZ[0];
+		int *capBegin = zzZ + 1;
+		int *capEnd = zzZ + 1 + ncap;
+		bool copyOver = TRUE;
+
+		if ( (m = mmInNextStack[zzZ[0]]) == -1 ) {
+		    m = nnext++;
+		    mmNextStack[m] = next;
+		    mmInNextStack[next] = m;
+		} else {
+		    copyOver = isBetterCapture( mmNextCapBegin + m * ncap,
+						mmNextCapEnd + m * ncap,
+						capBegin, capEnd );
+		}
+		if ( copyOver ) {
+		    memcpy( mmNextCapBegin + m * ncap, capBegin,
+			    ncap * sizeof(int) );
+		    memcpy( mmNextCapEnd + m * ncap, capEnd,
+			    ncap * sizeof(int) );
+		}
+		delete[] zzZ;
+	    }
+	}
+#endif
+#endif
+	for ( j = 0; j < nnext; j++ )
+	    mmInNextStack[mmNextStack[j]] = -1;
+
+	// avoid needless iteration that confuses mmOneTestMatchedLen
+	if ( nnext == 1 && mmNextStack[0] == FinalState
+#ifndef TQT_NO_REGEXP_BACKREF
+	     && mmSleeping.isEmpty()
+#endif
+	     )
+	    stop = TRUE;
+
+	tqSwap( mmCurStack, mmNextStack );
+#ifndef TQT_NO_REGEXP_CAPTURE
+	tqSwap( mmCurCapBegin, mmNextCapBegin );
+	tqSwap( mmCurCapEnd, mmNextCapEnd );
+#endif
+	ncur = nnext;
+	nnext = 0;
+	i++;
+    }
+
+#ifndef TQT_NO_REGEXP_BACKREF
+    /*
+      If minimal matching is enabled, we might have some sleepers
+      left.
+    */
+    while ( !mmSleeping.isEmpty() ) {
+	zzZ = mmSleeping.take( *TQIntDictIterator<int>(mmSleeping) );
+	delete[] zzZ;
+    }
+#endif
+
+    mmOneTestMatchedLen = i - 1;
+    return ( mmMatchLen >= 0 );
+}
+
+#ifndef TQT_NO_REGEXP_CCLASS
+
+TQRegExpEngine::CharClass::CharClass()
+    : c( 0 ), n( FALSE )
+{
+#ifndef TQT_NO_REGEXP_OPTIM
+    occ1.fill( NoOccurrence, NumBadChars );
+#endif
+}
+
+TQRegExpEngine::CharClass& TQRegExpEngine::CharClass::operator=(
+	const CharClass& cc )
+{
+    c = cc.c;
+    r = cc.r.copy();
+    n = cc.n;
+#ifndef TQT_NO_REGEXP_OPTIM
+    occ1 = cc.occ1;
+#endif
+    return *this;
+}
+
+void TQRegExpEngine::CharClass::clear()
+{
+    c = 0;
+    r.resize( 0 );
+    n = FALSE;
+}
+
+void TQRegExpEngine::CharClass::setNegative( bool negative )
+{
+    n = negative;
+#ifndef TQT_NO_REGEXP_OPTIM
+    occ1.fill( 0, NumBadChars );
+#endif
+}
+
+void TQRegExpEngine::CharClass::addCategories( int cats )
+{
+    c |= cats;
+#ifndef TQT_NO_REGEXP_OPTIM
+    occ1.fill( 0, NumBadChars );
+#endif
+}
+
+void TQRegExpEngine::CharClass::addRange( ushort from, ushort to )
+{
+    if ( from > to )
+	tqSwap( from, to );
+    int m = r.size();
+    r.resize( m + 1 );
+    r[m].from = from;
+    r[m].to = to;
+
+#ifndef TQT_NO_REGEXP_OPTIM
+    int i;
+
+    if ( to - from < NumBadChars ) {
+	occ1.detach();
+	if ( from % NumBadChars <= to % NumBadChars ) {
+	    for ( i = from % NumBadChars; i <= to % NumBadChars; i++ )
+		occ1[i] = 0;
+	} else {
+	    for ( i = 0; i <= to % NumBadChars; i++ )
+		occ1[i] = 0;
+	    for ( i = from % NumBadChars; i < NumBadChars; i++ )
+		occ1[i] = 0;
+	}
+    } else {
+	occ1.fill( 0, NumBadChars );
+    }
+#endif
+}
+
+bool TQRegExpEngine::CharClass::in( TQChar ch ) const
+{
+#ifndef TQT_NO_REGEXP_OPTIM
+    if ( occ1[BadChar(ch)] == NoOccurrence )
+	return n;
+#endif
+
+    if ( c != 0 && (c & (1 << (int) ch.category())) != 0 )
+	return !n;
+    for ( int i = 0; i < (int) r.size(); i++ ) {
+	if ( ch.tqunicode() >= r[i].from && ch.tqunicode() <= r[i].to )
+	    return !n;
+    }
+    return n;
+}
+
+#if defined(TQT_DEBUG)
+void TQRegExpEngine::CharClass::dump() const
+{
+    int i;
+    qDebug( "    %stive character class", n ? "nega" : "posi" );
+#ifndef TQT_NO_REGEXP_CCLASS
+    if ( c != 0 )
+	qDebug( "      categories 0x%.8x", c );
+#endif
+    for ( i = 0; i < (int) r.size(); i++ )
+	qDebug( "      0x%.4x through 0x%.4x", r[i].from, r[i].to );
+}
+#endif
+#endif
+
+TQRegExpEngine::Box::Box( TQRegExpEngine *engine )
+    : eng( engine ), skipanchors( 0 )
+#ifndef TQT_NO_REGEXP_OPTIM
+      , earlyStart( 0 ), lateStart( 0 ), maxl( 0 )
+#endif
+{
+#ifndef TQT_NO_REGEXP_OPTIM
+    occ1.fill( NoOccurrence, NumBadChars );
+#endif
+    minl = 0;
+}
+
+TQRegExpEngine::Box& TQRegExpEngine::Box::operator=( const Box& b )
+{
+    eng = b.eng;
+    ls = b.ls;
+    rs = b.rs;
+    lanchors = b.lanchors;
+    ranchors = b.ranchors;
+    skipanchors = b.skipanchors;
+#ifndef TQT_NO_REGEXP_OPTIM
+    earlyStart = b.earlyStart;
+    lateStart = b.lateStart;
+    str = b.str;
+    leftStr = b.leftStr;
+    rightStr = b.rightStr;
+    maxl = b.maxl;
+    occ1 = b.occ1;
+#endif
+    minl = b.minl;
+    return *this;
+}
+
+void TQRegExpEngine::Box::set( TQChar ch )
+{
+    ls.resize( 1 );
+    ls[0] = eng->createState( ch );
+    rs = ls;
+    rs.detach();
+#ifndef TQT_NO_REGEXP_OPTIM
+    str = ch;
+    leftStr = ch;
+    rightStr = ch;
+    maxl = 1;
+    occ1.detach();
+    occ1[BadChar(ch)] = 0;
+#endif
+    minl = 1;
+}
+
+void TQRegExpEngine::Box::set( const CharClass& cc )
+{
+    ls.resize( 1 );
+    ls[0] = eng->createState( cc );
+    rs = ls;
+    rs.detach();
+#ifndef TQT_NO_REGEXP_OPTIM
+    maxl = 1;
+    occ1 = cc.firstOccurrence();
+#endif
+    minl = 1;
+}
+
+#ifndef TQT_NO_REGEXP_BACKREF
+void TQRegExpEngine::Box::set( int bref )
+{
+    ls.resize( 1 );
+    ls[0] = eng->createState( bref );
+    rs = ls;
+    rs.detach();
+    if ( bref >= 1 && bref <= MaxBackRefs )
+	skipanchors = Anchor_BackRef0Empty << bref;
+#ifndef TQT_NO_REGEXP_OPTIM
+    maxl = InftyLen;
+#endif
+    minl = 0;
+}
+#endif
+
+void TQRegExpEngine::Box::cat( const Box& b )
+{
+    eng->addCatTransitions( rs, b.ls );
+    addAnchorsToEngine( b );
+    if ( minl == 0 ) {
+	mergeInto( &lanchors, b.lanchors );
+	if ( skipanchors != 0 ) {
+	    for ( int i = 0; i < (int) b.ls.size(); i++ ) {
+		int a = eng->anchorConcatenation( at(lanchors, b.ls[i]),
+						  skipanchors );
+		lanchors.insert( b.ls[i], a );
+	    }
+	}
+	mergeInto( &ls, b.ls );
+    }
+    if ( b.minl == 0 ) {
+	mergeInto( &ranchors, b.ranchors );
+	if ( b.skipanchors != 0 ) {
+	    for ( int i = 0; i < (int) rs.size(); i++ ) {
+		int a = eng->anchorConcatenation( at(ranchors, rs[i]),
+						  b.skipanchors );
+		ranchors.insert( rs[i], a );
+	    }
+	}
+	mergeInto( &rs, b.rs );
+    } else {
+	ranchors = b.ranchors;
+	rs = b.rs;
+    }
+
+#ifndef TQT_NO_REGEXP_OPTIM
+    if ( maxl != InftyLen ) {
+	if ( rightStr.length() + b.leftStr.length() >
+	     TQMAX(str.length(), b.str.length()) ) {
+	    earlyStart = minl - rightStr.length();
+	    lateStart = maxl - rightStr.length();
+	    str = rightStr + b.leftStr;
+	} else if ( b.str.length() > str.length() ) {
+	    earlyStart = minl + b.earlyStart;
+	    lateStart = maxl + b.lateStart;
+	    str = b.str;
+	}
+    }
+
+    if ( (int) leftStr.length() == maxl )
+	leftStr += b.leftStr;
+
+    if ( (int) b.rightStr.length() == b.maxl ) {
+	rightStr += b.rightStr;
+    } else {
+	rightStr = b.rightStr;
+    }
+
+    if ( maxl == InftyLen || b.maxl == InftyLen ) {
+	maxl = InftyLen;
+    } else {
+	maxl += b.maxl;
+    }
+
+    occ1.detach();
+    for ( int i = 0; i < NumBadChars; i++ ) {
+	if ( b.occ1[i] != NoOccurrence && minl + b.occ1[i] < occ1[i] )
+	    occ1[i] = minl + b.occ1[i];
+    }
+#endif
+
+    minl += b.minl;
+    if ( minl == 0 )
+	skipanchors = eng->anchorConcatenation( skipanchors, b.skipanchors );
+    else
+	skipanchors = 0;
+}
+
+void TQRegExpEngine::Box::orx( const Box& b )
+{
+    mergeInto( &ls, b.ls );
+    mergeInto( &lanchors, b.lanchors );
+    mergeInto( &rs, b.rs );
+    mergeInto( &ranchors, b.ranchors );
+
+    if ( b.minl == 0 ) {
+	if ( minl == 0 )
+	    skipanchors = eng->anchorAlternation( skipanchors, b.skipanchors );
+	else
+	    skipanchors = b.skipanchors;
+    }
+
+#ifndef TQT_NO_REGEXP_OPTIM
+    occ1.detach();
+    for ( int i = 0; i < NumBadChars; i++ ) {
+	if ( occ1[i] > b.occ1[i] )
+	    occ1[i] = b.occ1[i];
+    }
+    earlyStart = 0;
+    lateStart = 0;
+    str = TQString();
+    leftStr = TQString();
+    rightStr = TQString();
+    if ( b.maxl > maxl )
+	maxl = b.maxl;
+#endif
+    if ( b.minl < minl )
+	minl = b.minl;
+}
+
+void TQRegExpEngine::Box::plus( int atom )
+{
+#ifndef TQT_NO_REGEXP_CAPTURE
+    eng->addPlusTransitions( rs, ls, atom );
+#else
+    TQ_UNUSED( atom );
+    eng->addCatTransitions( rs, ls );
+#endif
+    addAnchorsToEngine( *this );
+#ifndef TQT_NO_REGEXP_OPTIM
+    maxl = InftyLen;
+#endif
+}
+
+void TQRegExpEngine::Box::opt()
+{
+#ifndef TQT_NO_REGEXP_OPTIM
+    earlyStart = 0;
+    lateStart = 0;
+    str = TQString();
+    leftStr = TQString();
+    rightStr = TQString();
+#endif
+    skipanchors = 0;
+    minl = 0;
+}
+
+void TQRegExpEngine::Box::catAnchor( int a )
+{
+    if ( a != 0 ) {
+	for ( int i = 0; i < (int) rs.size(); i++ ) {
+	    a = eng->anchorConcatenation( at(ranchors, rs[i]), a );
+	    ranchors.insert( rs[i], a );
+	}
+	if ( minl == 0 )
+	    skipanchors = eng->anchorConcatenation( skipanchors, a );
+    }
+}
+
+#ifndef TQT_NO_REGEXP_OPTIM
+void TQRegExpEngine::Box::setupHeuristics()
+{
+    eng->goodEarlyStart = earlyStart;
+    eng->goodLateStart = lateStart;
+    eng->goodStr = eng->cs ? str : str.lower();
+
+    eng->minl = minl;
+    if ( eng->cs ) {
+	/*
+	  A regular expression such as 112|1 has occ1['2'] = 2 and minl =
+	  1 at this point. An entry of occ1 has to be at most minl or
+	  infinity for the rest of the algorithm to go well.
+
+	  We waited until here before normalizing these cases (instead of
+	  doing it in Box::orx()) because sometimes things improve by
+	  themselves. Consider for example (112|1)34.
+	*/
+	for ( int i = 0; i < NumBadChars; i++ ) {
+	    if ( occ1[i] != NoOccurrence && occ1[i] >= minl )
+		occ1[i] = minl;
+	}
+	eng->occ1 = occ1;
+    } else {
+	eng->occ1.fill( 0, NumBadChars );
+    }
+
+    eng->heuristicallyChooseHeuristic();
+}
+#endif
+
+#if defined(TQT_DEBUG)
+void TQRegExpEngine::Box::dump() const
+{
+    int i;
+    qDebug( "Box of at least %d character%s", minl, minl == 1 ? "" : "s" );
+    qDebug( "  Left states:" );
+    for ( i = 0; i < (int) ls.size(); i++ ) {
+	if ( at(lanchors, ls[i]) == 0 )
+	    qDebug( "    %d", ls[i] );
+	else
+	    qDebug( "    %d [anchors 0x%.8x]", ls[i], lanchors[ls[i]] );
+    }
+    qDebug( "  Right states:" );
+    for ( i = 0; i < (int) rs.size(); i++ ) {
+	if ( at(ranchors, rs[i]) == 0 )
+	    qDebug( "    %d", rs[i] );
+	else
+	    qDebug( "    %d [anchors 0x%.8x]", rs[i], ranchors[rs[i]] );
+    }
+    qDebug( "  Skip anchors: 0x%.8x", skipanchors );
+}
+#endif
+
+void TQRegExpEngine::Box::addAnchorsToEngine( const Box& to ) const
+{
+    for ( int i = 0; i < (int) to.ls.size(); i++ ) {
+	for ( int j = 0; j < (int) rs.size(); j++ ) {
+	    int a = eng->anchorConcatenation( at(ranchors, rs[j]),
+					      at(to.lanchors, to.ls[i]) );
+	    eng->addAnchors( rs[j], to.ls[i], a );
+	}
+    }
+}
+
+int TQRegExpEngine::getChar()
+{
+    return ( yyPos == yyLen ) ? EOS : yyIn[yyPos++].tqunicode();
+}
+
+int TQRegExpEngine::getEscape()
+{
+#ifndef TQT_NO_REGEXP_ESCAPE
+    const char tab[] = "afnrtv"; // no b, as \b means word boundary
+    const char backTab[] = "\a\f\n\r\t\v";
+    ushort low;
+    int i;
+#endif
+    ushort val;
+    int prevCh = yyCh;
+
+    if ( prevCh == EOS ) {
+	error( RXERR_END );
+	return Tok_Char | '\\';
+    }
+    yyCh = getChar();
+#ifndef TQT_NO_REGEXP_ESCAPE
+    if ( (prevCh & ~0xff) == 0 ) {
+	const char *p = strchr( tab, prevCh );
+	if ( p != 0 )
+	    return Tok_Char | backTab[p - tab];
+    }
+#endif
+
+    switch ( prevCh ) {
+#ifndef TQT_NO_REGEXP_ESCAPE
+    case '0':
+	val = 0;
+	for ( i = 0; i < 3; i++ ) {
+	    if ( yyCh >= '0' && yyCh <= '7' )
+		val = ( val << 3 ) | ( yyCh - '0' );
+	    else
+		break;
+	    yyCh = getChar();
+	}
+	if ( (val & ~0377) != 0 )
+	    error( RXERR_OCTAL );
+	return Tok_Char | val;
+#endif
+#ifndef TQT_NO_REGEXP_ESCAPE
+    case 'B':
+	return Tok_NonWord;
+#endif
+#ifndef TQT_NO_REGEXP_CCLASS
+    case 'D':
+	// see TQChar::isDigit()
+	yyCharClass->addCategories( 0x7fffffef );
+	return Tok_CharClass;
+    case 'S':
+	// see TQChar::isSpace()
+	yyCharClass->addCategories( 0x7ffff87f );
+	yyCharClass->addRange( 0x0000, 0x0008 );
+	yyCharClass->addRange( 0x000e, 0x001f );
+	yyCharClass->addRange( 0x007f, 0x009f );
+	return Tok_CharClass;
+    case 'W':
+	// see TQChar::isLetterOrNumber()
+	yyCharClass->addCategories( 0x7fe07f8f );
+	yyCharClass->addRange( 0x203f, 0x2040 );
+	yyCharClass->addSingleton( 0x2040 );
+	yyCharClass->addSingleton( 0x30fb );
+	yyCharClass->addRange( 0xfe33, 0xfe34 );
+	yyCharClass->addRange( 0xfe4d, 0xfe4f );
+	yyCharClass->addSingleton( 0xff3f );
+	yyCharClass->addSingleton( 0xff65 );
+	return Tok_CharClass;
+#endif
+#ifndef TQT_NO_REGEXP_ESCAPE
+    case 'b':
+	return Tok_Word;
+#endif
+#ifndef TQT_NO_REGEXP_CCLASS
+    case 'd':
+	// see TQChar::isDigit()
+	yyCharClass->addCategories( 0x00000010 );
+	return Tok_CharClass;
+    case 's':
+	// see TQChar::isSpace()
+	yyCharClass->addCategories( 0x00000380 );
+	yyCharClass->addRange( 0x0009, 0x000d );
+	return Tok_CharClass;
+    case 'w':
+	// see TQChar::isLetterOrNumber()
+	yyCharClass->addCategories( 0x000f8070 );
+	yyCharClass->addSingleton( 0x005f ); // '_'
+	return Tok_CharClass;
+#endif
+#ifndef TQT_NO_REGEXP_ESCAPE
+    case 'x':
+	val = 0;
+	for ( i = 0; i < 4; i++ ) {
+	    low = TQChar( yyCh ).lower();
+	    if ( low >= '0' && low <= '9' )
+		val = ( val << 4 ) | ( low - '0' );
+	    else if ( low >= 'a' && low <= 'f' )
+		val = ( val << 4 ) | ( low - 'a' + 10 );
+	    else
+		break;
+	    yyCh = getChar();
+	}
+	return Tok_Char | val;
+#endif
+    default:
+	if ( prevCh >= '1' && prevCh <= '9' ) {
+#ifndef TQT_NO_REGEXP_BACKREF
+	    val = prevCh - '0';
+	    while ( yyCh >= '0' && yyCh <= '9' ) {
+		val = ( val * 10 ) + ( yyCh - '0' );
+		yyCh = getChar();
+	    }
+	    return Tok_BackRef | val;
+#else
+	    error( RXERR_DISABLED );
+#endif
+	}
+	return Tok_Char | prevCh;
+    }
+}
+
+#ifndef TQT_NO_REGEXP_INTERVAL
+int TQRegExpEngine::getRep( int def )
+{
+    if ( yyCh >= '0' && yyCh <= '9' ) {
+	int rep = 0;
+	do {
+	    rep = 10 * rep + yyCh - '0';
+	    if ( rep >= InftyRep ) {
+		error( RXERR_REPETITION );
+		rep = def;
+	    }
+	    yyCh = getChar();
+	} while ( yyCh >= '0' && yyCh <= '9' );
+	return rep;
+    } else {
+	return def;
+    }
+}
+#endif
+
+#ifndef TQT_NO_REGEXP_LOOKAHEAD
+void TQRegExpEngine::skipChars( int n )
+{
+    if ( n > 0 ) {
+	yyPos += n - 1;
+	yyCh = getChar();
+    }
+}
+#endif
+
+void TQRegExpEngine::error( const char *msg )
+{
+    if ( yyError.isEmpty() )
+	yyError = TQString::tqfromLatin1( msg );
+}
+
+void TQRegExpEngine::startTokenizer( const TQChar *rx, int len )
+{
+    yyIn = rx;
+    yyPos0 = 0;
+    yyPos = 0;
+    yyLen = len;
+    yyCh = getChar();
+    yyCharClass = new CharClass;
+    yyMinRep = 0;
+    yyMaxRep = 0;
+    yyError = TQString();
+}
+
+int TQRegExpEngine::getToken()
+{
+#ifndef TQT_NO_REGEXP_CCLASS
+    ushort pendingCh = 0;
+    bool charPending;
+    bool rangePending;
+    int tok;
+#endif
+    int prevCh = yyCh;
+
+    yyPos0 = yyPos - 1;
+#ifndef TQT_NO_REGEXP_CCLASS
+    yyCharClass->clear();
+#endif
+    yyMinRep = 0;
+    yyMaxRep = 0;
+    yyCh = getChar();
+
+    switch ( prevCh ) {
+    case EOS:
+	yyPos0 = yyPos;
+	return Tok_Eos;
+    case '$':
+	return Tok_Dollar;
+    case '(':
+	if ( yyCh == '?' ) {
+	    prevCh = getChar();
+	    yyCh = getChar();
+	    switch ( prevCh ) {
+#ifndef TQT_NO_REGEXP_LOOKAHEAD
+	    case '!':
+		return Tok_NegLookahead;
+	    case '=':
+		return Tok_PosLookahead;
+#endif
+	    case ':':
+		return Tok_MagicLeftParen;
+	    default:
+		error( RXERR_LOOKAHEAD );
+		return Tok_MagicLeftParen;
+	    }
+	} else {
+	    return Tok_LeftParen;
+	}
+    case ')':
+	return Tok_RightParen;
+    case '*':
+	yyMinRep = 0;
+	yyMaxRep = InftyRep;
+	return Tok_Quantifier;
+    case '+':
+	yyMinRep = 1;
+	yyMaxRep = InftyRep;
+	return Tok_Quantifier;
+    case '.':
+#ifndef TQT_NO_REGEXP_CCLASS
+	yyCharClass->setNegative( TRUE );
+#endif
+	return Tok_CharClass;
+    case '?':
+	yyMinRep = 0;
+	yyMaxRep = 1;
+	return Tok_Quantifier;
+    case '[':
+#ifndef TQT_NO_REGEXP_CCLASS
+	if ( yyCh == '^' ) {
+	    yyCharClass->setNegative( TRUE );
+	    yyCh = getChar();
+	}
+	charPending = FALSE;
+	rangePending = FALSE;
+	do {
+	    if ( yyCh == '-' && charPending && !rangePending ) {
+		rangePending = TRUE;
+		yyCh = getChar();
+	    } else {
+		if ( charPending && !rangePending ) {
+		    yyCharClass->addSingleton( pendingCh );
+		    charPending = FALSE;
+		}
+		if ( yyCh == '\\' ) {
+		    yyCh = getChar();
+		    tok = getEscape();
+		    if ( tok == Tok_Word )
+			tok = '\b';
+		} else {
+		    tok = Tok_Char | yyCh;
+		    yyCh = getChar();
+		}
+		if ( tok == Tok_CharClass ) {
+		    if ( rangePending ) {
+			yyCharClass->addSingleton( '-' );
+			yyCharClass->addSingleton( pendingCh );
+			charPending = FALSE;
+			rangePending = FALSE;
+		    }
+		} else if ( (tok & Tok_Char) != 0 ) {
+		    if ( rangePending ) {
+			yyCharClass->addRange( pendingCh, tok ^ Tok_Char );
+			charPending = FALSE;
+			rangePending = FALSE;
+		    } else {
+			pendingCh = tok ^ Tok_Char;
+			charPending = TRUE;
+		    }
+		} else {
+		    error( RXERR_CHARCLASS );
+		}
+	    }
+	}  while ( yyCh != ']' && yyCh != EOS );
+	if ( rangePending )
+	    yyCharClass->addSingleton( '-' );
+	if ( charPending )
+	    yyCharClass->addSingleton( pendingCh );
+	if ( yyCh == EOS )
+	    error( RXERR_END );
+	else
+	    yyCh = getChar();
+	return Tok_CharClass;
+#else
+	error( RXERR_END );
+	return Tok_Char | '[';
+#endif
+    case '\\':
+	return getEscape();
+    case ']':
+	error( RXERR_LEFTDELIM );
+	return Tok_Char | ']';
+    case '^':
+	return Tok_Caret;
+    case '{':
+#ifndef TQT_NO_REGEXP_INTERVAL
+	yyMinRep = getRep( 0 );
+	yyMaxRep = yyMinRep;
+	if ( yyCh == ',' ) {
+	    yyCh = getChar();
+	    yyMaxRep = getRep( InftyRep );
+	}
+	if ( yyMaxRep < yyMinRep )
+	    tqSwap( yyMinRep, yyMaxRep );
+	if ( yyCh != '}' )
+	    error( RXERR_REPETITION );
+	yyCh = getChar();
+	return Tok_Quantifier;
+#else
+	error( RXERR_DISABLED );
+	return Tok_Char | '{';
+#endif
+    case '|':
+	return Tok_Bar;
+    case '}':
+	error( RXERR_LEFTDELIM );
+	return Tok_Char | '}';
+    default:
+	return Tok_Char | prevCh;
+    }
+}
+
+int TQRegExpEngine::parse( const TQChar *pattern, int len )
+{
+    valid = TRUE;
+    startTokenizer( pattern, len );
+    yyTok = getToken();
+#ifndef TQT_NO_REGEXP_CAPTURE
+    yyMayCapture = TRUE;
+#else
+    yyMayCapture = FALSE;
+#endif
+
+#ifndef TQT_NO_REGEXP_CAPTURE
+    int atom = startAtom( FALSE );
+#endif
+    CharClass anything;
+    Box box( this ); // create InitialState
+    box.set( anything );
+    Box rightBox( this ); // create FinalState
+    rightBox.set( anything );
+
+    Box middleBox( this );
+    parseExpression( &middleBox );
+#ifndef TQT_NO_REGEXP_CAPTURE
+    finishAtom( atom );
+#endif
+#ifndef TQT_NO_REGEXP_OPTIM
+    middleBox.setupHeuristics();
+#endif
+    box.cat( middleBox );
+    box.cat( rightBox );
+    delete yyCharClass;
+    yyCharClass = 0;
+
+    officialncap = ncap;
+#ifndef TQT_NO_REGEXP_BACKREF
+    if ( nbrefs > ncap )
+	ncap = nbrefs;
+#endif
+
+    /*
+      We use one TQMemArray<int> for all the big data used a lot in
+      matchHere() and friends.
+    */
+#ifndef TQT_NO_REGEXP_OPTIM
+    mmSlideTabSize = TQMAX( minl + 1, 16 );
+#else
+    mmSlideTabSize = 0;
+#endif
+    mmBigArray.resize( (3 + 4 * ncap) * ns + 4 * ncap + mmSlideTabSize );
+
+    mmInNextStack = mmBigArray.data();
+    memset( mmInNextStack, -1, ns * sizeof(int) );
+    mmCurStack = mmInNextStack + ns;
+    mmNextStack = mmInNextStack + 2 * ns;
+
+    mmCurCapBegin = mmInNextStack + 3 * ns;
+    mmNextCapBegin = mmCurCapBegin + ncap * ns;
+    mmCurCapEnd = mmCurCapBegin + 2 * ncap * ns;
+    mmNextCapEnd = mmCurCapBegin + 3 * ncap * ns;
+
+    mmTempCapBegin = mmCurCapBegin + 4 * ncap * ns;
+    mmTempCapEnd = mmTempCapBegin + ncap;
+    mmCapBegin = mmTempCapBegin + 2 * ncap;
+    mmCapEnd = mmTempCapBegin + 3 * ncap;
+
+    mmSlideTab = mmTempCapBegin + 4 * ncap;
+
+    if ( !yyError.isEmpty() )
+	return -1;
+
+#ifndef TQT_NO_REGEXP_OPTIM
+    State *sinit = s[InitialState];
+    caretAnchored = ( sinit->anchors != 0 );
+    if ( caretAnchored ) {
+	TQMap<int, int>& anchors = *sinit->anchors;
+	TQMap<int, int>::ConstIterator a;
+	for ( a = anchors.begin(); a != anchors.end(); ++a ) {
+	    if (
+#ifndef TQT_NO_REGEXP_ANCHOR_ALT
+		 (*a & Anchor_Alternation) != 0 ||
+#endif
+		 (*a & Anchor_Caret) == 0 ) {
+		caretAnchored = FALSE;
+		break;
+	    }
+	}
+    }
+#endif
+    return yyPos0;
+}
+
+void TQRegExpEngine::parseAtom( Box *box )
+{
+#ifndef TQT_NO_REGEXP_LOOKAHEAD
+    TQRegExpEngine *eng = 0;
+    bool neg;
+    int len;
+#endif
+
+    if ( (yyTok & Tok_Char) != 0 ) {
+	box->set( TQChar(yyTok ^ Tok_Char) );
+    } else {
+#ifndef TQT_NO_REGEXP_OPTIM
+	trivial = FALSE;
+#endif
+	switch ( yyTok ) {
+	case Tok_Dollar:
+	    box->catAnchor( Anchor_Dollar );
+	    break;
+	case Tok_Caret:
+	    box->catAnchor( Anchor_Caret );
+	    break;
+#ifndef TQT_NO_REGEXP_LOOKAHEAD
+	case Tok_PosLookahead:
+	case Tok_NegLookahead:
+	    neg = ( yyTok == Tok_NegLookahead );
+	    eng = new TQRegExpEngine( cs );
+	    len = eng->parse( yyIn + yyPos - 1, yyLen - yyPos + 1 );
+	    if ( len >= 0 )
+		skipChars( len );
+	    else
+		error( RXERR_LOOKAHEAD );
+	    box->catAnchor( addLookahead(eng, neg) );
+	    yyTok = getToken();
+	    if ( yyTok != Tok_RightParen )
+		error( RXERR_LOOKAHEAD );
+	    break;
+#endif
+#ifndef TQT_NO_REGEXP_ESCAPE
+	case Tok_Word:
+	    box->catAnchor( Anchor_Word );
+	    break;
+	case Tok_NonWord:
+	    box->catAnchor( Anchor_NonWord );
+	    break;
+#endif
+	case Tok_LeftParen:
+	case Tok_MagicLeftParen:
+	    yyTok = getToken();
+	    parseExpression( box );
+	    if ( yyTok != Tok_RightParen )
+		error( RXERR_END );
+	    break;
+	case Tok_CharClass:
+	    box->set( *yyCharClass );
+	    break;
+	case Tok_Quantifier:
+	    error( RXERR_REPETITION );
+	    break;
+	default:
+#ifndef TQT_NO_REGEXP_BACKREF
+	    if ( (yyTok & Tok_BackRef) != 0 )
+		box->set( yyTok ^ Tok_BackRef );
+	    else
+#endif
+		error( RXERR_DISABLED );
+	}
+    }
+    yyTok = getToken();
+}
+
+void TQRegExpEngine::parseFactor( Box *box )
+{
+#ifndef TQT_NO_REGEXP_CAPTURE
+    int atom = startAtom( yyMayCapture && yyTok == Tok_LeftParen );
+#else
+    static const int atom = 0;
+#endif
+
+#ifndef TQT_NO_REGEXP_INTERVAL
+#define YYREDO() \
+	yyIn = in, yyPos0 = pos0, yyPos = pos, yyLen = len, yyCh = ch, \
+	*yyCharClass = charClass, yyMinRep = 0, yyMaxRep = 0, yyTok = tok
+
+    const TQChar *in = yyIn;
+    int pos0 = yyPos0;
+    int pos = yyPos;
+    int len = yyLen;
+    int ch = yyCh;
+    CharClass charClass;
+    if ( yyTok == Tok_CharClass )
+	charClass = *yyCharClass;
+    int tok = yyTok;
+    bool mayCapture = yyMayCapture;
+#endif
+
+    parseAtom( box );
+#ifndef TQT_NO_REGEXP_CAPTURE
+    finishAtom( atom );
+#endif
+
+    if ( yyTok == Tok_Quantifier ) {
+#ifndef TQT_NO_REGEXP_OPTIM
+	trivial = FALSE;
+#endif
+	if ( yyMaxRep == InftyRep ) {
+	    box->plus( atom );
+#ifndef TQT_NO_REGEXP_INTERVAL
+	} else if ( yyMaxRep == 0 ) {
+	    box->clear();
+#endif
+	}
+	if ( yyMinRep == 0 )
+	    box->opt();
+
+#ifndef TQT_NO_REGEXP_INTERVAL
+	yyMayCapture = FALSE;
+	int alpha = ( yyMinRep == 0 ) ? 0 : yyMinRep - 1;
+	int beta = ( yyMaxRep == InftyRep ) ? 0 : yyMaxRep - ( alpha + 1 );
+
+	Box rightBox( this );
+	int i;
+
+	for ( i = 0; i < beta; i++ ) {
+	    YYREDO();
+	    Box leftBox( this );
+	    parseAtom( &leftBox );
+	    leftBox.cat( rightBox );
+	    leftBox.opt();
+	    rightBox = leftBox;
+	}
+	for ( i = 0; i < alpha; i++ ) {
+	    YYREDO();
+	    Box leftBox( this );
+	    parseAtom( &leftBox );
+	    leftBox.cat( rightBox );
+	    rightBox = leftBox;
+	}
+	rightBox.cat( *box );
+	*box = rightBox;
+#endif
+	yyTok = getToken();
+#ifndef TQT_NO_REGEXP_INTERVAL
+	yyMayCapture = mayCapture;
+#endif
+    }
+#undef YYREDO
+}
+
+void TQRegExpEngine::parseTerm( Box *box )
+{
+#ifndef TQT_NO_REGEXP_OPTIM
+    if ( yyTok != Tok_Eos && yyTok != Tok_RightParen && yyTok != Tok_Bar )
+	parseFactor( box );
+#endif
+    while ( yyTok != Tok_Eos && yyTok != Tok_RightParen && yyTok != Tok_Bar ) {
+	Box rightBox( this );
+	parseFactor( &rightBox );
+	box->cat( rightBox );
+    }
+}
+
+void TQRegExpEngine::parseExpression( Box *box )
+{
+    parseTerm( box );
+    while ( yyTok == Tok_Bar ) {
+#ifndef TQT_NO_REGEXP_OPTIM
+	trivial = FALSE;
+#endif
+	Box rightBox( this );
+	yyTok = getToken();
+	parseTerm( &rightBox );
+	box->orx( rightBox );
+    }
+}
+
+/*
+  The struct TQRegExpPrivate tqcontains the private data of a regular
+  expression other than the automaton. It makes it possible for many
+  TQRegExp objects to use the same TQRegExpEngine object with different
+  TQRegExpPrivate objects.
+*/
+struct TQRegExpPrivate
+{
+    TQString pattern; // regular-expression or wildcard pattern
+    TQString rxpattern; // regular-expression pattern
+#ifndef TQT_NO_REGEXP_WILDCARD
+    bool wc : 1; // wildcard mode?
+#endif
+    bool min : 1; // minimal matching? (instead of maximal)
+    bool cs : 1; // case sensitive?
+#ifndef TQT_NO_REGEXP_CAPTURE
+    TQString t; // last string passed to TQRegExp::search() or searchRev()
+    TQStringList capturedCache; // what TQRegExp::capturedTexts() returned last
+#endif
+    TQMemArray<int> captured; // what TQRegExpEngine::search() returned last
+
+    TQRegExpPrivate() { captured.fill( -1, 2 ); }
+};
+
+#ifndef TQT_NO_REGEXP_OPTIM
+static TQSingleCleanupHandler<TQCache<TQRegExpEngine> > cleanup_cache;
+#  ifndef TQT_THREAD_SUPPORT
+static TQCache<TQRegExpEngine> *engineCache = 0;
+#  endif // TQT_THREAD_SUPPORT
+#endif // TQT_NO_REGEXP_OPTIM
+
+static void regexpEngine( TQRegExpEngine *&eng, const TQString &pattern,
+			  bool caseSensitive, bool deref )
+{
+#  ifdef TQT_THREAD_SUPPORT
+    static TQThreadStorage<TQCache<TQRegExpEngine> *> engineCaches;
+    TQCache<TQRegExpEngine> *engineCache = 0;
+    TQThreadInstance *currentThread = TQThreadInstance::current();
+    if (currentThread)
+        engineCache = engineCaches.localData();
+#endif // TQT_THREAD_SUPPORT
+
+    if ( !deref ) {
+#ifndef TQT_NO_REGEXP_OPTIM
+#  ifdef TQT_THREAD_SUPPORT
+        if ( currentThread )
+#  endif
+            {
+                if ( engineCache != 0 ) {
+                    eng = engineCache->take( pattern );
+                    if ( eng == 0 || eng->caseSensitive() != caseSensitive ) {
+                        delete eng;
+                    } else {
+                        eng->ref();
+                        return;
+                    }
+                }
+            }
+#endif // TQT_NO_REGEXP_OPTIM
+	eng = new TQRegExpEngine( pattern, caseSensitive );
+	return;
+    }
+
+    if ( eng->deref() ) {
+#ifndef TQT_NO_REGEXP_OPTIM
+#  ifdef TQT_THREAD_SUPPORT
+        if ( currentThread )
+#  endif
+            {
+                if ( engineCache == 0 ) {
+                    engineCache = new TQCache<TQRegExpEngine>;
+                    engineCache->setAutoDelete( TRUE );
+#  ifdef TQT_THREAD_SUPPORT
+                    engineCaches.setLocalData(engineCache);
+#  else
+                    cleanup_cache.set( &engineCache );
+#  endif // !TQT_THREAD_SUPPORT
+                }
+                if ( !pattern.isNull() &&
+                     engineCache->insert(pattern, eng, 4 + pattern.length() / 4) )
+                    return;
+            }
+#else
+	TQ_UNUSED( pattern );
+#endif // TQT_NO_REGEXP_OPTIM
+	delete eng;
+	eng = 0;
+    }
+}
+
+/*!
+    \enum TQRegExp::CaretMode
+
+    The CaretMode enum defines the different meanings of the caret
+    (<b>^</b>) in a regular expression. The possible values are:
+
+    \value CaretAtZero
+	   The caret corresponds to index 0 in the searched string.
+
+    \value CaretAtOffset
+	   The caret corresponds to the start offset of the search.
+
+    \value CaretWontMatch
+	   The caret never matches.
+*/
+
+/*!
+    Constructs an empty regexp.
+
+    \sa isValid() errorString()
+*/
+TQRegExp::TQRegExp()
+    : eng( 0 )
+{
+    priv = new TQRegExpPrivate;
+#ifndef TQT_NO_REGEXP_WILDCARD
+    priv->wc = FALSE;
+#endif
+    priv->min = FALSE;
+    priv->cs = TRUE;
+}
+
+/*!
+    Constructs a regular expression object for the given \a pattern
+    string. The pattern must be given using wildcard notation if \a
+    wildcard is TRUE (default is FALSE). The pattern is case
+    sensitive, unless \a caseSensitive is FALSE. Matching is greedy
+    (maximal), but can be changed by calling setMinimal().
+
+    \sa setPattern() setCaseSensitive() setWildcard() setMinimal()
+*/
+TQRegExp::TQRegExp( const TQString& pattern, bool caseSensitive, bool wildcard )
+    : eng( 0 )
+{
+    priv = new TQRegExpPrivate;
+    priv->pattern = pattern;
+#ifndef TQT_NO_REGEXP_WILDCARD
+    priv->wc = wildcard;
+#endif
+    priv->min = FALSE;
+    priv->cs = caseSensitive;
+}
+
+/*!
+    Constructs a regular expression as a copy of \a rx.
+
+    \sa operator=()
+*/
+TQRegExp::TQRegExp( const TQRegExp& rx )
+    : eng( 0 )
+{
+    priv = new TQRegExpPrivate;
+    operator=( rx );
+}
+
+/*!
+    Destroys the regular expression and cleans up its internal data.
+*/
+TQRegExp::~TQRegExp()
+{
+    invalidateEngine();
+    delete priv;
+}
+
+/*!
+    Copies the regular expression \a rx and returns a reference to the
+    copy. The case sensitivity, wildcard and minimal matching options
+    are also copied.
+*/
+TQRegExp& TQRegExp::operator=( const TQRegExp& rx )
+{
+    TQRegExpEngine *otherEng = rx.eng;
+    if ( otherEng != 0 )
+	otherEng->ref();
+    invalidateEngine();
+    eng = otherEng;
+    priv->pattern = rx.priv->pattern;
+    priv->rxpattern = rx.priv->rxpattern;
+#ifndef TQT_NO_REGEXP_WILDCARD
+    priv->wc = rx.priv->wc;
+#endif
+    priv->min = rx.priv->min;
+    priv->cs = rx.priv->cs;
+#ifndef TQT_NO_REGEXP_CAPTURE
+    priv->t = rx.priv->t;
+    priv->capturedCache = rx.priv->capturedCache;
+#endif
+    priv->captured = rx.priv->captured;
+    return *this;
+}
+
+/*!
+    Returns TRUE if this regular expression is equal to \a rx;
+    otherwise returns FALSE.
+
+    Two TQRegExp objects are equal if they have the same pattern
+    strings and the same settings for case sensitivity, wildcard and
+    minimal matching.
+*/
+bool TQRegExp::operator==( const TQRegExp& rx ) const
+{
+    return priv->pattern == rx.priv->pattern &&
+#ifndef TQT_NO_REGEXP_WILDCARD
+	   priv->wc == rx.priv->wc &&
+#endif
+	   priv->min == rx.priv->min &&
+	   priv->cs == rx.priv->cs;
+}
+
+/*!
+    \fn bool TQRegExp::operator!=( const TQRegExp& rx ) const
+
+    Returns TRUE if this regular expression is not equal to \a rx;
+    otherwise returns FALSE.
+
+    \sa operator==()
+*/
+
+/*!
+    Returns TRUE if the pattern string is empty; otherwise returns
+    FALSE.
+
+    If you call exactMatch() with an empty pattern on an empty string
+    it will return TRUE; otherwise it returns FALSE since it operates
+    over the whole string. If you call search() with an empty pattern
+    on \e any string it will return the start offset (0 by default)
+    because the empty pattern matches the 'emptiness' at the start of
+    the string. In this case the length of the match returned by
+    matchedLength() will be 0.
+
+    See TQString::isEmpty().
+*/
+
+bool TQRegExp::isEmpty() const
+{
+    return priv->pattern.isEmpty();
+}
+
+/*!
+    Returns TRUE if the regular expression is valid; otherwise returns
+    FALSE. An invalid regular expression never matches.
+
+    The pattern <b>[a-z</b> is an example of an invalid pattern, since
+    it lacks a closing square bracket.
+
+    Note that the validity of a regexp may also depend on the setting
+    of the wildcard flag, for example <b>*.html</b> is a valid
+    wildcard regexp but an invalid full regexp.
+
+    \sa errorString()
+*/
+bool TQRegExp::isValid() const
+{
+    if ( priv->pattern.isEmpty() ) {
+	return TRUE;
+    } else {
+	prepareEngine();
+	return eng->isValid();
+    }
+}
+
+/*!
+    Returns the pattern string of the regular expression. The pattern
+    has either regular expression syntax or wildcard syntax, depending
+    on wildcard().
+
+    \sa setPattern()
+*/
+TQString TQRegExp::pattern() const
+{
+    return priv->pattern;
+}
+
+/*!
+    Sets the pattern string to \a pattern. The case sensitivity,
+    wildcard and minimal matching options are not changed.
+
+    \sa pattern()
+*/
+void TQRegExp::setPattern( const TQString& pattern )
+{
+    if ( priv->pattern != pattern ) {
+	priv->pattern = pattern;
+	invalidateEngine();
+    }
+}
+
+/*!
+    Returns TRUE if case sensitivity is enabled; otherwise returns
+    FALSE. The default is TRUE.
+
+    \sa setCaseSensitive()
+*/
+bool TQRegExp::caseSensitive() const
+{
+    return priv->cs;
+}
+
+/*!
+    Sets case sensitive matching to \a sensitive.
+
+    If \a sensitive is TRUE, <b>\\.txt$</b> matches \c{readme.txt} but
+    not \c{README.TXT}.
+
+    \sa caseSensitive()
+*/
+void TQRegExp::setCaseSensitive( bool sensitive )
+{
+    if ( sensitive != priv->cs ) {
+	priv->cs = sensitive;
+	invalidateEngine();
+    }
+}
+
+#ifndef TQT_NO_REGEXP_WILDCARD
+/*!
+    Returns TRUE if wildcard mode is enabled; otherwise returns FALSE.
+    The default is FALSE.
+
+    \sa setWildcard()
+*/
+bool TQRegExp::wildcard() const
+{
+    return priv->wc;
+}
+
+/*!
+    Sets the wildcard mode for the regular expression. The default is
+    FALSE.
+
+    Setting \a wildcard to TRUE enables simple shell-like wildcard
+    matching. (See \link #wildcard-matching wildcard matching
+    (globbing) \endlink.)
+
+    For example, <b>r*.txt</b> matches the string \c{readme.txt} in
+    wildcard mode, but does not match \c{readme}.
+
+    \sa wildcard()
+*/
+void TQRegExp::setWildcard( bool wildcard )
+{
+    if ( wildcard != priv->wc ) {
+	priv->wc = wildcard;
+	invalidateEngine();
+    }
+}
+#endif
+
+/*!
+    Returns TRUE if minimal (non-greedy) matching is enabled;
+    otherwise returns FALSE.
+
+    \sa setMinimal()
+*/
+bool TQRegExp::minimal() const
+{
+    return priv->min;
+}
+
+/*!
+    Enables or disables minimal matching. If \a minimal is FALSE,
+    matching is greedy (maximal) which is the default.
+
+    For example, suppose we have the input string "We must be
+    \<b>bold\</b>, very \<b>bold\</b>!" and the pattern
+    <b>\<b>.*\</b></b>. With the default greedy (maximal) matching,
+    the match is "We must be <u>\<b>bold\</b>, very
+    \<b>bold\</b></u>!". But with minimal (non-greedy) matching the
+    first match is: "We must be <u>\<b>bold\</b></u>, very
+    \<b>bold\</b>!" and the second match is "We must be \<b>bold\</b>,
+    very <u>\<b>bold\</b></u>!". In practice we might use the pattern
+    <b>\<b>[^\<]+\</b></b> instead, although this will still fail for
+    nested tags.
+
+    \sa minimal()
+*/
+void TQRegExp::setMinimal( bool minimal )
+{
+    priv->min = minimal;
+}
+
+/*!
+    Returns TRUE if \a str is matched exactly by this regular
+    expression; otherwise returns FALSE. You can determine how much of
+    the string was matched by calling matchedLength().
+
+    For a given regexp string, R, exactMatch("R") is the equivalent of
+    search("^R$") since exactMatch() effectively encloses the regexp
+    in the start of string and end of string anchors, except that it
+    sets matchedLength() differently.
+
+    For example, if the regular expression is <b>blue</b>, then
+    exactMatch() returns TRUE only for input \c blue. For inputs \c
+    bluebell, \c blutak and \c lightblue, exactMatch() returns FALSE
+    and matchedLength() will return 4, 3 and 0 respectively.
+
+    Although const, this function sets matchedLength(),
+    capturedTexts() and pos().
+
+    \sa search() searchRev() TQRegExpValidator
+*/
+bool TQRegExp::exactMatch( const TQString& str ) const
+{
+    prepareEngineForMatch( str );
+    eng->match( str, 0, priv->min, TRUE, 0, priv->captured );
+    if ( priv->captured[1] == (int) str.length() ) {
+	return TRUE;
+    } else {
+	priv->captured[0] = 0;
+	priv->captured[1] = eng->partialMatchLength();
+	return FALSE;
+    }
+}
+
+#ifndef TQT_NO_COMPAT
+/*! \obsolete
+
+  Attempts to match in \a str, starting from position \a index.
+  Returns the position of the match, or -1 if there was no match.
+
+  The length of the match is stored in \a *len, unless \a len is a
+  null pointer.
+
+  If \a indexIsStart is TRUE (the default), the position \a index in
+  the string will match the start of string anchor, <b>^</b>, in the
+  regexp, if present. Otherwise, position 0 in \a str will match.
+
+  Use search() and matchedLength() instead of this function.
+
+  \sa TQString::mid() TQConstString
+*/
+int TQRegExp::match( const TQString& str, int index, int *len,
+		    bool indexIsStart ) const
+{
+    int pos = search( str, index, indexIsStart ? CaretAtOffset : CaretAtZero );
+    if ( len != 0 )
+	*len = matchedLength();
+    return pos;
+}
+#endif // TQT_NO_COMPAT
+
+int TQRegExp::search( const TQString& str, int offset ) const
+{
+    return search( str, offset, CaretAtZero );
+}
+
+/*!
+    Attempts to tqfind a match in \a str from position \a offset (0 by
+    default). If \a offset is -1, the search starts at the last
+    character; if -2, at the next to last character; etc.
+
+    Returns the position of the first match, or -1 if there was no
+    match.
+
+    The \a caretMode parameter can be used to instruct whether <b>^</b>
+    should match at index 0 or at \a offset.
+
+    You might prefer to use TQString::tqfind(), TQString::tqcontains() or
+    even TQStringList::grep(). To tqreplace matches use
+    TQString::tqreplace().
+
+    Example:
+    \code
+	TQString str = "offsets: 1.23 .50 71.00 6.00";
+	TQRegExp rx( "\\d*\\.\\d+" );    // primitive floating point matching
+	int count = 0;
+	int pos = 0;
+	while ( (pos = rx.search(str, pos)) != -1 ) {
+	    count++;
+	    pos += rx.matchedLength();
+	}
+	// pos will be 9, 14, 18 and finally 24; count will end up as 4
+    \endcode
+
+    Although const, this function sets matchedLength(),
+    capturedTexts() and pos().
+
+    \sa searchRev() exactMatch()
+*/
+
+int TQRegExp::search( const TQString& str, int offset, CaretMode caretMode ) const
+{
+    prepareEngineForMatch( str );
+    if ( offset < 0 )
+	offset += str.length();
+    eng->match( str, offset, priv->min, FALSE, caretIndex(offset, caretMode),
+		priv->captured );
+    return priv->captured[0];
+}
+
+
+int TQRegExp::searchRev( const TQString& str, int offset ) const
+{
+    return searchRev( str, offset, CaretAtZero );
+}
+
+/*!
+    Attempts to tqfind a match backwards in \a str from position \a
+    offset. If \a offset is -1 (the default), the search starts at the
+    last character; if -2, at the next to last character; etc.
+
+    Returns the position of the first match, or -1 if there was no
+    match.
+
+    The \a caretMode parameter can be used to instruct whether <b>^</b>
+    should match at index 0 or at \a offset.
+
+    Although const, this function sets matchedLength(),
+    capturedTexts() and pos().
+
+    \warning Searching backwards is much slower than searching
+    forwards.
+
+    \sa search() exactMatch()
+*/
+
+int TQRegExp::searchRev( const TQString& str, int offset,
+			CaretMode caretMode ) const
+{
+    prepareEngineForMatch( str );
+    if ( offset < 0 )
+	offset += str.length();
+    if ( offset < 0 || offset > (int) str.length() ) {
+	priv->captured.detach();
+	priv->captured.fill( -1 );
+	return -1;
+    }
+
+    while ( offset >= 0 ) {
+	eng->match( str, offset, priv->min, TRUE, caretIndex(offset, caretMode),
+		    priv->captured );
+	if ( priv->captured[0] == offset )
+	    return offset;
+	offset--;
+    }
+    return -1;
+}
+
+/*!
+    Returns the length of the last matched string, or -1 if there was
+    no match.
+
+    \sa exactMatch() search() searchRev()
+*/
+int TQRegExp::matchedLength() const
+{
+    return priv->captured[1];
+}
+
+#ifndef TQT_NO_REGEXP_CAPTURE
+/*!
+  Returns the number of captures contained in the regular expression.
+ */
+int TQRegExp::numCaptures() const
+{
+    prepareEngine();
+    return eng->numCaptures();
+}
+
+/*!
+    Returns a list of the captured text strings.
+
+    The first string in the list is the entire matched string. Each
+    subsequent list element tqcontains a string that matched a
+    (capturing) subexpression of the regexp.
+
+    For example:
+    \code
+	TQRegExp rx( "(\\d+)(\\s*)(cm|inch(es)?)" );
+	int pos = rx.search( "Length: 36 inches" );
+	TQStringList list = rx.capturedTexts();
+	// list is now ( "36 inches", "36", " ", "inches", "es" )
+    \endcode
+
+    The above example also captures elements that may be present but
+    which we have no interest in. This problem can be solved by using
+    non-capturing parentheses:
+
+    \code
+	TQRegExp rx( "(\\d+)(?:\\s*)(cm|inch(?:es)?)" );
+	int pos = rx.search( "Length: 36 inches" );
+	TQStringList list = rx.capturedTexts();
+	// list is now ( "36 inches", "36", "inches" )
+    \endcode
+
+    Note that if you want to iterate over the list, you should iterate
+    over a copy, e.g.
+    \code
+	TQStringList list = rx.capturedTexts();
+	TQStringList::Iterator it = list.begin();
+	while( it != list.end() ) {
+	    myProcessing( *it );
+	    ++it;
+	}
+    \endcode
+
+    Some regexps can match an indeterminate number of times. For
+    example if the input string is "Offsets: 12 14 99 231 7" and the
+    regexp, \c{rx}, is <b>(\\d+)+</b>, we would hope to get a list of
+    all the numbers matched. However, after calling
+    \c{rx.search(str)}, capturedTexts() will return the list ( "12",
+    "12" ), i.e. the entire match was "12" and the first subexpression
+    matched was "12". The correct approach is to use cap() in a \link
+    #cap_in_a_loop loop \endlink.
+
+    The order of elements in the string list is as follows. The first
+    element is the entire matching string. Each subsequent element
+    corresponds to the next capturing open left parentheses. Thus
+    capturedTexts()[1] is the text of the first capturing parentheses,
+    capturedTexts()[2] is the text of the second and so on
+    (corresponding to $1, $2, etc., in some other regexp languages).
+
+    \sa cap() pos() exactMatch() search() searchRev()
+*/
+TQStringList TQRegExp::capturedTexts()
+{
+    if ( priv->capturedCache.isEmpty() ) {
+	for ( int i = 0; i < (int) priv->captured.size(); i += 2 ) {
+	    TQString m;
+	    if ( priv->captured[i + 1] == 0 )
+		m = TQString::tqfromLatin1( "" );
+	    else if ( priv->captured[i] >= 0 )
+		m = priv->t.mid( priv->captured[i],
+				 priv->captured[i + 1] );
+	    priv->capturedCache.append( m );
+	}
+	priv->t = TQString::null;
+    }
+    return priv->capturedCache;
+}
+
+/*!
+    Returns the text captured by the \a nth subexpression. The entire
+    match has index 0 and the parenthesized subexpressions have
+    indices starting from 1 (excluding non-capturing parentheses).
+
+    \code
+    TQRegExp rxlen( "(\\d+)(?:\\s*)(cm|inch)" );
+    int pos = rxlen.search( "Length: 189cm" );
+    if ( pos > -1 ) {
+	TQString value = rxlen.cap( 1 ); // "189"
+	TQString unit = rxlen.cap( 2 );  // "cm"
+	// ...
+    }
+    \endcode
+
+    The order of elements matched by cap() is as follows. The first
+    element, cap(0), is the entire matching string. Each subsequent
+    element corresponds to the next capturing open left parentheses.
+    Thus cap(1) is the text of the first capturing parentheses, cap(2)
+    is the text of the second, and so on.
+
+    \target cap_in_a_loop
+    Some patterns may lead to a number of matches which cannot be
+    determined in advance, for example:
+
+    \code
+    TQRegExp rx( "(\\d+)" );
+    str = "Offsets: 12 14 99 231 7";
+    TQStringList list;
+    pos = 0;
+    while ( pos >= 0 ) {
+	pos = rx.search( str, pos );
+	if ( pos > -1 ) {
+	    list += rx.cap( 1 );
+	    pos  += rx.matchedLength();
+	}
+    }
+    // list tqcontains "12", "14", "99", "231", "7"
+    \endcode
+
+    \sa capturedTexts() pos() exactMatch() search() searchRev()
+*/
+TQString TQRegExp::cap( int nth )
+{
+    if ( nth < 0 || nth >= (int) priv->captured.size() / 2 ) {
+	return TQString::null;
+    } else {
+	return capturedTexts()[nth];
+    }
+}
+
+/*!
+    Returns the position of the \a nth captured text in the searched
+    string. If \a nth is 0 (the default), pos() returns the position
+    of the whole match.
+
+    Example:
+    \code
+    TQRegExp rx( "/([a-z]+)/([a-z]+)" );
+    rx.search( "Output /dev/null" );    // returns 7 (position of /dev/null)
+    rx.pos( 0 );                        // returns 7 (position of /dev/null)
+    rx.pos( 1 );                        // returns 8 (position of dev)
+    rx.pos( 2 );                        // returns 12 (position of null)
+    \endcode
+
+    For zero-length matches, pos() always returns -1. (For example, if
+    cap(4) would return an empty string, pos(4) returns -1.) This is
+    due to an implementation tradeoff.
+
+    \sa capturedTexts() exactMatch() search() searchRev()
+*/
+int TQRegExp::pos( int nth )
+{
+    if ( nth < 0 || nth >= (int) priv->captured.size() / 2 )
+	return -1;
+    else
+	return priv->captured[2 * nth];
+}
+
+/*!
+  Returns a text string that explains why a regexp pattern is
+  invalid the case being; otherwise returns "no error occurred".
+
+  \sa isValid()
+*/
+TQString TQRegExp::errorString()
+{
+    if ( isValid() ) {
+	return TQString( RXERR_OK );
+    } else {
+	return eng->errorString();
+    }
+}
+#endif
+
+/*!
+  Returns the string \a str with every regexp special character
+  escaped with a backslash. The special characters are $, (, ), *, +,
+  ., ?, [, \, ], ^, {, | and }.
+
+  Example:
+  \code
+     s1 = TQRegExp::escape( "bingo" );   // s1 == "bingo"
+     s2 = TQRegExp::escape( "f(x)" );    // s2 == "f\\(x\\)"
+  \endcode
+
+  This function is useful to construct regexp patterns dynamically:
+
+  \code
+    TQRegExp rx( "(" + TQRegExp::escape(name) +
+		"|" + TQRegExp::escape(alias) + ")" );
+  \endcode
+*/
+TQString TQRegExp::escape( const TQString& str )
+{
+    static const char meta[] = "$()*+.?[\\]^{|}";
+    TQString quoted = str;
+    int i = 0;
+
+    while ( i < (int) quoted.length() ) {
+	if ( strchr(meta, quoted[i].latin1()) != 0 )
+	    quoted.insert( i++, "\\" );
+	i++;
+    }
+    return quoted;
+}
+
+void TQRegExp::prepareEngine() const
+{
+    if ( eng == 0 ) {
+#ifndef TQT_NO_REGEXP_WILDCARD
+	if ( priv->wc )
+	    priv->rxpattern = wc2rx( priv->pattern );
+	else
+#endif
+	    priv->rxpattern = priv->pattern.isNull() ? TQString::tqfromLatin1( "" )
+			      : priv->pattern;
+	TQRegExp *that = (TQRegExp *) this;
+	// that->eng = newEngine( priv->rxpattern, priv->cs );
+	regexpEngine( that->eng, priv->rxpattern, priv->cs, FALSE );
+	priv->captured.detach();
+	priv->captured.fill( -1, 2 + 2 * eng->numCaptures() );
+    }
+}
+
+void TQRegExp::prepareEngineForMatch( const TQString& str ) const
+{
+    prepareEngine();
+#ifndef TQT_NO_REGEXP_CAPTURE
+    priv->t = str;
+    priv->capturedCache.clear();
+#else
+    TQ_UNUSED( str );
+#endif
+}
+
+void TQRegExp::invalidateEngine()
+{
+    if ( eng != 0 ) {
+	regexpEngine( eng, priv->rxpattern, priv->cs, TRUE );
+	priv->rxpattern = TQString();
+	eng = 0;
+    }
+}
+
+int TQRegExp::caretIndex( int offset, CaretMode caretMode )
+{
+    if ( caretMode == CaretAtZero ) {
+	return 0;
+    } else if ( caretMode == CaretAtOffset ) {
+	return offset;
+    } else { // CaretWontMatch
+	return -1;
+    }
+}
+
+#endif // USE_QT4
+
+#endif // TQT_NO_REGEXP
diff --git a/tqtinterface/qt4/src/tools/tqregexp.h b/tqtinterface/qt4/src/tools/tqregexp.h
new file mode 100644
index 0000000..23b92a1
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqregexp.h
@@ -0,0 +1,181 @@
+/****************************************************************************
+**
+** Definition of TQRegExp class
+**
+** Created : 950126
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQREGEXP_H
+#define TQREGEXP_H
+
+#include "tqtglobaldefines.h"
+
+#ifndef TQT_H
+#include "tqstringlist.h"
+#endif // TQT_H
+
+#ifdef USE_QT4
+
+#include <Qt/qregexp.h>
+#include <Qt/qstringlist.h>
+
+#endif // USE_QT4
+
+#ifndef TQT_NO_REGEXP
+
+#ifdef USE_QT4
+
+class TQ_EXPORT TQRegExp : public QRegExp
+{
+public:
+	TQRegExp() : QRegExp() {}
+	TQRegExp( const QString& pattern, bool caseSensitive = TRUE, bool wildcard = FALSE ) : QRegExp( pattern, (Qt::CaseSensitivity)caseSensitive, (wildcard)?QRegExp::Wildcard:QRegExp::RegExp ) {}
+	TQRegExp( const QRegExp& rx ) : QRegExp( rx ) {}
+
+#if defined(TQ_TQDOC)
+	int search( const TQString& str, int offset = 0, CaretMode caretMode = CaretAtZero ) const;
+	int searchRev( const TQString& str, int offset = -1, CaretMode caretMode = CaretAtZero ) const;
+#else
+	int search( const TQString& str, int offset = 0 ) const;
+	int search( const TQString& str, int offset, CaretMode caretMode ) const;
+	int searchRev( const TQString& str, int offset = -1 ) const;
+	int searchRev( const TQString& str, int offset, CaretMode caretMode ) const;
+#endif
+
+	inline TQString cap( int nth = 0 ) { return QRegExp::cap(nth); }
+
+#ifndef TQT_NO_COMPAT
+	inline int match( const TQString& str, int index = 0, int *len = 0, bool indexIsStart = TRUE ) const {
+		int r = search(str, index, indexIsStart?CaretAtOffset:CaretAtZero);
+		if (len != NULL) *len = matchedLength();
+		return r;
+	}
+#endif
+
+	bool caseSensitive() const;
+	void setCaseSensitive( bool sensitive );
+
+#ifndef TQT_NO_REGEXP_WILDCARD
+	inline bool wildcard() const { return (patternSyntax() == QRegExp::Wildcard); }
+	inline void setWildcard( bool wildcard ) { setPatternSyntax(wildcard ? QRegExp::Wildcard : QRegExp::RegExp); }
+#endif
+
+#ifndef TQT_NO_REGEXP_CAPTURE
+	inline TQStringList tqcapturedTexts() {
+		QStringList ql = capturedTexts();
+		TQStringList tqsl;
+		tqsl.clear();
+		for (int i = 0; i < ql.size(); ++i) tqsl.append(ql.at(i));
+		return tqsl;
+	}
+#endif
+};
+
+#else // USE_QT4
+
+class TQRegExpEngine;
+struct TQRegExpPrivate;
+
+class TQ_EXPORT TQRegExp
+{
+public:
+    enum CaretMode { CaretAtZero, CaretAtOffset, CaretWontMatch };
+
+    TQRegExp();
+    TQRegExp( const TQString& pattern, bool caseSensitive = TRUE,
+	     bool wildcard = FALSE );
+    TQRegExp( const TQRegExp& rx );
+    ~TQRegExp();
+    TQRegExp& operator=( const TQRegExp& rx );
+
+    bool operator==( const TQRegExp& rx ) const;
+    bool operator!=( const TQRegExp& rx ) const { return !operator==( rx ); }
+
+    bool isEmpty() const;
+    bool isValid() const;
+    TQString pattern() const;
+    void setPattern( const TQString& pattern );
+    bool caseSensitive() const;
+    void setCaseSensitive( bool sensitive );
+#ifndef TQT_NO_REGEXP_WILDCARD
+    bool wildcard() const;
+    void setWildcard( bool wildcard );
+#endif
+    bool minimal() const;
+    void setMinimal( bool minimal );
+
+    bool exactMatch( const TQString& str ) const;
+#ifndef TQT_NO_COMPAT
+    int match( const TQString& str, int index = 0, int *len = 0,
+	       bool indexIsStart = TRUE ) const;
+#endif
+
+#if defined(TQ_TQDOC)
+    int search( const TQString& str, int offset = 0,
+		CaretMode caretMode = CaretAtZero ) const;
+    int searchRev( const TQString& str, int offset = -1,
+		   CaretMode caretMode = CaretAtZero ) const;
+#else
+    // ### TQt 4.0: reduce these four to two functions
+    int search( const TQString& str, int offset = 0 ) const;
+    int search( const TQString& str, int offset, CaretMode caretMode ) const;
+    int searchRev( const TQString& str, int offset = -1 ) const;
+    int searchRev( const TQString& str, int offset, CaretMode caretMode ) const;
+#endif
+    int matchedLength() const;
+#ifndef TQT_NO_REGEXP_CAPTURE
+    int numCaptures() const;
+    TQStringList capturedTexts();
+    TQString cap( int nth = 0 );
+    int pos( int nth = 0 );
+    TQString errorString();
+#endif
+
+    static TQString escape( const TQString& str );
+
+private:
+    void prepareEngine() const;
+    void prepareEngineForMatch( const TQString& str ) const;
+    void invalidateEngine();
+
+    static int caretIndex( int offset, CaretMode caretMode );
+
+    TQRegExpEngine *eng;
+    TQRegExpPrivate *priv;
+};
+#endif // USE_QT4
+#endif // TQT_NO_REGEXP
+#endif // TQREGEXP_H
diff --git a/tqtinterface/qt4/src/tools/tqsemaphore.cpp b/tqtinterface/qt4/src/tools/tqsemaphore.cpp
new file mode 100644
index 0000000..7f1eff9
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqsemaphore.cpp
@@ -0,0 +1,255 @@
+/****************************************************************************
+**
+** TQSemaphore class for Unix
+**
+** Created : 20010725
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#if defined(TQT_THREAD_SUPPORT)
+
+#include "tqsemaphore.h"
+#include "tqmutex.h"
+#include "tqwaitcondition.h"
+
+
+/*!
+    \class TQSemaphore tqsemaphore.h
+    \threadsafe
+    \brief The TQSemaphore class provides a robust integer semaphore.
+
+    \ingroup thread
+    \ingroup environment
+
+    A TQSemaphore can be used to serialize thread execution, in a
+    similar way to a TQMutex. A semaphore differs from a mutex, in
+    that a semaphore can be accessed by more than one thread at a
+    time.
+
+    For example, suppose we have an application that stores data in a
+    large tree structure. The application creates 10 threads
+    (commonly called a thread pool) to perform searches on the tree.
+    When the application searches the tree for some piece of data, it
+    uses one thread per base node to do the searching. A semaphore
+    could be used to make sure that two threads don't try to search
+    the same branch of the tree at the same time.
+
+    A non-computing example of a semaphore would be dining at a
+    restuarant. A semaphore is initialized to have a maximum count
+    equal to the number of chairs in the restuarant. As people
+    arrive, they want a seat. As seats are filled, the semaphore is
+    accessed, once per person. As people leave, the access is
+    released, allowing more people to enter. If a party of 10 people
+    want to be seated, but there are only 9 seats, those 10 people
+    will wait, but a party of 4 people would be seated (taking the
+    available seats to 5, making the party of 10 people wait longer).
+
+    When a semaphore is created it is given a number which is the
+    maximum number of concurrent accesses it will permit. Accesses to
+    the sempahore are gained using operator++() or operator+=(), and
+    released with operator--() or operator-=(). The number of
+    accesses allowed is retrieved with available(), and the total
+    number with total(). Note that the incrementing functions will
+    block if there aren't enough available accesses. Use tryAccess()
+    if you want to acquire accesses without blocking.
+*/
+
+
+class TQSemaphorePrivate {
+public:
+    TQSemaphorePrivate(int);
+
+    TQMutex mutex;
+    TQWaitCondition cond;
+
+    int value, max;
+};
+
+
+TQSemaphorePrivate::TQSemaphorePrivate(int m)
+    : mutex(FALSE), value(0), max(m)
+{
+}
+
+
+/*!
+    Creates a new semaphore. The semaphore can be concurrently
+    accessed at most \a maxcount times.
+*/
+TQSemaphore::TQSemaphore(int maxcount)
+{
+    d = new TQSemaphorePrivate(maxcount);
+}
+
+
+/*!
+    Destroys the semaphore.
+
+    \warning If you destroy a semaphore that has accesses in use the
+    resultant behavior is undefined.
+*/
+TQSemaphore::~TQSemaphore()
+{
+    delete d;
+}
+
+
+/*!
+    Postfix ++ operator.
+
+    Try to get access to the semaphore. If \l available() == 0, this
+    call will block until it can get access, i.e. until available() \>
+    0.
+*/
+int TQSemaphore::operator++(int)
+{
+    TQMutexLocker locker(&d->mutex);
+    while (d->value >= d->max)
+	d->cond.wait(locker.mutex());
+
+    ++d->value;
+    if (d->value > d->max)
+	d->value = d->max;
+
+    return d->value;
+}
+
+
+/*!
+    Postfix -- operator.
+
+    Release access of the semaphore. This wakes all threads waiting
+    for access to the semaphore.
+*/
+int TQSemaphore::operator--(int)
+{
+    TQMutexLocker locker(&d->mutex);
+
+    --d->value;
+    if (d->value < 0)
+	d->value = 0;
+
+    d->cond.wakeAll();
+
+    return d->value;
+}
+
+
+/*!
+    Try to get access to the semaphore. If \l available() \< \a n, this
+    call will block until it can get all the accesses it wants, i.e.
+    until available() \>= \a n.
+*/
+int TQSemaphore::operator+=(int n)
+{
+    TQMutexLocker locker(&d->mutex);
+
+    if ( n < 0 || n > d->max ) {
+#ifdef TQT_CHECK_RANGE
+	qWarning( "TQSemaphore::operator+=: paramter %d out of range", n );
+#endif // TQT_CHECK_RANGE
+	n = n < 0 ? 0 : d->max;
+    }
+
+    while (d->value + n > d->max)
+	d->cond.wait(locker.mutex());
+
+    d->value += n;
+
+    return d->value;
+}
+
+
+/*!
+    Release \a n accesses to the semaphore.
+*/
+int TQSemaphore::operator-=(int n)
+{
+    TQMutexLocker locker(&d->mutex);
+
+    if ( n < 0 || n > d->value ) {
+#ifdef TQT_CHECK_RANGE
+	qWarning( "TQSemaphore::operator-=: paramter %d out of range", n );
+#endif // TQT_CHECK_RANGE
+	n = n < 0 ? 0 : d->value;
+    }
+
+    d->value -= n;
+    d->cond.wakeAll();
+
+    return d->value;
+}
+
+
+/*!
+    Returns the number of accesses currently available to the
+    semaphore.
+*/
+int TQSemaphore::available() const
+{
+    TQMutexLocker locker(&d->mutex);
+    return d->max - d->value;
+}
+
+
+/*!
+    Returns the total number of accesses to the semaphore.
+*/
+int TQSemaphore::total() const
+{
+    TQMutexLocker locker(&d->mutex);
+    return d->max;
+}
+
+
+/*!
+    Try to get access to the semaphore. If \l available() \< \a n, this
+    function will return FALSE immediately. If \l available() \>= \a n,
+    this function will take \a n accesses and return TRUE. This
+    function does \e not block.
+*/
+bool TQSemaphore::tryAccess(int n)
+{
+    TQMutexLocker locker(&d->mutex);
+
+    if (d->value + n > d->max)
+	return FALSE;
+
+    d->value += n;
+
+    return TRUE;
+}
+
+#endif // TQT_THREAD_SUPPORT
diff --git a/tqtinterface/qt4/src/tools/tqsemaphore.h b/tqtinterface/qt4/src/tools/tqsemaphore.h
new file mode 100644
index 0000000..31e25a9
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqsemaphore.h
@@ -0,0 +1,81 @@
+/****************************************************************************
+**
+** Definition of TQSemaphore class
+**
+** Created : 931107
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQSEMAPHORE_H
+#define TQSEMAPHORE_H
+
+#ifndef TQT_H
+#include "tqglobal.h"
+#endif // TQT_H
+
+#if defined(TQT_THREAD_SUPPORT)
+
+class TQSemaphorePrivate;
+
+class TQ_EXPORT TQSemaphore
+{
+public:
+    TQSemaphore( int );
+    virtual ~TQSemaphore();
+
+    int available() const;
+    int total() const;
+
+    // postfix operators
+    int operator++(int);
+    int operator--(int);
+
+    int operator+=(int);
+    int operator-=(int);
+
+    bool tryAccess(int);
+
+private:
+    TQSemaphorePrivate *d;
+
+#if defined(TQ_DISABLE_COPY)
+    TQSemaphore(const TQSemaphore &);
+    TQSemaphore &operator=(const TQSemaphore &);
+#endif
+};
+
+#endif
+
+#endif
diff --git a/tqtinterface/qt4/src/tools/tqsettings.cpp b/tqtinterface/qt4/src/tools/tqsettings.cpp
new file mode 100644
index 0000000..3ef5e5e
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqsettings.cpp
@@ -0,0 +1,2105 @@
+/****************************************************************************
+**
+** Implementation of TQSettings class
+**
+** Created : 000626
+**
+** Copyright (C) 2000-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "tqplatformdefs.h"
+
+// POSIX Large File Support redefines open -> open64
+static inline int qt_open( const char *pathname, int flags, mode_t mode )
+{ return ::open( pathname, flags, mode ); }
+#if defined(open)
+# undef open
+#endif
+
+// POSIX Large File Support redefines truncate -> truncate64
+#if defined(truncate)
+# undef truncate
+#endif
+
+#include "tqsettings.h"
+
+#ifndef TQT_NO_SETTINGS
+
+#include "tqdir.h"
+#include "tqfile.h"
+#include "tqfileinfo.h"
+#include "tqmap.h"
+#include "tqtextstream.h"
+#include "tqregexp.h"
+#include <private/tqsettings_p.h>
+#ifndef NO_ERRNO_H
+#include <errno.h>
+#endif
+
+/*!
+    \class TQSettings
+    \brief The TQSettings class provides persistent platform-independent application settings.
+
+    \ingroup io
+    \ingroup misc
+    \mainclass
+
+    On Unix systems, TQSettings uses text files to store settings. On Windows
+    systems, TQSettings uses the system registry.  On Mac OS X, TQSettings uses
+    the Carbon preferences API.
+
+    Each setting comprises an identifying key and the data associated with
+    the key. A key is a tqunicode string which consists of \e two or more
+    subkeys. A subkey is a slash, '/', followed by one or more tqunicode
+    characters (excluding slashes, newlines, carriage returns and equals,
+    '=', signs). The associated data, called the entry or value, may be a
+    boolean, an integer, a double, a string or a list of strings. Entry
+    strings may contain any tqunicode characters.
+
+    If you want to save and restore the entire desktop's settings, i.e.
+    which applications are running, use TQSettings to save the settings
+    for each individual application and TQSessionManager to save the
+    desktop's session.
+
+    Example settings:
+    \code
+    /MyCompany/MyApplication/background color
+    /MyCompany/MyApplication/foreground color
+    /MyCompany/MyApplication/tqgeometry/x
+    /MyCompany/MyApplication/tqgeometry/y
+    /MyCompany/MyApplication/tqgeometry/width
+    /MyCompany/MyApplication/tqgeometry/height
+    /MyCompany/MyApplication/recent files/1
+    /MyCompany/MyApplication/recent files/2
+    /MyCompany/MyApplication/recent files/3
+    \endcode
+    Each line above is a complete key, made up of subkeys.
+
+    A typical usage pattern for reading settings at application
+    startup:
+    \code
+    TQSettings settings;
+    settings.setPath( "MyCompany.com", "MyApplication" );
+
+    TQString bgColor = settings.readEntry( "/colors/background", "white" );
+    int width = settings.readNumEntry( "/tqgeometry/width", 640 );
+    // ...
+    \endcode
+
+    A typical usage pattern for saving settings at application exit or
+    'save preferences':
+    \code
+    TQSettings settings;
+    settings.setPath( "MyCompany.com", "MyApplication" );
+
+    settings.writeEntry( "/colors/background", bgColor );
+    settings.writeEntry( "/tqgeometry/width", width );
+    // ...
+    \endcode
+
+    A key prefix can be prepended to all keys using beginGroup(). The
+    application of the prefix is stopped using endGroup(). For
+    example:
+    \code
+    TQSettings settings;
+
+    settings.beginGroup( "/MainWindow" );
+        settings.beginGroup( "/Geometry" );
+            int x = settings.readEntry( "/x" );
+            // ...
+        settings.endGroup();
+        settings.beginGroup( "/Toolbars" );
+            // ...
+        settings.endGroup();
+    settings.endGroup();
+    \endcode
+
+    You can get a list of entry-holding keys by calling entryList(), and
+    a list of key-holding keys using subkeyList().
+
+    \code
+    TQStringList keys = settings.entryList( "/MyApplication" );
+    // keys tqcontains 'background color' and 'foreground color'.
+
+    TQStringList keys = settings.entryList( "/MyApplication/recent files" );
+    // keys tqcontains '1', '2' and '3'.
+
+    TQStringList subkeys = settings.subkeyList( "/MyApplication" );
+    // subkeys tqcontains 'tqgeometry' and 'recent files'
+
+    TQStringList subkeys = settings.subkeyList( "/MyApplication/recent files" );
+    // subkeys is empty.
+    \endcode
+
+    Since settings for Windows are stored in the registry there are
+    some size limitations as follows:
+    \list
+    \i A subkey may not exceed 255 characters.
+    \i An entry's value may not exceed 16,300 characters.
+    \i All the values of a key (for example, all the 'recent files'
+    subkeys values), may not exceed 65,535 characters.
+    \endlist
+
+    These limitations are not enforced on Unix or Mac OS X.
+
+    \warning Creating multiple, simultaneous instances of TQSettings writing
+    to a text file may lead to data loss! This is a known issue which will
+    be fixed in a future release of TQt.
+
+    \section1 Notes for Mac OS X Applications
+
+    The location where settings are stored is not formally defined by
+    the CFPreferences API.
+
+    At the time of writing settings are stored (either on a global or
+    user basis, preferring locally) into a plist file in \c
+    $ROOT/System/Library/Preferences (in XML format). TQSettings will
+    create an appropriate plist file (\c{com.<first group name>.plist})
+    out of the full path to a key.
+
+    For further information on CFPreferences see
+    \link http://developer.apple.com/documentation/CoreFoundation/Conceptual/CFPreferences/index.html
+    Apple's Specifications\endlink
+
+    \section1 Notes for Unix Applications
+
+    There is no universally accepted place for storing application
+    settings under Unix. In the examples the settings file will be
+    searched for in the following directories:
+    \list 1
+    \i \c SYSCONF - the default value is \c INSTALL/etc/settings
+    \i \c /opt/MyCompany/share/etc
+    \i \c /opt/MyCompany/share/MyApplication/etc
+    \i \c $HOME/.qt
+    \endlist
+    When reading settings the files are searched in the order shown
+    above, with later settings overriding earlier settings. Files for
+    which the user doesn't have read permission are ignored. When saving
+    settings TQSettings works in the order shown above, writing
+    to the first settings file for which the user has write permission.
+    (\c INSTALL is the directory where TQt was installed.  This can be
+    modified by using the configure script's -prefix argument )
+
+    If you want to put the settings in a particular place in the
+    filesystem you could do this:
+    \code
+    settings.insertSearchPath( TQSettings::Unix, "/opt/MyCompany/share" );
+    \endcode
+
+    But in practice you may prefer not to use a search path for Unix.
+    For example the following code:
+    \code
+    settings.writeEntry( "/MyApplication/tqgeometry/width", width );
+    \endcode
+    will end up writing the "tqgeometry/width" setting to the file
+    \c{$HOME/.qt/myapplicationrc} (assuming that the application is
+    being run by an ordinary user, i.e. not by root).
+
+    For cross-platform applications you should ensure that the
+    \link #sizelimit Windows size limitations \endlink are not exceeded.
+
+    \warning TQSettings doesn't write the settings until it is destroyed so
+    you should construct the TQSettings object on the stack.
+*/
+
+/*!
+    \enum TQSettings::System
+
+    \value Mac Macintosh execution environments
+    \value Unix Mac OS X, Unix, Linux and Unix-like execution environments
+    \value Windows Windows execution environments
+*/
+
+/*!
+    \enum TQSettings::Format
+
+    \value Native Store the settings in a platform dependent location
+    \value Ini Store the settings in a text file
+*/
+
+/*!
+    \enum TQSettings::Scope
+
+    \value Global Save settings as global as possible
+    \value User Save settings in user space
+*/
+
+#if defined(TQ_OS_UNIX)
+typedef int HANDLE;
+#define TQ_LOCKREAD F_RDLCK
+#define TQ_LOCKWRITE F_WRLCK
+/*
+  Locks the file specified by name.  The lockfile is created as a
+  hidden file in the same directory as the target file, with .lock
+  appended to the name. For example, "/etc/settings/onerc" uses a
+  lockfile named "/etc/settings/.onerc.lock".  The type argument
+  controls the type of the lock, it can be either F_RDLCK for a read
+  lock, or F_WRLCK for a write lock.
+
+  A file descriptor for the lock file is returned, and should be
+  closed with closelock() when the lock is no longer needed.
+ */
+static HANDLE openlock( const TQString &name, int type )
+{
+    TQFileInfo info( name );
+    // lockfile should be hidden, and never removed
+    TQString lockfile = info.dirPath() + "/." + info.fileName() + ".lock";
+
+    // open the lockfile
+    HANDLE fd = qt_open( TQFile::encodeName( lockfile ),
+			 O_RDWR | O_CREAT, S_IRUSR | S_IWUSR );
+
+    if ( fd < 0 ) {
+ 	// failed to open the lock file, most likely because of permissions
+	return fd;
+    }
+
+    struct flock fl;
+    fl.l_type = type;
+    fl.l_whence = SEEK_SET;
+    fl.l_start = 0;
+    fl.l_len = 0;
+    if ( fcntl( fd, F_SETLKW, &fl ) == -1 ) {
+	// the lock failed, so we should fail silently, so that people
+	// using filesystems that do not support locking don't see
+	// numerous warnings about a failed lock
+	close( fd );
+	fd = -1;
+    }
+
+    return fd;
+}
+
+/*
+  Closes the lock file specified by fd.  fd is the file descriptor
+  returned by the openlock() function.
+*/
+static void closelock( HANDLE fd )
+{
+    if ( fd < 0 ) {
+	// the lock file is not open
+	return;
+    }
+
+    struct flock fl;
+    fl.l_type = F_UNLCK;
+    fl.l_whence = SEEK_SET;
+    fl.l_start = 0;
+    fl.l_len = 0;
+    // ignore the return value, so that the unlock fails silently
+    (void) fcntl( fd, F_SETLKW, &fl );
+
+    close( fd );
+}
+#endif
+
+
+TQSettingsGroup::TQSettingsGroup()
+    : modified(FALSE)
+{
+}
+
+
+
+
+void TQSettingsHeading::read(const TQString &filename)
+{
+    if (! TQFileInfo(filename).exists())
+	return;
+
+#ifndef TQ_WS_WIN
+    HANDLE lockfd = openlock( filename, TQ_LOCKREAD );
+#endif
+
+    TQFile file(filename);
+    if (! file.open(IO_ReadOnly)) {
+#if defined(TQT_CHECK_STATE)
+	qWarning("TQSettings: failed to open file '%s'", filename.latin1());
+#endif
+	return;
+    }
+
+    git = end();
+
+    TQTextStream stream(&file);
+    stream.setEncoding(TQTextStream::UnicodeUTF8);
+    while (! stream.atEnd())
+	parseLine(stream);
+
+    git = end();
+
+    file.close();
+
+#ifndef TQ_WS_WIN
+    closelock( lockfd );
+#endif
+}
+
+
+void TQSettingsHeading::parseLine(TQTextStream &stream)
+{
+    TQString line = stream.readLine();
+    if (line.isEmpty())
+	// empty line... we'll allow it
+	return;
+
+    if (line[0] == TQChar('#'))
+	// commented line
+	return;
+
+    if (line[0] == TQChar('[')) {
+	TQString gname = line;
+
+	gname = gname.remove((uint)0, 1);
+	if (gname[(int)gname.length() - 1] == TQChar(']'))
+	    gname = gname.remove(gname.length() - 1, 1);
+
+	git = tqfind(gname);
+	if (git == end())
+	    git = tqreplace(gname, TQSettingsGroup());
+    } else {
+	if (git == end()) {
+#if defined(TQT_CHECK_STATE)
+	    qWarning("TQSettings: line '%s' out of group", line.latin1());
+#endif
+	    return;
+	}
+
+	int i = line.tqfind('=');
+       	if (i == -1) {
+#if defined(TQT_CHECK_STATE)
+	    qWarning("TQSettings: malformed line '%s' in group '%s'",
+		     line.latin1(), git.key().latin1());
+#endif
+	    return;
+	} else {
+	    TQString key, value;
+	    key = line.left(i);
+	    value = "";
+	    bool esc=TRUE;
+	    i++;
+	    while (esc) {
+		esc = FALSE;
+		for ( ; i < (int)line.length(); i++ ) {
+		    if ( esc ) {
+			if ( line[i] == 'n' )
+			    value.append('\n'); // escaped newline
+			else if ( line[i] == '0' )
+			    value = TQString::null; // escaped empty string
+			else
+			    value.append(line[i]);
+			esc = FALSE;
+		    } else if ( line[i] == '\\' )
+			esc = TRUE;
+		    else
+			value.append(line[i]);
+		}
+		if ( esc ) {
+		    // Backwards-compatiblity...
+		    // still escaped at EOL - manually escaped "newline"
+		    if (stream.atEnd()) {
+#if defined(TQT_CHECK_STATE)
+			qWarning("TQSettings: reached end of file, expected continued line");
+#endif
+			break;
+		    }
+		    value.append('\n');
+		    line = stream.readLine();
+		    i = 0;
+		}
+	    }
+
+	    (*git).insert(key, value);
+	}
+    }
+}
+
+#ifdef TQ_WS_WIN // for homedirpath reading from registry
+#include "tqt_windows.h"
+#include "tqlibrary.h"
+
+#ifndef CSIDL_APPDATA
+#define CSIDL_APPDATA                   0x001a        // <user name>\Application Data
+#endif
+#ifndef CSIDL_COMMON_APPDATA
+#define CSIDL_COMMON_APPDATA            0x0023        // All Users\Application Data
+#endif
+
+#endif
+
+TQSettingsPrivate::TQSettingsPrivate( TQSettings::Format format )
+    : groupDirty( TRUE ), modified(FALSE), globalScope(TRUE)
+{
+#if !defined(TQWS) && (defined(TQ_WS_WIN) || defined(TQ_OS_MAC))
+    if ( format != TQSettings::Ini )
+	return;
+#else
+    TQ_UNUSED( format );
+#endif
+
+    TQString appSettings(TQDir::homeDirPath() + "/.qt/");
+    TQString defPath;
+#ifdef TQ_WS_WIN
+#ifdef TQ_OS_TEMP
+	TCHAR path[MAX_PATH];
+	SHGetSpecialFolderPath( 0, path, CSIDL_APPDATA, FALSE );
+	appSettings  = TQString::fromUcs2( path );
+	SHGetSpecialFolderPath( 0, path, CSIDL_COMMON_APPDATA, FALSE );
+	defPath = TQString::fromUcs2( path );
+#else
+    TQLibrary library( "shell32" );
+    library.setAutoUnload( FALSE );
+    TQT_WA( {
+	typedef BOOL (WINAPI*GetSpecialFolderPath)(HWND, LPTSTR, int, BOOL);
+	GetSpecialFolderPath SHGetSpecialFolderPath = (GetSpecialFolderPath)library.resolve( "SHGetSpecialFolderPathW" );
+	if ( SHGetSpecialFolderPath ) {
+	    TCHAR path[MAX_PATH];
+	    SHGetSpecialFolderPath( 0, path, CSIDL_APPDATA, FALSE );
+	    appSettings  = TQString::fromUcs2( (ushort*)path );
+	    SHGetSpecialFolderPath( 0, path, CSIDL_COMMON_APPDATA, FALSE );
+	    defPath = TQString::fromUcs2( (ushort*)path );
+	}
+    } , {
+	typedef BOOL (WINAPI*GetSpecialFolderPath)(HWND, char*, int, BOOL);
+	GetSpecialFolderPath SHGetSpecialFolderPath = (GetSpecialFolderPath)library.resolve( "SHGetSpecialFolderPathA" );
+	if ( SHGetSpecialFolderPath ) {
+	    char path[MAX_PATH];
+	    SHGetSpecialFolderPath( 0, path, CSIDL_APPDATA, FALSE );
+	    appSettings = TQString::fromLocal8Bit( path );
+	    SHGetSpecialFolderPath( 0, path, CSIDL_COMMON_APPDATA, FALSE );
+	    defPath = TQString::fromLocal8Bit( path );
+	}
+    } );
+#endif // TQ_OS_TEMP
+#else
+    defPath = qInstallPathSysconf();
+#endif
+    TQDir dir(appSettings);
+    if (! dir.exists()) {
+	if (! dir.mkdir(dir.path()))
+#if defined(TQT_CHECK_STATE)
+	    qWarning("TQSettings: error creating %s", dir.path().latin1());
+#else
+	    ;
+#endif
+    }
+
+    if ( !!defPath )
+	searchPaths.append(defPath);
+    searchPaths.append(dir.path());
+}
+
+TQSettingsPrivate::~TQSettingsPrivate()
+{
+}
+
+TQSettingsGroup TQSettingsPrivate::readGroup()
+{
+    TQSettingsHeading hd;
+    TQSettingsGroup grp;
+
+    TQMap<TQString,TQSettingsHeading>::Iterator headingsit = headings.tqfind(heading);
+    if (headingsit != headings.end())
+	hd = *headingsit;
+
+    TQSettingsHeading::Iterator grpit = hd.tqfind(group);
+    if (grpit == hd.end()) {
+	TQStringList::Iterator it = searchPaths.begin();
+	if ( !globalScope )
+	    ++it;
+	while (it != searchPaths.end()) {
+            TQString filebase = heading.lower().tqreplace(TQRegExp(TQString::tqfromLatin1("\\s+")), "_");
+	    TQString fn((*it++) + "/" + filebase + "rc");
+	    if (! hd.tqcontains(fn + "cached")) {
+		hd.read(fn);
+		hd.insert(fn + "cached", TQSettingsGroup());
+	    }
+	}
+
+	headings.tqreplace(heading, hd);
+
+	grpit = hd.tqfind(group);
+	if (grpit != hd.end())
+	    grp = *grpit;
+    } else if (hd.count() != 0)
+	grp = *grpit;
+
+    return grp;
+}
+
+
+void TQSettingsPrivate::removeGroup(const TQString &key)
+{
+    TQSettingsHeading hd;
+    TQSettingsGroup grp;
+    bool found = FALSE;
+
+    TQMap<TQString,TQSettingsHeading>::Iterator headingsit = headings.tqfind(heading);
+    if (headingsit != headings.end())
+	hd = *headingsit;
+
+    TQSettingsHeading::Iterator grpit = hd.tqfind(group);
+    if (grpit == hd.end()) {
+	TQStringList::Iterator it = searchPaths.begin();
+	if ( !globalScope )
+	    ++it;
+	while (it != searchPaths.end()) {
+            TQString filebase = heading.lower().tqreplace(TQRegExp(TQString::tqfromLatin1("\\s+")), "_");
+	    TQString fn((*it++) + "/" + filebase + "rc");
+	    if (! hd.tqcontains(fn + "cached")) {
+		hd.read(fn);
+		hd.insert(fn + "cached", TQSettingsGroup());
+	    }
+	}
+
+	headings.tqreplace(heading, hd);
+
+	grpit = hd.tqfind(group);
+	if (grpit != hd.end()) {
+	    found = TRUE;
+	    grp = *grpit;
+	}
+    } else if (hd.count() != 0) {
+	found = TRUE;
+	grp = *grpit;
+    }
+
+    if (found) {
+	grp.remove(key);
+
+	if (grp.count() > 0)
+	    hd.tqreplace(group, grp);
+	else
+	    hd.remove(group);
+
+	if (hd.count() > 0)
+	    headings.tqreplace(heading, hd);
+	else
+	    headings.remove(heading);
+
+	modified = TRUE;
+    }
+}
+
+
+void TQSettingsPrivate::writeGroup(const TQString &key, const TQString &value)
+{
+    TQSettingsHeading hd;
+    TQSettingsGroup grp;
+
+    TQMap<TQString,TQSettingsHeading>::Iterator headingsit = headings.tqfind(heading);
+    if (headingsit != headings.end())
+	hd = *headingsit;
+
+    TQSettingsHeading::Iterator grpit = hd.tqfind(group);
+    if (grpit == hd.end()) {
+	TQStringList::Iterator it = searchPaths.begin();
+	if ( !globalScope )
+	    ++it;
+	while (it != searchPaths.end()) {
+            TQString filebase = heading.lower().tqreplace(TQRegExp(TQString::tqfromLatin1("\\s+")), "_");
+	    TQString fn((*it++) + "/" + filebase + "rc");
+	    if (! hd.tqcontains(fn + "cached")) {
+		hd.read(fn);
+		hd.insert(fn + "cached", TQSettingsGroup());
+	    }
+	}
+
+	headings.tqreplace(heading, hd);
+
+	grpit = hd.tqfind(group);
+	if (grpit != hd.end())
+	    grp = *grpit;
+    } else if (hd.count() != 0)
+	grp = *grpit;
+
+    grp.modified = TRUE;
+    grp.tqreplace(key, value);
+    hd.tqreplace(group, grp);
+    headings.tqreplace(heading, hd);
+
+    modified = TRUE;
+}
+
+
+TQDateTime TQSettingsPrivate::modificationTime()
+{
+    TQSettingsHeading hd = headings[heading];
+    TQSettingsGroup grp = hd[group];
+
+    TQDateTime datetime;
+
+    TQStringList::Iterator it = searchPaths.begin();
+    if ( !globalScope )
+	++it;
+    while (it != searchPaths.end()) {
+	TQFileInfo fi((*it++) + "/" + heading + "rc");
+	if (fi.exists() && fi.lastModified() > datetime)
+	    datetime = fi.lastModified();
+    }
+
+    return datetime;
+}
+
+bool qt_verify_key( const TQString &key )
+{
+    if ( key.isEmpty() || key[0] != '/' || key.tqcontains( TQRegExp(TQString::tqfromLatin1("[=\\r\\n]")) ) )
+	return FALSE;
+    return TRUE;
+}
+
+static TQString groupKey( const TQString &group, const TQString &key )
+{
+    TQString grp_key;
+    if ( group.isEmpty() || ( group.length() == 1 && group[0] == '/' ) ) {
+	// group is empty, or it tqcontains a single '/', so we just return the key
+	if ( key.startsWith( "/" ) )
+	    grp_key = key;
+	else
+	    grp_key = "/" + key;
+    } else if ( group.endsWith( "/" ) || key.startsWith( "/" ) ) {
+	grp_key = group + key;
+    } else {
+	grp_key = group + "/" + key;
+    }
+    return grp_key;
+}
+
+/*!
+  Inserts \a path into the settings search path. The semantics of \a
+  path depends on the system \a s. It is usually easier and better to
+  use setPath() instead of this function.
+
+  When \a s is \e Windows and the execution environment is \e not
+  Windows the function does nothing. Similarly when \a s is \e Unix and
+  the execution environment is \e not Unix the function does nothing.
+
+  When \a s is \e Windows, and the execution environment is Windows, the
+  search path list will be used as the first subfolder of the "Software"
+  folder in the registry.
+
+  When reading settings the folders are searched forwards from the
+  first folder (listed below) to the last, returning the first
+  settings found, and ignoring any folders for which the user doesn't
+  have read permission.
+  \list 1
+  \i HKEY_CURRENT_USER/Software/MyCompany/MyApplication
+  \i HKEY_LOCAL_MACHINE/Software/MyCompany/MyApplication
+  \i HKEY_CURRENT_USER/Software/MyApplication
+  \i HKEY_LOCAL_MACHINE/Software/MyApplication
+  \endlist
+
+  \code
+  TQSettings settings;
+  settings.insertSearchPath( TQSettings::Windows, "/MyCompany" );
+  settings.writeEntry( "/MyApplication/Tip of the day", TRUE );
+  \endcode
+  The code above will write the subkey "Tip of the day" into the \e
+  first of the registry folders listed below that is found and for
+  which the user has write permission.
+  \list 1
+  \i HKEY_LOCAL_MACHINE/Software/MyCompany/MyApplication
+  \i HKEY_CURRENT_USER/Software/MyCompany/MyApplication
+  \i HKEY_LOCAL_MACHINE/Software/MyApplication
+  \i HKEY_CURRENT_USER/Software/MyApplication
+  \endlist
+  If a setting is found in the HKEY_CURRENT_USER space, this setting
+  is overwritten independently of write permissions in the
+  HKEY_LOCAL_MACHINE space.
+
+  When \a s is \e Unix, and the execution environment is Unix, the
+  search path list will be used when trying to determine a suitable
+  filename for reading and writing settings files. By default, there are
+  two entries in the search path:
+
+  \list 1
+  \i \c SYSCONF - where \c SYSCONF is a directory specified when
+  configuring TQt; by default it is INSTALL/etc/settings.
+  \i \c $HOME/.qt/ - where \c $HOME is the user's home directory.
+  \endlist
+
+  All insertions into the search path will go before $HOME/.qt/.
+  For example:
+  \code
+  TQSettings settings;
+  settings.insertSearchPath( TQSettings::Unix, "/opt/MyCompany/share/etc" );
+  settings.insertSearchPath( TQSettings::Unix, "/opt/MyCompany/share/MyApplication/etc" );
+  // ...
+  \endcode
+  Will result in a search path of:
+  \list 1
+  \i SYSCONF
+  \i /opt/MyCompany/share/etc
+  \i /opt/MyCompany/share/MyApplication/etc
+  \i $HOME/.qt
+  \endlist
+    When reading settings the files are searched in the order shown
+    above, with later settings overriding earlier settings. Files for
+    which the user doesn't have read permission are ignored. When saving
+    settings TQSettings works in the order shown above, writing
+    to the first settings file for which the user has write permission.
+
+    Note that paths in the file system are not created by this
+    function, so they must already exist to be useful.
+
+  Settings under Unix are stored in files whose names are based on the
+  first subkey of the key (not including the search path). The algorithm
+  for creating names is essentially: lowercase the first subkey, tqreplace
+  spaces with underscores and add 'rc', e.g.
+  <tt>/MyCompany/MyApplication/background color</tt> will be stored in
+  <tt>myapplicationrc</tt> (assuming that <tt>/MyCompany</tt> is part of
+  the search path).
+
+  \sa removeSearchPath()
+
+*/
+void TQSettings::insertSearchPath( System s, const TQString &path)
+{
+#if !defined(TQWS) && (defined(TQ_WS_WIN) || defined(TQ_OS_MAC))
+    if ( d->sysd ) {
+	d->sysInsertSearchPath( s, path );
+	return;
+    }
+#endif
+
+#if !defined(TQ_WS_WIN)
+    if ( s == Windows )
+	return;
+#endif
+#if !defined(TQ_OS_MAC)
+    if ( s == Mac )
+	return;
+#endif
+
+    if ( !qt_verify_key( path ) ) {
+#if defined(TQT_CHECK_STATE)
+	qWarning( "TQSettings::insertSearchPath: Invalid key: '%s'", path.isNull() ? "(null)" : path.latin1() );
+#endif
+	return;
+    }
+
+#if !defined(TQWS) && (defined(TQ_WS_WIN) || defined(TQ_OS_MAC))
+    if ( d->sysd && s != Unix ) {
+#else
+    if ( s != Unix ) {
+#endif
+#if !defined(TQWS) && defined(TQ_OS_MAC)
+	if(s != Mac) //mac is respected on the mac as well
+#endif
+	    return;
+    }
+
+    TQString realPath = path;
+#if defined(TQ_WS_WIN)
+    TQString defPath = d->globalScope ? d->searchPaths.first() : d->searchPaths.last();
+    realPath = defPath + path;
+#endif
+
+    TQStringList::Iterator it = d->searchPaths.tqfind(d->searchPaths.last());
+    if (it != d->searchPaths.end()) {
+	d->searchPaths.insert(it, realPath);
+    }
+}
+
+
+/*!
+  Removes all occurrences of \a path (using exact matching) from the
+  settings search path for system \a s. Note that the default search
+  paths cannot be removed.
+
+  \sa insertSearchPath()
+*/
+void TQSettings::removeSearchPath( System s, const TQString &path)
+{
+    if ( !qt_verify_key( path ) ) {
+#if defined(TQT_CHECK_STATE)
+	qWarning( "TQSettings::insertSearchPath: Invalid key: '%s'", path.isNull() ? "(null)" : path.latin1() );
+#endif
+	return;
+    }
+
+#ifdef TQ_WS_WIN
+    if ( d->sysd ) {
+	d->sysRemoveSearchPath( s, path );
+	return;
+    }
+#endif
+#if !defined(TQWS) && (defined(TQ_WS_WIN) || defined(TQ_OS_MAC))
+    if ( d->sysd && s != Unix ) {
+#else
+    if ( s != Unix ) {
+#endif
+#if !defined(TQWS) && defined(TQ_OS_MAC)
+	if(s != Mac) //mac is respected on the mac as well
+#endif
+	    return;
+    }
+
+    if (path == d->searchPaths.first() || path == d->searchPaths.last())
+	return;
+
+    d->searchPaths.remove(path);
+}
+
+
+/*!
+  Creates a settings object.
+
+  Be aware that you must call setPath() or insertSearchPath() before
+  you can use the TQSettings object.
+*/
+TQSettings::TQSettings()
+{
+    d = new TQSettingsPrivate( Native );
+    TQ_CHECK_PTR(d);
+
+#if !defined(TQWS) && (defined(TQ_WS_WIN) || defined(TQ_OS_MAC))
+    d->sysd = 0;
+    d->sysInit();
+#endif
+}
+
+/*!
+  Creates a settings object. If \a format is 'Ini' the settings will
+  be stored in a text file, using the Unix strategy (see above). If \a format
+  is 'Native', the settings will be stored in a platform specific way
+  (ie. the Windows registry).
+
+  Be aware that you must call setPath() or insertSearchPath() before
+  you can use the TQSettings object.
+*/
+TQSettings::TQSettings( Format format )
+{
+    d = new TQSettingsPrivate( format );
+    TQ_CHECK_PTR(d);
+
+#if !defined(TQWS) && (defined(TQ_WS_WIN) || defined(TQ_OS_MAC))
+    d->sysd = 0;
+    if ( format == Native )
+	d->sysInit();
+#else
+    TQ_UNUSED(format);
+#endif
+}
+
+/*!
+  Destroys the settings object.  All modifications made to the settings
+  will automatically be saved.
+
+*/
+TQSettings::~TQSettings()
+{
+    sync();
+
+#if !defined(TQWS) && (defined(TQ_WS_WIN) || defined(TQ_OS_MAC))
+    if ( d->sysd )
+	d->sysClear();
+#endif
+
+    delete d;
+}
+
+
+/*! \internal
+  Writes all modifications to the settings to disk.  If any errors are
+  encountered, this function returns FALSE, otherwise it will return TRUE.
+*/
+bool TQSettings::sync()
+{
+#if !defined(TQWS) && (defined(TQ_WS_WIN) || defined(TQ_OS_MAC))
+    if ( d->sysd )
+	return d->sysSync();
+#endif
+    if (! d->modified)
+	// fake success
+	return TRUE;
+
+    bool success = TRUE;
+    TQMap<TQString,TQSettingsHeading>::Iterator it = d->headings.begin();
+
+    while (it != d->headings.end()) {
+	// determine filename
+	TQSettingsHeading hd(*it);
+	TQSettingsHeading::Iterator hdit = hd.begin();
+	TQString filename;
+
+	TQStringList::Iterator pit = d->searchPaths.begin();
+	if ( !d->globalScope )
+	    ++pit;
+	while (pit != d->searchPaths.end()) {
+            TQString filebase = it.key().lower().tqreplace(TQRegExp(TQString::tqfromLatin1("\\s+")), "_");
+	    TQFileInfo di(*pit);
+	    if ( !di.exists() ) {
+		TQDir dir;
+		dir.mkdir( *pit );
+	    }
+
+	    TQFileInfo fi((*pit++) + "/" + filebase + "rc");
+
+	    if ((fi.exists() && fi.isFile() && fi.isWritable()) ||
+		(! fi.exists() && di.isDir()
+#ifndef TQ_WS_WIN
+		&& di.isWritable()
+#else
+		&& ((qWinVersion()&TQt::WV_NT_based) > TQt::WV_2000 || di.isWritable())
+#endif
+		)) {
+		filename = fi.filePath();
+		break;
+	    }
+	}
+
+	++it;
+
+	if ( filename.isEmpty() ) {
+
+#ifdef TQT_CHECK_STATE
+	    qWarning("TQSettings::sync: filename is null/empty");
+#endif // TQT_CHECK_STATE
+
+	    success = FALSE;
+	    continue;
+	}
+
+#ifndef TQ_WS_WIN
+	HANDLE lockfd = openlock( filename, TQ_LOCKWRITE );
+#endif
+
+	TQFile file( filename + ".tmp" );
+	if (! file.open(IO_WriteOnly)) {
+
+#ifdef TQT_CHECK_STATE
+	    qWarning("TQSettings::sync: failed to open '%s' for writing",
+		     file.name().latin1());
+#endif // TQT_CHECK_STATE
+
+	    success = FALSE;
+	    continue;
+	}
+
+	// spew to file
+	TQTextStream stream(&file);
+	stream.setEncoding(TQTextStream::UnicodeUTF8);
+
+	while (hdit != hd.end()) {
+	    if ((*hdit).count() > 0) {
+		stream << "[" << hdit.key() << "]" << endl;
+
+		TQSettingsGroup grp(*hdit);
+		TQSettingsGroup::Iterator grpit = grp.begin();
+
+		while (grpit != grp.end()) {
+		    TQString v = grpit.data();
+		    if ( v.isNull() ) {
+                        v = TQString::tqfromLatin1("\\0"); // escape null string
+		    } else {
+                        v.tqreplace('\\', TQString::tqfromLatin1("\\\\")); // escape backslash
+                        v.tqreplace('\n', TQString::tqfromLatin1("\\n")); // escape newlines
+		    }
+
+		    stream << grpit.key() << "=" << v << endl;
+		    ++grpit;
+		}
+
+		stream << endl;
+	    }
+
+	    ++hdit;
+	}
+
+	if (file.status() != IO_Ok) {
+
+#ifdef TQT_CHECK_STATE
+	    qWarning("TQSettings::sync: error at end of write");
+#endif // TQT_CHECK_STATE
+
+	    success = FALSE;
+	}
+
+	file.close();
+
+	if ( success ) {
+	    TQDir dir( TQFileInfo( file ).dir( TRUE ) );
+	    if ( dir.exists( filename ) && !dir.remove( filename ) ||
+		 !dir.rename( file.name(), filename, TRUE ) ) {
+
+#ifdef TQT_CHECK_STATE
+		qWarning( "TQSettings::sync: error writing file '%s'",
+			  TQFile::encodeName( filename ).data() );
+#endif // TQT_CHECK_STATE
+
+		success = FALSE;
+	    }
+	}
+
+	// remove temporary file
+	file.remove();
+
+#ifndef TQ_WS_WIN
+	closelock( lockfd );
+#endif
+    }
+
+    d->modified = FALSE;
+
+    return success;
+}
+
+
+/*!
+  \fn bool TQSettings::readBoolEntry(const TQString &key, bool def, bool *ok ) const
+
+  Reads the entry specified by \a key, and returns a bool, or the
+  default value, \a def, if the entry couldn't be read.
+  If \a ok is non-null, *ok is set to TRUE if the key was read, FALSE
+  otherwise.
+
+  \sa readEntry(), readNumEntry(), readDoubleEntry(), writeEntry(), removeEntry()
+*/
+
+/*!
+    \internal
+*/
+bool TQSettings::readBoolEntry(const TQString &key, bool def, bool *ok )
+{
+    TQString grp_key( groupKey( group(), key ) );
+    if ( !qt_verify_key( grp_key ) ) {
+#if defined(TQT_CHECK_STATE)
+	qWarning( "TQSettings::readBoolEntry: Invalid key: '%s'", grp_key.isNull() ? "(null)" : grp_key.latin1() );
+#endif
+    	if ( ok )
+	    *ok = FALSE;
+
+	return def;
+    }
+
+#if !defined(TQWS) && (defined(TQ_WS_WIN) || defined(TQ_OS_MAC))
+    if ( d->sysd )
+	return d->sysReadBoolEntry( grp_key, def, ok );
+#endif
+
+    TQString value = readEntry( key, ( def ? "true" : "false" ), ok );
+
+    if (value.lower() == "true")
+	return TRUE;
+    else if (value.lower() == "false")
+	return FALSE;
+    else if (value == "1")
+	return TRUE;
+    else if (value == "0")
+	return FALSE;
+
+    if (! value.isEmpty())
+	qWarning("TQSettings::readBoolEntry: '%s' is not 'true' or 'false'",
+		 value.latin1());
+    if ( ok )
+	*ok = FALSE;
+    return def;
+}
+
+
+/*!
+    \fn double TQSettings::readDoubleEntry(const TQString &key, double def, bool *ok ) const
+
+  Reads the entry specified by \a key, and returns a double, or the
+  default value, \a def, if the entry couldn't be read.
+  If \a ok is non-null, *ok is set to TRUE if the key was read, FALSE
+  otherwise.
+
+  \sa readEntry(), readNumEntry(), readBoolEntry(), writeEntry(), removeEntry()
+*/
+
+/*!
+    \internal
+*/
+double TQSettings::readDoubleEntry(const TQString &key, double def, bool *ok )
+{
+    TQString grp_key( groupKey( group(), key ) );
+    if ( !qt_verify_key( grp_key ) ) {
+#if defined(TQT_CHECK_STATE)
+	qWarning( "TQSettings::readDoubleEntry: Invalid key: '%s'", grp_key.isNull() ? "(null)" : grp_key.latin1() );
+#endif
+    	if ( ok )
+	    *ok = FALSE;
+
+	return def;
+    }
+
+#if !defined(TQWS) && (defined(TQ_WS_WIN) || defined(TQ_OS_MAC))
+    if ( d->sysd )
+	return d->sysReadDoubleEntry( grp_key, def, ok );
+#endif
+
+    TQString value = readEntry( key, TQString::number(def), ok );
+    bool conv_ok;
+    double retval = value.toDouble( &conv_ok );
+    if ( conv_ok )
+	return retval;
+    if ( ! value.isEmpty() )
+	qWarning( "TQSettings::readDoubleEntry: '%s' is not a number",
+		  value.latin1() );
+    if ( ok )
+	*ok = FALSE;
+    return def;
+}
+
+
+/*!
+    \fn int TQSettings::readNumEntry(const TQString &key, int def, bool *ok ) const
+
+  Reads the entry specified by \a key, and returns an integer, or the
+  default value, \a def, if the entry couldn't be read.
+  If \a ok is non-null, *ok is set to TRUE if the key was read, FALSE
+  otherwise.
+
+  \sa readEntry(), readDoubleEntry(), readBoolEntry(), writeEntry(), removeEntry()
+*/
+
+/*!
+    \internal
+*/
+int TQSettings::readNumEntry(const TQString &key, int def, bool *ok )
+{
+    TQString grp_key( groupKey( group(), key ) );
+    if ( !qt_verify_key( grp_key ) ) {
+#if defined(TQT_CHECK_STATE)
+	qWarning( "TQSettings::readNumEntry: Invalid key: '%s'", grp_key.isNull() ? "(null)" : grp_key.latin1() );
+#endif
+	if ( ok )
+	    *ok = FALSE;
+	return def;
+    }
+
+#if !defined(TQWS) && (defined(TQ_WS_WIN) || defined(TQ_OS_MAC))
+    if ( d->sysd )
+	return d->sysReadNumEntry( grp_key, def, ok );
+#endif
+
+    TQString value = readEntry( key, TQString::number( def ), ok );
+    bool conv_ok;
+    int retval = value.toInt( &conv_ok );
+    if ( conv_ok )
+	return retval;
+    if ( ! value.isEmpty() )
+	qWarning( "TQSettings::readNumEntry: '%s' is not a number",
+		  value.latin1() );
+    if ( ok )
+	*ok = FALSE;
+    return def;
+}
+
+
+/*!
+    \fn TQString TQSettings::readEntry(const TQString &key, const TQString &def, bool *ok ) const
+
+  Reads the entry specified by \a key, and returns a TQString, or the
+  default value, \a def, if the entry couldn't be read.
+  If \a ok is non-null, *ok is set to TRUE if the key was read, FALSE
+  otherwise.
+
+  \sa readListEntry(), readNumEntry(), readDoubleEntry(), readBoolEntry(), writeEntry(), removeEntry()
+*/
+
+/*!
+    \internal
+*/
+TQString TQSettings::readEntry(const TQString &key, const TQString &def, bool *ok )
+{
+    TQString grp_key( groupKey( group(), key ) );
+    if ( !qt_verify_key( grp_key ) ) {
+#if defined(TQT_CHECK_STATE)
+	qWarning( "TQSettings::readEntry: Invalid key: '%s'", grp_key.isNull() ? "(null)" : grp_key.latin1() );
+#endif
+	if ( ok )
+	    *ok = FALSE;
+
+	return def;
+    }
+
+#if !defined(TQWS) && (defined(TQ_WS_WIN) || defined(TQ_OS_MAC))
+    if ( d->sysd )
+	return d->sysReadEntry( grp_key, def, ok );
+#endif
+
+    if ( ok ) // no, everything is not ok
+	*ok = FALSE;
+
+    TQString realkey;
+
+    if (grp_key[0] == '/') {
+	// parse our key
+	TQStringList list(TQStringList::split('/', grp_key));
+
+	if (list.count() < 2) {
+#ifdef TQT_CHECK_STATE
+	    qWarning("TQSettings::readEntry: invalid key '%s'", grp_key.latin1());
+#endif // TQT_CHECK_STATE
+	    if ( ok )
+		*ok = FALSE;
+	    return def;
+	}
+
+	if (list.count() == 2) {
+	    d->heading = list[0];
+	    d->group = "General";
+	    realkey = list[1];
+	} else {
+	    d->heading = list[0];
+	    d->group = list[1];
+
+	    // remove the group from the list
+	    list.remove(list.at(1));
+	    // remove the heading from the list
+	    list.remove(list.at(0));
+
+	    realkey = list.join("/");
+	}
+    } else {
+    	realkey = grp_key;
+    }
+
+    TQSettingsGroup grp = d->readGroup();
+    TQSettingsGroup::const_iterator it = grp.tqfind( realkey ), end = grp.end();
+    TQString retval = def;
+    if ( it != end ) {
+	// found the value we needed
+	retval = *it;
+	if ( ok ) *ok = TRUE;
+    }
+    return retval;
+}
+
+
+#if !defined(TQ_NO_BOOL_TYPE)
+/*!
+    Writes the boolean entry \a value into key \a key. The \a key is
+    created if it doesn't exist. Any previous value is overwritten by \a
+    value.
+
+    If an error occurs the settings are left unchanged and FALSE is
+    returned; otherwise TRUE is returned.
+
+    \warning On certain platforms, keys are required to contain at least
+    two components (e.g., "/foo/bar"). This limitation does not apply to
+    TQt 4.
+
+  \sa readListEntry(), readNumEntry(), readDoubleEntry(), readBoolEntry(), removeEntry()
+*/
+bool TQSettings::writeEntry(const TQString &key, bool value)
+{
+    TQString grp_key( groupKey( group(), key ) );
+    if ( !qt_verify_key( grp_key ) ) {
+#if defined(TQT_CHECK_STATE)
+	qWarning( "TQSettings::writeEntry: Invalid key: '%s'", grp_key.isNull() ? "(null)" : grp_key.latin1() );
+#endif
+	return FALSE;
+    }
+
+#if !defined(TQWS) && (defined(TQ_WS_WIN) || defined(TQ_OS_MAC))
+    if ( d->sysd )
+	return d->sysWriteEntry( grp_key, value );
+#endif
+    TQString s(value ? "true" : "false");
+    return writeEntry(key, s);
+}
+#endif
+
+
+/*!
+    \overload
+    Writes the double entry \a value into key \a key. The \a key is
+    created if it doesn't exist. Any previous value is overwritten by \a
+    value.
+
+    If an error occurs the settings are left unchanged and FALSE is
+    returned; otherwise TRUE is returned.
+
+  \sa readListEntry(), readNumEntry(), readDoubleEntry(), readBoolEntry(), removeEntry()
+*/
+bool TQSettings::writeEntry(const TQString &key, double value)
+{
+    TQString grp_key( groupKey( group(), key ) );
+    if ( !qt_verify_key( grp_key ) ) {
+#if defined(TQT_CHECK_STATE)
+	qWarning( "TQSettings::writeEntry: Invalid key: '%s'", grp_key.isNull() ? "(null)" : grp_key.latin1() );
+#endif
+	return FALSE;
+    }
+
+#if !defined(TQWS) && (defined(TQ_WS_WIN) || defined(TQ_OS_MAC))
+    if ( d->sysd )
+	return d->sysWriteEntry( grp_key, value );
+#endif
+    TQString s(TQString::number(value));
+    return writeEntry(key, s);
+}
+
+
+/*!
+    \overload
+    Writes the integer entry \a value into key \a key. The \a key is
+    created if it doesn't exist. Any previous value is overwritten by \a
+    value.
+
+    If an error occurs the settings are left unchanged and FALSE is
+    returned; otherwise TRUE is returned.
+
+  \sa readListEntry(), readNumEntry(), readDoubleEntry(), readBoolEntry(), removeEntry()
+*/
+bool TQSettings::writeEntry(const TQString &key, int value)
+{
+    TQString grp_key( groupKey( group(), key ) );
+    if ( !qt_verify_key( grp_key ) ) {
+#if defined(TQT_CHECK_STATE)
+	qWarning( "TQSettings::writeEntry: Invalid key: '%s'", grp_key.isNull() ? "(null)" : grp_key.latin1() );
+#endif
+	return FALSE;
+    }
+
+#if !defined(TQWS) && (defined(TQ_WS_WIN) || defined(TQ_OS_MAC))
+    if ( d->sysd )
+	return d->sysWriteEntry( grp_key, value );
+#endif
+    TQString s(TQString::number(value));
+    return writeEntry(key, s);
+}
+
+
+/*!
+    \internal
+
+  Writes the entry specified by \a key with the string-literal \a value,
+  replacing any previous setting.  If \a value is zero-length or null, the
+  entry is tqreplaced by an empty setting.
+
+  \e NOTE: This function is provided because some compilers use the
+  writeEntry (const TQString &, bool) overload for this code:
+  writeEntry ("/foo/bar", "baz")
+
+  If an error occurs, this functions returns FALSE and the object is left
+  unchanged.
+
+  \sa readEntry(), removeEntry()
+*/
+bool TQSettings::writeEntry(const TQString &key, const char *value)
+{
+    return writeEntry(key, TQString(value));
+}
+
+
+/*!
+    \overload
+    Writes the string entry \a value into key \a key. The \a key is
+    created if it doesn't exist. Any previous value is overwritten by \a
+    value. If \a value is an empty string or a null string the key's
+    value will be an empty string.
+
+    If an error occurs the settings are left unchanged and FALSE is
+    returned; otherwise TRUE is returned.
+
+  \sa readListEntry(), readNumEntry(), readDoubleEntry(), readBoolEntry(), removeEntry()
+*/
+bool TQSettings::writeEntry(const TQString &key, const TQString &value)
+{
+    TQString grp_key( groupKey( group(), key ) );
+    if ( !qt_verify_key( grp_key ) ) {
+#if defined(TQT_CHECK_STATE)
+	qWarning( "TQSettings::writeEntry: Invalid key: '%s'", grp_key.isNull() ? "(null)" : grp_key.latin1() );
+#endif
+	return FALSE;
+    }
+
+#if !defined(TQWS) && (defined(TQ_WS_WIN) || defined(TQ_OS_MAC))
+    if ( d->sysd )
+	return d->sysWriteEntry( grp_key, value );
+#endif
+    // NOTE: we *do* allow value to be a null/empty string
+
+    TQString realkey;
+
+    if (grp_key[0] == '/') {
+	// parse our key
+	TQStringList list(TQStringList::split('/', grp_key));
+
+	if (list.count() < 2) {
+#ifdef TQT_CHECK_STATE
+	    qWarning("TQSettings::writeEntry: invalid key '%s'", grp_key.latin1());
+#endif // TQT_CHECK_STATE
+
+	    return FALSE;
+	}
+
+	if (list.count() == 2) {
+	    d->heading = list[0];
+	    d->group = "General";
+	    realkey = list[1];
+	} else {
+	    d->heading = list[0];
+	    d->group = list[1];
+
+	    // remove the group from the list
+	    list.remove(list.at(1));
+	    // remove the heading from the list
+	    list.remove(list.at(0));
+
+	    realkey = list.join("/");
+	}
+    } else {
+	realkey = grp_key;
+    }
+
+    d->writeGroup(realkey, value);
+    return TRUE;
+}
+
+
+/*!
+    Removes the entry specified by \a key.
+
+    Returns true if the entry was successfully removed; otherwise
+    returns false. Note that removing the last entry in any given
+    folder, will also remove the folder.
+
+    \sa readEntry(), writeEntry()
+*/
+bool TQSettings::removeEntry(const TQString &key)
+{
+    TQString grp_key( groupKey( group(), key ) );
+    if ( !qt_verify_key( grp_key ) ) {
+#if defined(TQT_CHECK_STATE)
+	qWarning( "TQSettings::removeEntry: Invalid key: '%s'", grp_key.isNull() ? "(null)" : grp_key.latin1() );
+#endif
+	return FALSE;
+    }
+
+#if !defined(TQWS) && (defined(TQ_WS_WIN) || defined(TQ_OS_MAC))
+    if ( d->sysd )
+	return d->sysRemoveEntry( grp_key );
+#endif
+
+    TQString realkey;
+    if (grp_key[0] == '/') {
+	// parse our key
+	TQStringList list(TQStringList::split('/', grp_key));
+
+	if (list.count() < 2) {
+#ifdef TQT_CHECK_STATE
+	    qWarning("TQSettings::removeEntry: invalid key '%s'", grp_key.latin1());
+#endif // TQT_CHECK_STATE
+
+	    return FALSE;
+	}
+
+	if (list.count() == 2) {
+	    d->heading = list[0];
+	    d->group = "General";
+	    realkey = list[1];
+	} else {
+	    d->heading = list[0];
+	    d->group = list[1];
+
+	    // remove the group from the list
+	    list.remove(list.at(1));
+	    // remove the heading from the list
+	    list.remove(list.at(0));
+
+	    realkey = list.join("/");
+	}
+    } else {
+	realkey = grp_key;
+    }
+
+    d->removeGroup(realkey);
+    return TRUE;
+}
+
+
+/*!
+  Returns a list of the keys which contain entries under \a key. Does \e
+  not return any keys that contain subkeys.
+
+    Example settings:
+    \code
+    /MyCompany/MyApplication/background color
+    /MyCompany/MyApplication/foreground color
+    /MyCompany/MyApplication/tqgeometry/x
+    /MyCompany/MyApplication/tqgeometry/y
+    /MyCompany/MyApplication/tqgeometry/width
+    /MyCompany/MyApplication/tqgeometry/height
+    \endcode
+    \code
+    TQStringList keys = settings.entryList( "/MyCompany/MyApplication" );
+    \endcode
+
+    In the above example, \c keys will contain 'background color' and
+    'foreground color'. It will not contain 'tqgeometry' because this key
+    tqcontains subkeys not entries.
+
+    To access the tqgeometry values, you could either use subkeyList()
+    to read the keys then read each entry, or simply read each entry
+    directly by specifying its full key, e.g.
+    "/MyCompany/MyApplication/tqgeometry/y".
+
+  \sa subkeyList()
+*/
+TQStringList TQSettings::entryList(const TQString &key) const
+{
+    TQString grp_key( groupKey( group(), key ) );
+    if ( !qt_verify_key( grp_key ) ) {
+#if defined(TQT_CHECK_STATE)
+	qWarning( "TQSettings::entryList: Invalid key: %s", grp_key.isNull() ? "(null)" : grp_key.latin1() );
+#endif
+	return TQStringList();
+    }
+
+#if !defined(TQWS) && (defined(TQ_WS_WIN) || defined(TQ_OS_MAC))
+    if ( d->sysd )
+	return d->sysEntryList( grp_key );
+#endif
+
+    TQString realkey;
+    if (grp_key[0] == '/') {
+	// parse our key
+	TQStringList list(TQStringList::split('/', grp_key));
+
+	if (list.count() < 1) {
+#ifdef TQT_CHECK_STATE
+	    qWarning("TQSettings::listEntries: invalid key '%s'", grp_key.latin1());
+#endif // TQT_CHECK_STATE
+
+	    return TQStringList();
+	}
+
+	if (list.count() == 1) {
+	    d->heading = list[0];
+	    d->group = "General";
+	} else {
+	    d->heading = list[0];
+	    d->group = list[1];
+
+	    // remove the group from the list
+	    list.remove(list.at(1));
+	    // remove the heading from the list
+	    list.remove(list.at(0));
+
+	    realkey = list.join("/");
+	}
+    } else
+	realkey = grp_key;
+
+    TQSettingsGroup grp = d->readGroup();
+    TQSettingsGroup::Iterator it = grp.begin();
+    TQStringList ret;
+    TQString itkey;
+    while (it != grp.end()) {
+	itkey = it.key();
+	++it;
+
+	if ( realkey.length() > 0 ) {
+	    if ( itkey.left( realkey.length() ) != realkey )
+		continue;
+	    else
+		itkey.remove( 0, realkey.length() + 1 );
+	}
+
+	if ( itkey.tqfind( '/' ) != -1 )
+	    continue;
+
+	ret << itkey;
+    }
+
+    return ret;
+}
+
+
+/*!
+  Returns a list of the keys which contain subkeys under \a key. Does \e
+  not return any keys that contain entries.
+
+    Example settings:
+    \code
+    /MyCompany/MyApplication/background color
+    /MyCompany/MyApplication/foreground color
+    /MyCompany/MyApplication/tqgeometry/x
+    /MyCompany/MyApplication/tqgeometry/y
+    /MyCompany/MyApplication/tqgeometry/width
+    /MyCompany/MyApplication/tqgeometry/height
+    /MyCompany/MyApplication/recent files/1
+    /MyCompany/MyApplication/recent files/2
+    /MyCompany/MyApplication/recent files/3
+    \endcode
+    \code
+    TQStringList keys = settings.subkeyList( "/MyCompany/MyApplication" );
+    \endcode
+
+    In the above example, \c keys will contain 'tqgeometry' and
+    'recent files'. It will not contain 'background color' or
+    'foreground color' because those keys contain entries not
+    subkeys. To get a list of keys that contain entries rather than
+    subkeys use entryList() instead.
+
+    \warning In the above example, if TQSettings is writing to an Ini file,
+    then a call to
+    \code subkeyList("/MyCompany") \endcode
+    will return an empty list. This happens because a key like
+    \code /MyCompany/MyApplication/background color \endcode
+    is written to the file \e{"mycompanyrc"}, under the section \e{[MyApplication]}.
+    This call is therefore a request to list the sections in an ini file, which
+    is not supported in this version of TQSettings. This is a known issue which
+    will be fixed in TQt-4.
+
+  \sa entryList()
+*/
+TQStringList TQSettings::subkeyList(const TQString &key) const
+{
+    TQString grp_key( groupKey( group(), key ) );
+    if ( !qt_verify_key( grp_key ) ) {
+#if defined(TQT_CHECK_STATE)
+	qWarning( "TQSettings::subkeyList: Invalid key: %s", grp_key.isNull() ? "(null)" : grp_key.latin1() );
+#endif
+	return TQStringList();
+    }
+
+#if !defined(TQWS) && (defined(TQ_WS_WIN) || defined(TQ_OS_MAC))
+    if ( d->sysd )
+	return d->sysSubkeyList( grp_key );
+#endif
+
+    TQString realkey;
+    int subkeycount = 2;
+    if (grp_key[0] == '/') {
+	// parse our key
+	TQStringList list(TQStringList::split('/', grp_key));
+
+	if (list.count() < 1) {
+#ifdef TQT_CHECK_STATE
+	    qWarning("TQSettings::subkeyList: invalid key '%s'", grp_key.latin1());
+#endif // TQT_CHECK_STATE
+
+	    return TQStringList();
+	}
+
+	subkeycount = (int)list.count();
+
+	if (list.count() == 1) {
+	    d->heading = list[0];
+	    d->group = "General";
+	} else {
+	    d->heading = list[0];
+	    d->group = list[1];
+
+	    // remove the group from the list
+	    list.remove(list.at(1));
+	    // remove the heading from the list
+	    list.remove(list.at(0));
+
+	    realkey = list.join("/");
+	}
+
+    } else
+	realkey = grp_key;
+
+    TQStringList ret;
+    if ( subkeycount == 1 ) {
+	TQMap<TQString,TQSettingsHeading>::Iterator it = d->headings.begin();
+	while ( it != d->headings.end() ) {
+	    if ( it.key() != "General" && ! ret.tqcontains( it.key() ) )
+		ret << it.key();
+	    ++it;
+	}
+
+	return ret;
+    }
+
+    TQSettingsGroup grp = d->readGroup();
+    TQSettingsGroup::Iterator it = grp.begin();
+    TQString itkey;
+    while (it != grp.end()) {
+	itkey = it.key();
+	++it;
+
+	if ( realkey.length() > 0 ) {
+	    if ( itkey.left( realkey.length() ) != realkey
+            || itkey.length()+1 < realkey.length()
+            || itkey[(int)realkey.length()] != '/')
+		continue;
+	    else
+		itkey.remove( 0, realkey.length() + 1 );
+	}
+
+	int slash = itkey.tqfind( '/' );
+	if ( slash == -1 )
+	    continue;
+	itkey.truncate( slash );
+
+	if ( ! ret.tqcontains( itkey ) )
+	    ret << itkey;
+    }
+
+    return ret;
+}
+
+
+/*!
+    \internal
+
+  This function returns the time of last modification for \a key.
+*/
+TQDateTime TQSettings::lastModificationTime( const TQString &key )
+{
+    TQString grp_key( groupKey( group(), key ) );
+    if ( !qt_verify_key( grp_key ) ) {
+#if defined(TQT_CHECK_STATE)
+	qWarning( "TQSettings::lastModificationTime: Invalid key '%s'", grp_key.isNull() ? "(null)" : grp_key.latin1() );
+#endif
+	return TQDateTime();
+    }
+
+#if !defined(TQWS) && (defined(TQ_WS_WIN) || defined(TQ_OS_MAC))
+    if ( d->sysd )
+	return TQDateTime();
+#endif
+
+    if (grp_key[0] == '/') {
+	// parse our key
+	TQStringList list(TQStringList::split('/', grp_key));
+
+	if (list.count() < 2) {
+#ifdef TQT_CHECK_STATE
+	    qWarning("TQSettings::lastModificationTime: Invalid key '%s'", grp_key.latin1());
+#endif // TQT_CHECK_STATE
+
+	    return TQDateTime();
+	}
+
+	if (list.count() == 2) {
+	    d->heading = list[0];
+	    d->group = "General";
+	} else {
+	    d->heading = list[0];
+	    d->group = list[1];
+	}
+    }
+
+    return d->modificationTime();
+}
+
+
+/*!
+    \overload
+    \obsolete
+
+    Writes the string list entry \a value into key \a key. The \a key
+    is created if it doesn't exist. Any previous value is overwritten
+    by \a value. The list is stored as a sequence of strings separated
+    by \a separator (using TQStringList::join()), so none of the
+    strings in the list should contain the separator. If the list is
+    empty or null the key's value will be an empty string.
+
+    \warning The list should not contain empty or null strings, as
+    readListEntry() will use TQStringList::split() to recreate the
+    list.  As the documentation states, TQStringList::split() will omit
+    empty strings from the list.  Because of this, it is impossible to
+    retrieve identical list data that is stored with this function.
+    We recommend using the writeEntry() and readListEntry() overloads
+    that do not take a \a separator argument.
+
+
+    If an error occurs the settings are left unchanged and FALSE is
+    returned; otherwise returns TRUE.
+
+    \sa readListEntry(), readNumEntry(), readDoubleEntry(), readBoolEntry(), removeEntry(), TQStringList::join()
+*/
+bool TQSettings::writeEntry(const TQString &key, const TQStringList &value,
+			   const TQChar &separator)
+{
+    TQString s(value.join(separator));
+    return writeEntry(key, s);
+}
+
+/*!
+    \overload
+
+    Writes the string list entry \a value into key \a key. The \a key
+    is created if it doesn't exist. Any previous value is overwritten
+    by \a value.
+
+    If an error occurs the settings are left unchanged and FALSE is
+    returned; otherwise returns TRUE.
+
+    \sa readListEntry(), readNumEntry(), readDoubleEntry(), readBoolEntry(), removeEntry()
+*/
+bool TQSettings::writeEntry(const TQString &key, const TQStringList &value)
+{
+    TQString s;
+    for (TQStringList::ConstIterator it=value.begin(); it!=value.end(); ++it) {
+	TQString el = *it;
+	if ( el.isNull() ) {
+	    el = "^0";
+	} else {
+	    el.tqreplace("^", "^^");
+	}
+	s+=el;
+	s+="^e"; // end of element
+    }
+    return writeEntry(key, s);
+}
+
+
+/*!
+    \overload TQStringList TQSettings::readListEntry(const TQString &key, const TQChar &separator, bool *ok ) const
+    \obsolete
+
+    Reads the entry specified by \a key as a string. The \a separator
+    is used to create a TQStringList by calling TQStringList::split(\a
+    separator, entry). If \a ok is not 0: \a *ok is set to TRUE
+    if the key was read, otherwise \a *ok is set to FALSE.
+
+    \warning As the documentation states, TQStringList::split() will
+    omit empty strings from the list.  Because of this, it is
+    impossible to retrieve identical list data with this function.  We
+    recommend using the readListEntry() and writeEntry() overloads
+    that do not take a \a separator argument.
+
+    Note that if you want to iterate over the list, you should iterate
+    over a copy, e.g.
+    \code
+    TQStringList list = mySettings.readListEntry( "size", " " );
+    TQStringList::Iterator it = list.begin();
+    while( it != list.end() ) {
+	myProcessing( *it );
+	++it;
+    }
+    \endcode
+
+    \sa readEntry(), readDoubleEntry(), readBoolEntry(), writeEntry(), removeEntry(), TQStringList::split()
+*/
+
+/*!
+    \internal
+*/
+TQStringList TQSettings::readListEntry(const TQString &key, const TQChar &separator, bool *ok )
+{
+    TQString value = readEntry( key, TQString::null, ok );
+    if ( ok && !*ok )
+	return TQStringList();
+
+    return TQStringList::split(separator, value);
+}
+
+/*!
+    \fn TQStringList TQSettings::readListEntry(const TQString &key, bool *ok ) const
+    Reads the entry specified by \a key as a string. If \a ok is not
+    0, \a *ok is set to TRUE if the key was read, otherwise \a *ok is
+    set to FALSE.
+
+    Note that if you want to iterate over the list, you should iterate
+    over a copy, e.g.
+    \code
+    TQStringList list = mySettings.readListEntry( "recentfiles" );
+    TQStringList::Iterator it = list.begin();
+    while( it != list.end() ) {
+	myProcessing( *it );
+	++it;
+    }
+    \endcode
+
+    \sa readEntry(), readDoubleEntry(), readBoolEntry(), writeEntry(), removeEntry(), TQStringList::split()
+*/
+
+/*!
+    \internal
+*/
+TQStringList TQSettings::readListEntry(const TQString &key, bool *ok )
+{
+    TQString value = readEntry( key, TQString::null, ok );
+    if ( ok && !*ok )
+	return TQStringList();
+    TQStringList l;
+    TQString s;
+    bool esc=FALSE;
+    for (int i=0; i<(int)value.length(); i++) {
+	if ( esc ) {
+	    if ( value[i] == 'e' ) { // end-of-string
+		l.append(s);
+		s="";
+	    } else if ( value[i] == '0' ) { // null string
+		s=TQString::null;
+	    } else {
+		s.append(value[i]);
+	    }
+	    esc=FALSE;
+	} else if ( value[i] == '^' ) {
+	    esc = TRUE;
+	} else {
+	    s.append(value[i]);
+	    if ( i == (int)value.length()-1 )
+		l.append(s);
+	}
+    }
+    return l;
+}
+
+#ifdef TQ_OS_MAC
+void qt_setSettingsBasePath(const TQString &); //qsettings_mac.cpp
+#endif
+
+/*!
+    Insert platform-dependent paths from platform-independent information.
+
+    The \a domain should be an Internet domain name
+    controlled by the producer of the software, eg. Trolltech products
+    use "trolltech.com".
+
+    The \a product should be the official name of the product.
+
+    The \a scope should be
+    TQSettings::User for user-specific settings, or
+    TQSettings::Global for system-wide settings (generally
+    these will be read-only to many users).
+
+    Not all information is relevant on all systems.
+*/
+
+void TQSettings::setPath( const TQString &domain, const TQString &product, Scope scope )
+{
+//    On Windows, any trailing ".com(\..*)" is stripped from the domain. The
+//    Global scope corresponds to HKEY_LOCAL_MACHINE, and User corresponds to
+//    HKEY_CURRENT_USER. Note that on some installations, not all users can
+//    write to the Global scope. On UNIX, any trailing ".com(\..*)" is stripped
+//    from the domain. The Global scope corresponds to "/opt" (this would be
+//    configurable at library build time - eg. to "/usr/local" or "/usr"),
+//    while the User scope corresponds to $HOME/.*rc.
+//    Note that on most installations, not all users can write to the System
+//    scope.
+//
+//    On MacOS X, if there is no "." in domain, append ".com", then reverse the
+//    order of the elements (Mac OS uses "com.apple.tqfinder" as domain+product).
+//    The Global scope corresponds to /Library/Preferences/*.plist, while the
+//    User scope corresponds to ~/Library/Preferences/*.plist.
+//    Note that on most installations, not all users can write to the System
+//    scope.
+    d->globalScope = scope == Global;
+
+    TQString actualSearchPath;
+    int lastDot = domain.tqfindRev( '.' );
+
+#if defined(TQ_WS_WIN)
+    actualSearchPath = "/" + domain.mid( 0, lastDot ) + "/" + product;
+    insertSearchPath( Windows, actualSearchPath );
+#elif !defined(TQWS) && defined(TQ_OS_MAC)
+    if(lastDot != -1) {
+	TQString topLevelDomain = domain.right( domain.length() - lastDot - 1 ) + ".";
+	if ( !topLevelDomain.isEmpty() )
+	    qt_setSettingsBasePath( topLevelDomain );
+    }
+    actualSearchPath = "/" + domain.left( lastDot ) + "." + product;
+    insertSearchPath( Mac, actualSearchPath );
+#else
+    if (scope == User)
+	actualSearchPath = TQDir::homeDirPath() + "/.";
+    else
+	actualSearchPath = TQString(qInstallPathSysconf()) + "/";
+    actualSearchPath += domain.mid( 0, lastDot ) + "/" + product;
+    insertSearchPath( Unix, actualSearchPath );
+#endif
+}
+
+/*!
+    Appends \a group to the current key prefix.
+
+    \code
+    TQSettings settings;
+    settings.beginGroup( "/MainWindow" );
+    // read values
+    settings.endGroup();
+    \endcode
+*/
+void TQSettings::beginGroup( const TQString &group )
+{
+    d->groupStack.push( group );
+    d->groupDirty = TRUE;
+}
+
+/*!
+    Undo previous calls to beginGroup(). Note that a single beginGroup("a/b/c") is undone
+    by a single call to endGroup().
+
+    \code
+    TQSettings settings;
+    settings.beginGroup( "/MainWindow/Geometry" );
+    // read values
+    settings.endGroup();
+    \endcode
+*/
+void TQSettings::endGroup()
+{
+    d->groupStack.pop();
+    d->groupDirty = TRUE;
+}
+
+/*!
+    Set the current key prefix to the empty string.
+*/
+void TQSettings::resetGroup()
+{
+    d->groupStack.clear();
+    d->groupDirty = FALSE;
+    d->groupPrefix = TQString::null;
+}
+
+/*!
+    Returns the current key prefix, or a null string if there is no key prefix set.
+
+    \sa beginGroup();
+*/
+TQString TQSettings::group() const
+{
+    if ( d->groupDirty ) {
+	d->groupDirty = FALSE;
+	d->groupPrefix = TQString::null;
+
+	TQValueStack<TQString>::Iterator it = d->groupStack.begin();
+	while ( it != d->groupStack.end() ) {
+	    TQString group = *it;
+	    ++it;
+	    if ( group[0] != '/' )
+		group.prepend( "/" );
+	    d->groupPrefix += group;
+	}
+    }
+    return d->groupPrefix;
+}
+
+#endif
diff --git a/tqtinterface/qt4/src/tools/tqsettings.h b/tqtinterface/qt4/src/tools/tqsettings.h
new file mode 100644
index 0000000..e7eb2a3
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqsettings.h
@@ -0,0 +1,159 @@
+/****************************************************************************
+**
+** Definition of TQSettings class
+**
+** Created : 000626
+**
+** Copyright (C) 2000-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQSETTINGS_H
+#define TQSETTINGS_H
+
+#ifndef TQT_H
+#include "tqdatetime.h"
+#include "tqstringlist.h"
+#endif // TQT_H
+
+#ifndef TQT_NO_SETTINGS
+
+class TQSettingsPrivate;
+
+
+class TQ_EXPORT TQSettings
+{
+public:
+    enum Format {
+	Native = 0,
+	Ini
+    };
+    enum System {
+	Unix = 0,
+	Windows,
+	Mac
+    };
+    enum Scope {
+	User,
+	Global
+    };
+
+    TQSettings();
+    TQSettings( Format format );
+
+    ~TQSettings();
+
+#if !defined(TQ_NO_BOOL_TYPE)
+    bool	writeEntry( const TQString &, bool );
+#endif
+    bool	writeEntry( const TQString &, double );
+    bool	writeEntry( const TQString &, int );
+    bool	writeEntry( const TQString &, const char * );
+    bool	writeEntry( const TQString &, const TQString & );
+    bool	writeEntry( const TQString &, const TQStringList & );
+    bool	writeEntry( const TQString &, const TQStringList &, const TQChar& sep );
+
+    TQStringList entryList(const TQString &) const;
+    TQStringList subkeyList(const TQString &) const;
+
+    //### remove non const versions in 4.0
+    TQStringList readListEntry( const TQString &, bool * = 0 );
+    TQStringList readListEntry( const TQString &, const TQChar& sep, bool * = 0 );
+    TQString	readEntry( const TQString &, const TQString &def = TQString::null, bool * = 0 );
+    int		readNumEntry( const TQString &, int def = 0, bool * = 0 );
+    double	readDoubleEntry( const TQString &, double def = 0, bool * = 0 );
+    bool	readBoolEntry( const TQString &, bool def = FALSE, bool * = 0 );
+
+    //### make those non-inlined in 4.0
+    TQStringList readListEntry( const TQString &key, bool *ok = 0 ) const
+    {
+	TQSettings *that = (TQSettings*)this;
+	return that->readListEntry( key, ok );
+    }
+    TQStringList readListEntry( const TQString &key, const TQChar& sep, bool *ok = 0 ) const
+    {
+	TQSettings *that = (TQSettings*)this;
+	return that->readListEntry( key, sep, ok );
+    }
+    TQString	readEntry( const TQString &key, const TQString &def = TQString::null,
+			   bool *ok = 0 ) const
+    {
+	TQSettings *that = (TQSettings*)this;
+	return that->readEntry( key, def, ok );
+    }
+    int		readNumEntry( const TQString &key, int def = 0, bool *ok = 0 ) const
+    {
+	TQSettings *that = (TQSettings*)this;
+	return that->readNumEntry( key, def, ok );
+    }
+
+    double	readDoubleEntry( const TQString &key, double def = 0, bool *ok = 0 ) const
+    {
+	TQSettings *that = (TQSettings*)this;
+	return that->readDoubleEntry( key, def, ok );
+    }
+    bool	readBoolEntry( const TQString &key, bool def = FALSE, bool *ok = 0 ) const
+    {
+	TQSettings *that = (TQSettings*)this;
+	return that->readBoolEntry( key, def, ok );
+    }
+
+    bool	removeEntry( const TQString & );
+
+    void insertSearchPath( System, const TQString & );
+    void removeSearchPath( System, const TQString & );
+
+    void setPath( const TQString &domain, const TQString &product, Scope = Global );
+
+    void beginGroup( const TQString &group );
+    void endGroup();
+    void resetGroup();
+    TQString group() const;
+
+    bool sync();
+
+private:
+    TQSettingsPrivate *d;
+
+#if defined(TQ_DISABLE_COPY)
+    TQSettings(const TQSettings &);
+    TQSettings &operator=(const TQSettings &);
+#endif
+
+    TQDateTime lastModificationTime( const TQString & );
+
+    friend class TQApplication;
+};
+
+#endif // TQT_NO_SETTINGS
+#endif // TQSETTINGS_H
diff --git a/tqtinterface/qt4/src/tools/tqsettings_p.h b/tqtinterface/qt4/src/tools/tqsettings_p.h
new file mode 100644
index 0000000..31283a1
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqsettings_p.h
@@ -0,0 +1,148 @@
+/****************************************************************************
+**
+** Definition of TQSettings related classes
+**
+** Created : 990124
+**
+** Copyright (C) 1999-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the kernel module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQSETTINGS_P_H
+#define TQSETTINGS_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the TQt API.  It exists for the convenience
+// of TQSettings. This header file may change from version to 
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+//
+
+#ifndef TQT_H
+#include "tqstringlist.h"
+#include "tqmap.h"
+#include "tqvaluestack.h"
+#endif // TQT_H
+
+#ifndef TQT_NO_SETTINGS
+class TQSettingsSysPrivate;
+
+// TQSettingsGroup is a map of key/value pairs
+class TQSettingsGroup : public TQMap<TQString,TQString>
+{
+public:
+    TQSettingsGroup();
+
+    bool modified;
+};
+
+// TQSettingsHeading is a map of heading/group pairs
+class TQSettingsHeading : public TQMap<TQString,TQSettingsGroup>
+{
+public:
+    TQSettingsHeading::Iterator git;
+    void read(const TQString &);
+    void parseLine(TQTextStream &);
+};
+
+
+class TQSettingsPrivate
+{
+public:
+    TQSettingsPrivate( TQSettings::Format format );
+    ~TQSettingsPrivate();
+
+    TQSettingsGroup readGroup();
+    void removeGroup(const TQString &);
+    void writeGroup(const TQString &, const TQString &);
+    TQDateTime modificationTime();
+
+    TQStringList searchPaths;
+    TQMap<TQString,TQSettingsHeading> headings;
+    TQString group;
+    TQString heading;
+
+    /*### static data brings threading trouble
+    static TQString *defProduct;
+    static TQString *defDomain;
+    */
+    TQValueStack<TQString> groupStack;
+    TQString groupPrefix;
+
+    bool groupDirty :1;
+    bool modified :1;
+    bool globalScope :1;
+
+#if !defined(TQWS) && (defined(TQ_WS_WIN) || defined(TQ_OS_MAC))
+    // system dependent implementations to use the 
+    // system specific setting database (ie. registry on Windows)
+
+    TQSettingsSysPrivate *sysd;
+    void	sysInit();
+    void	sysClear();
+
+#if !defined(TQ_NO_BOOL_TYPE)
+    bool	sysWriteEntry( const TQString &, bool );
+#endif
+    bool	sysWriteEntry( const TQString &, double );
+    bool	sysWriteEntry( const TQString &, int );
+    bool	sysWriteEntry( const TQString &, const TQString & );
+    bool	sysWriteEntry( const TQString &, const TQStringList & );
+    bool	sysWriteEntry( const TQString &, const TQStringList &, const TQChar& sep );
+
+    TQStringList sysEntryList(const TQString &) const;
+    TQStringList sysSubkeyList(const TQString &) const;
+
+    TQStringList sysReadListEntry( const TQString &, bool * = 0 ) const;
+    TQStringList sysReadListEntry( const TQString &, const TQChar& sep, bool * = 0 ) const;
+    TQString	sysReadEntry( const TQString &, const TQString &def = TQString::null, bool * = 0 ) const;
+    int		sysReadNumEntry( const TQString &, int def = 0, bool * = 0 ) const;
+    double	sysReadDoubleEntry( const TQString &, double def = 0, bool * = 0 ) const;
+    bool	sysReadBoolEntry( const TQString &, bool def = 0, bool * = 0 ) const;
+
+    bool	sysRemoveEntry( const TQString & );
+
+    bool	sysSync();
+
+    void	sysInsertSearchPath( TQSettings::System, const TQString & );
+    void	sysRemoveSearchPath( TQSettings::System, const TQString & );
+#endif
+
+};
+#endif //TQT_NO_SETTINGS
+#endif // TQSETTINGS_P_H
diff --git a/tqtinterface/qt4/src/tools/tqshared.h b/tqtinterface/qt4/src/tools/tqshared.h
new file mode 100644
index 0000000..918af3c
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqshared.h
@@ -0,0 +1,58 @@
+/****************************************************************************
+**
+** Definition of TQShared struct
+**
+** Created : 940112
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQSHARED_H
+#define TQSHARED_H
+
+#ifndef TQT_H
+#include "tqglobal.h"
+#endif // TQT_H
+
+
+struct TQ_EXPORT TQShared
+{
+    TQShared() : count( 1 ) { }
+    void ref()		{ count++; }
+    bool deref()	{ return !--count; }
+    uint count;
+};
+
+
+#endif // TQSHARED_H
diff --git a/tqtinterface/qt4/src/tools/tqsortedlist.h b/tqtinterface/qt4/src/tools/tqsortedlist.h
new file mode 100644
index 0000000..28799f1
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqsortedlist.h
@@ -0,0 +1,63 @@
+/****************************************************************************
+**
+** Definition of TQSortedList template/macro class
+**
+** Created : 920701
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQSORTEDLIST_H
+#define TQSORTEDLIST_H
+
+#ifndef TQT_H
+#include "tqptrlist.h"
+#endif // TQT_H
+
+
+template<class type> 
+class TQSortedList : public TQPtrList<type>
+{
+public:
+    TQSortedList() {}
+    TQSortedList( const TQSortedList<type> &l ) : TQPtrList<type>(l) {}
+    ~TQSortedList() { this->clear(); }
+    TQSortedList<type> &operator=(const TQSortedList<type> &l)
+      { return (TQSortedList<type>&)TQPtrList<type>::operator=(l); }
+
+    virtual int compareItems( TQPtrCollection::Item s1, TQPtrCollection::Item s2 )
+      { if ( *((type*)s1) == *((type*)s2) ) return 0; return ( *((type*)s1) < *((type*)s2) ? -1 : 1 ); }
+};
+
+#endif
diff --git a/tqtinterface/qt4/src/tools/tqstring.cpp b/tqtinterface/qt4/src/tools/tqstring.cpp
new file mode 100644
index 0000000..5c731b3
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqstring.cpp
@@ -0,0 +1,8350 @@
+/****************************************************************************
+**
+** Implementation of the TQString class and related Unicode functions
+**
+** Created : 920722
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+// Don't define it while compiling this module, or USERS of TQt will
+// not be able to link.
+#ifdef TQT_NO_CAST_ASCII
+#undef TQT_NO_CAST_ASCII
+#endif
+
+#include "tqstring.h"
+#include "tqregexp.h"
+#include "tqdatastream.h"
+#ifndef TQT_NO_TEXTCODEC
+#include "tqtextcodec.h"
+#endif
+#include "tqlocale.h"
+#include "tqlocale_p.h"
+
+#include "tqunicodetables_p.h"
+#include <limits.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifndef TQ_OS_TEMP
+#include <locale.h>
+#endif
+#if defined(TQ_WS_WIN)
+#include "tqt_windows.h"
+#endif
+#if !defined( TQT_NO_COMPONENT ) && !defined( TQT_LITE_COMPONENT )
+#include "tqcleanuphandler.h"
+#endif
+
+#ifndef LLONG_MAX
+#define LLONG_MAX TQ_INT64_C(9223372036854775807)
+#endif
+#ifndef LLONG_MIN
+#define LLONG_MIN (-LLONG_MAX - TQ_INT64_C(1))
+#endif
+#ifndef ULLONG_MAX
+#define ULLONG_MAX TQ_UINT64_C(18446744073709551615)
+#endif
+
+#ifdef USE_QT4
+
+// #include <Qt/qhash.h>
+
+// static QHash<void *, QByteArray> *asciiCache = 0;
+
+TQT_STATIC_CONST_IMPL TQChar TQChar::null;
+TQT_STATIC_CONST_IMPL TQChar TQChar::tqreplacement((ushort)0xfffd);
+TQT_STATIC_CONST_IMPL TQChar TQChar::byteOrderMark((ushort)0xfeff);
+TQT_STATIC_CONST_IMPL TQChar TQChar::byteOrderSwapped((ushort)0xfffe);
+TQT_STATIC_CONST_IMPL TQChar TQChar::nbsp((ushort)0x00a0);
+
+/*!
+  \internal
+*/
+const char *TQString::ascii_helper() const
+{
+	// tqstring_ascii_ba must be a persistent member variable within the class instance, but NOT static.  A static variable is global for ALL class instances (very bad!)
+	// Also, it MUST be declared mutable, otherwise a raft of "discards qualifiers" errors will pop up.
+
+// 	tqstring_ascii_ba = toAscii();
+	// Get a real, TRUE copy of the data, not some stupid shared copy that will randomly invalidate my pointer at an unknown future date/time
+	QByteArray tempba = toAscii();
+	tqstring_ascii_ba.resize(tempba.size());
+	memcpy(tqstring_ascii_ba.data(), tempba.data(), tempba.size());
+	return tqstring_ascii_ba.data();
+}
+
+/*!
+  \internal
+*/
+const char *TQString::latin1_helper() const
+{
+	// tqstring_latin1_ba must be a persistent member variable within the class instance, but NOT static.  A static variable is global for ALL class instances (very bad!)
+	// Also, it MUST be declared mutable, otherwise a raft of "discards qualifiers" errors will pop up.
+
+	//tqstring_latin1_ba = toLatin1();
+	// Get a real, TRUE copy of the data, not some stupid shared copy that will randomly invalidate my pointer at an unknown future date/time
+	QByteArray tempba = toLatin1();
+	tqstring_latin1_ba.resize(tempba.size());
+	memcpy(tqstring_latin1_ba.data(), tempba.data(), tempba.size());
+	return tqstring_latin1_ba.data();
+}
+
+/*!
+    This utility function converts \a l 16-bit characters from \a uc
+    to ASCII, returning a '\0'-terminated string.
+
+    The caller is responsible for deleting the resultant string with
+    delete[].
+*/
+char* TQString::tqunicodeToLatin1(const TQChar *uc, uint l)
+{
+    if (!uc) {
+	return 0;
+    }
+    char *a = new char[l+1];
+    char *result = a;
+    while (l--) {
+	*a++ = (uc->tqunicode() > 0xff) ? '?' : (char)uc->tqunicode();
+	uc++;
+    }
+    *a = '\0';
+    return result;
+}
+
+#if defined(Q_CC_MSVC) && _MSC_VER <= 1300
+const TQString::Null TQString::null;
+#else
+const TQString::Null TQString::null = { };
+#endif
+
+/*****************************************************************************
+  TQString stream functions
+ *****************************************************************************/
+#ifndef TQT_NO_DATASTREAM
+/*!
+    \relates TQString
+
+    Writes the string \a str to the stream \a s.
+
+    See also \link datastreamformat.html Format of the TQDataStream operators \endlink
+*/
+
+TQDataStream &operator<<( TQDataStream &s, const TQString &str )
+{
+    if ( s.version() == 1 ) {
+	TQCString l( str.latin1() );
+	s << l;
+    }
+    else {
+	int byteOrder = s.byteOrder();
+	const TQChar* ub = str.tqunicode();
+	if ( ub || s.version() < 3 ) {
+	    static const uint auto_size = 1024;
+	    char t[auto_size];
+	    char *b;
+	    if ( str.length()*sizeof(TQChar) > auto_size ) {
+		b = new char[str.length()*sizeof(TQChar)];
+	    } else {
+		b = t;
+	    }
+	    int l = str.length();
+	    char *c=b;
+	    while ( l-- ) {
+		if ( byteOrder == TQDataStream::BigEndian ) {
+		    *c++ = (char)ub->row();
+		    *c++ = (char)ub->cell();
+		} else {
+		    *c++ = (char)ub->cell();
+		    *c++ = (char)ub->row();
+		}
+		ub++;
+	    }
+	    s.writeBytes( b, sizeof(TQChar)*str.length() );
+	    if ( str.length()*sizeof(TQChar) > auto_size )
+		delete [] b;
+	} else {
+	    // write null marker
+	    s << (TQ_UINT32)0xffffffff;
+	}
+    }
+    return s;
+}
+
+/*!
+    \relates TQString
+
+    Reads a string from the stream \a s into string \a str.
+
+    See also \link datastreamformat.html Format of the TQDataStream operators \endlink
+*/
+
+TQDataStream &operator>>( TQDataStream &s, TQString &str )
+{
+#ifdef TQT_TQSTRING_UCS_4
+#if defined(TQ_CC_GNU)
+#warning "operator>> not working properly"
+#endif
+#endif
+    if ( s.version() == 1 ) {
+	TQCString l;
+	s >> l;
+	str = TQString( l );
+    }
+    else {
+	TQ_UINT32 bytes = 0;
+	s >> bytes;                                     // read size of string
+	if ( bytes == 0xffffffff ) {                    // null string
+	    str = TQString::null;
+	} else if ( bytes > 0 ) {                       // not empty
+	    int byteOrder = s.byteOrder();
+	    str.setLength( bytes/2 );
+// 	    TQChar* ch = str.d->tqunicode;
+	    TQChar* ch = static_cast<TQChar*>(str.data());
+	    static const uint auto_size = 1024;
+	    char t[auto_size];
+	    char *b;
+	    if ( bytes > auto_size ) {
+		b = new char[bytes];
+	    } else {
+		b = t;
+	    }
+	    s.readRawBytes( b, bytes );
+	    int bt = bytes/2;
+	    char *oldb = b;
+	    while ( bt-- ) {
+		if ( byteOrder == TQDataStream::BigEndian )
+		    *ch++ = (ushort) (((ushort)b[0])<<8) | (uchar)b[1];
+		else
+		    *ch++ = (ushort) (((ushort)b[1])<<8) | (uchar)b[0];
+		b += 2;
+	    }
+	    if ( bytes > auto_size )
+		delete [] oldb;
+	} else {
+	    str = "";
+	}
+    }
+    return s;
+}
+#endif // TQT_NO_DATASTREAM
+
+#ifndef TQT_NO_CAST_ASCII
+TQString &TQString::operatorPlusEqHelper( const char *s, uint len2 )
+{
+//     if ( s ) {
+// #ifndef TQT_NO_TEXTCODEC
+// 	if ( TQTextCodec::codecForCStrings() )
+// 	    return operator+=( fromAscii( s, len2 ) );
+// #endif
+//
+// 	uint len1 = length();
+// 	if ( len2 == UINT_MAX )
+// 	    len2 = int(strlen( s ));
+// 	if ( len2 ) {
+// 	    grow( len1 + len2 );
+// 	    TQChar* uc = d->tqunicode + len1;
+// 	    while ( len2-- )
+// 		*uc++ = *s++;
+// 	} else if ( isNull() ) {   // ## just for 1.x compat:
+// 	    *this = tqfromLatin1( "" );
+// 	}
+//     }
+//     return *this;
+
+	this->append(s);
+	return *this;
+}
+#endif
+
+/*!
+    \class TQCharRef tqstring.h
+    \reentrant
+    \brief The TQCharRef class is a helper class for TQString.
+
+    \ingroup text
+
+    When you get an object of type TQCharRef, if you can assign to it,
+    the assignment will apply to the character in the string from
+    which you got the reference. That is its whole purpose in life.
+    The TQCharRef becomes invalid once modifications are made to the
+    string: if you want to keep the character, copy it into a TQChar.
+
+    Most of the TQChar member functions also exist in TQCharRef.
+    However, they are not explicitly documented here.
+
+    \sa TQString::operator[]() TQString::at() TQChar
+*/
+
+/*! \fn TQString& TQString::append( const char *str )
+  \overload
+
+  Appends \a str to the string and returns a reference to the result.
+
+  Equivalent to operator+=().
+*/
+
+/*!
+    Appends \a str to the string and returns a reference to the string.
+*/
+TQString& TQString::operator+=( const TQString &str )
+{
+//     uint len1 = length();
+//     uint len2 = str.length();
+//     if ( len2 ) {
+// 	if ( isEmpty() ) {
+// 	    operator=( str );
+// 	} else {
+// 	    grow( len1+len2 );
+// 	    memcpy( d->tqunicode+len1, str.tqunicode(), sizeof(TQChar)*len2 );
+// 	}
+//     } else if ( isNull() && !str.isNull() ) {   // ## just for 1.x compat:
+// 	*this = tqfromLatin1( "" );
+//     }
+//     return *this;
+
+	this->append(str);
+	return *this;
+}
+
+/*!
+    \overload
+
+  Appends \a str to the string and returns a reference to the string.
+*/
+#ifndef TQT_NO_CAST_ASCII
+TQString& TQString::operator+=( const char *str )
+{
+    // ### TQt 4: make this function inline
+    return operatorPlusEqHelper( str );
+}
+#endif
+
+/*! \overload
+
+  Appends \a c to the string and returns a reference to the string.
+*/
+
+TQString &TQString::operator+=( TQChar c )
+{
+//     grow( length()+1 );
+//     d->tqunicode[length()-1] = c;
+//     return *this;
+
+	this->append(c);
+	return *this;
+}
+
+/*!
+    \overload
+
+    Appends \a c to the string and returns a reference to the string.
+*/
+
+TQString &TQString::operator+=( char c )
+{
+// #ifndef TQT_NO_TEXTCODEC
+//     if ( TQTextCodec::codecForCStrings() )
+// 	return operator+=( fromAscii( &c, 1 ) );
+// #endif
+//     grow( length()+1 );
+//     d->tqunicode[length()-1] = c;
+//     return *this;
+
+	this->append(c);
+	return *this;
+}
+
+TQString &TQString::operator+=(const QStringRef &s) {
+	//return convertFromQString();
+	return (*static_cast<TQString*>(&append(s)));
+}
+
+TQString &TQString::operator+=(const QLatin1String &s) {
+	return (*static_cast<TQString*>(&append(s)));
+}
+
+TQString &TQString::operator+=(QChar c) {
+	return (*static_cast<TQString*>(&append(c)));
+}
+
+/*!
+    \fn TQCharRef TQString::at( uint i )
+
+    \overload
+
+    The function returns a reference to the character at index \a i.
+    The resulting reference can then be assigned to, or used
+    immediately, but it will become invalid once further modifications
+    are made to the original string.
+
+    If \a i is beyond the length of the string then the string is
+    expanded with TQChar::null.
+*/
+
+/*
+  Internal chunk of code to handle the
+  uncommon cases of at() above.
+*/
+void TQString::subat( uint i )
+{
+    uint olen = length();
+    if ( i >= olen ) {
+	setLength( i+1 );               // i is index; i+1 is needed length
+	for ( uint j=olen; j<=i; j++ )
+	    tqat(j) = TQChar::null;
+    } else {
+	// Just be sure to detach
+// 	real_detach();
+    }
+}
+
+/*!
+    \fn const TQChar* TQString::tqunicode() const
+
+    Returns the Unicode representation of the string. The result
+    remains valid until the string is modified.
+*/
+
+/*!
+    Returns the string encoded in a locale-specific format. On X11,
+    this is the TQTextCodec::codecForLocale(). On Windows, it is a
+    system-defined encoding. On Mac OS X, this always uses UTF-8 as
+    the encoding.
+
+    See TQTextCodec for more diverse coding/decoding of Unicode
+    strings.
+
+    \sa fromLocal8Bit(), ascii(), latin1(), utf8()
+*/
+
+TQCString TQString::local8Bit() const
+{
+#ifdef TQT_NO_TEXTCODEC
+    return latin1();
+#else
+#ifdef TQ_WS_X11
+    TQTextCodec* codec = TQTextCodec::codecForLocale();
+    return codec
+	    ? codec->fromUnicode(*this)
+	    : TQCString(latin1());
+#endif
+#if defined( TQ_WS_MACX )
+    return utf8();
+#endif
+#if defined( TQ_WS_MAC9 )
+    return TQCString(latin1()); //I'm evil..
+#endif
+#ifdef TQ_WS_WIN
+    return isNull() ? TQCString("") : qt_winTQString2MB( *this );
+#endif
+#ifdef TQ_WS_TQWS
+    return utf8(); // ### if there is any 8 bit format supported?
+#endif
+#endif
+}
+
+// TQCString TQString::local8Bit() const
+// {
+// 	return toLocal8Bit();
+// }
+
+/*!
+    Returns the Unicode string decoded from the first \a len
+    bytes of \a utf8, ignoring the rest of \a utf8. If \a len is
+    -1 then the length of \a utf8 is used. If \a len is bigger than
+    the length of \a utf8 then it will use the length of \a utf8.
+
+    \code
+	TQString str = TQString::fromUtf8( "123456789", 5 );
+	// str == "12345"
+    \endcode
+
+    See TQTextCodec for more diverse coding/decoding of Unicode strings.
+*/
+TQString TQString::fromUtf8( const char* utf8, int len )
+{
+	if ( !utf8 )
+		return TQString();
+	TQString result = QString::fromUtf8(utf8, len);
+	int slen = int(strlen(utf8));
+	if (result.length() > slen) {
+		result.truncate(slen);
+	}
+	return result;
+}
+
+/*!
+    Returns the Unicode string decoded from the first \a len
+    bytes of \a chars, ignoring the rest of \a chars. If \a len
+    is -1 then the length of \a chars is used. If \a len is bigger
+    than the length of \a chars then it will use the length of \a
+    chars.
+
+    \sa fromAscii()
+*/
+TQString TQString::fromLatin1( const char* chars, int len )
+{
+	if ( !chars )
+		return TQString();
+	TQString result = QString::fromLatin1(chars, len);
+	int slen = int(strlen(chars));
+	if (result.length() > slen) {
+		result.truncate(slen);
+	}
+	return result;
+}
+
+/*!
+    Returns the string encoded in UTF-8 format.
+
+    See TQTextCodec for more diverse coding/decoding of Unicode strings.
+
+    \sa fromUtf8(), ascii(), latin1(), local8Bit()
+*/
+TQCString TQString::utf8() const
+{
+    int l = length();
+    int rlen = l*3+1;
+    TQCString rstr(rlen);
+    uchar* cursor = (uchar*)rstr.data();
+    const TQChar *ch = static_cast<const TQChar*>(data());
+    for (int i=0; i < l; i++) {
+	uint u = ch->tqunicode();
+ 	if ( u < 0x80 ) {
+ 	    *cursor++ = (uchar)u;
+ 	} else {
+ 	    if ( u < 0x0800 ) {
+		*cursor++ = 0xc0 | ((uchar) (u >> 6));
+ 	    } else {
+		if (u >= 0xd800 && u < 0xdc00 && i < l-1) {
+		    unsigned short low = ch[1].tqunicode();
+		    if (low >= 0xdc00 && low < 0xe000) {
+			++ch;
+			++i;
+			u = (u - 0xd800)*0x400 + (low - 0xdc00) + 0x10000;
+		    }
+		}
+		if (u > 0xffff) {
+		    // if people are working in utf8, but strings are encoded in eg. latin1, the resulting
+		    // name might be invalid utf8. This and the corresponding code in fromUtf8 takes care
+		    // we can handle this without loosing information. This can happen with latin filenames
+		    // and a utf8 locale under Unix.
+		    if (u > 0x10fe00 && u < 0x10ff00) {
+			*cursor++ = (u - 0x10fe00);
+			++ch;
+			continue;
+		    } else {
+			*cursor++ = 0xf0 | ((uchar) (u >> 18));
+			*cursor++ = 0x80 | ( ((uchar) (u >> 12)) & 0x3f);
+		    }
+		} else {
+		    *cursor++ = 0xe0 | ((uchar) (u >> 12));
+		}
+ 		*cursor++ = 0x80 | ( ((uchar) (u >> 6)) & 0x3f);
+ 	    }
+ 	    *cursor++ = 0x80 | ((uchar) (u&0x3f));
+ 	}
+ 	++ch;
+    }
+    rstr.truncate( cursor - (uchar*)rstr.data() );
+    return rstr;
+}
+
+static bool tqIsUpper(char c)
+{
+    return c >= 'A' && c <= 'Z';
+}
+
+static bool tqIsDigit(char c)
+{
+    return c >= '0' && c <= '9';
+}
+
+static char tqToLower(char c)
+{
+    if (c >= 'A' && c <= 'Z')
+    	return c - 'A' + 'a';
+    else
+    	return c;
+}
+
+struct ArgEscapeData
+{
+    uint min_escape;	    // lowest escape sequence number
+    uint occurrences;	    // number of occurences of the lowest escape
+    	    	    	    // sequence number
+    uint locale_occurrences; // number of occurences of the lowest escape
+    	    	    	    // sequence number which contain 'L'
+    uint escape_len;	    // total length of escape sequences which will
+    	    	    	    // be tqreplaced
+};
+
+static ArgEscapeData tqfindArgEscapes(const TQString &s)
+{
+    const TQChar *uc_begin = s.tqunicode();
+    const TQChar *uc_end = uc_begin + s.length();
+
+    ArgEscapeData d;
+
+    d.min_escape = 10;
+    d.occurrences = 0;
+    d.escape_len = 0;
+    d.locale_occurrences = 0;
+
+    const TQChar *c = uc_begin;
+    while (c != uc_end) {
+    	while (c != uc_end && c->tqunicode() != '%')
+	    ++c;
+
+	if (c == uc_end || ++c == uc_end)
+	    break;
+
+	bool locale_arg = FALSE;
+    	if (c->tqunicode() == 'L') {
+	    locale_arg = TRUE;
+	    if (++c == uc_end)
+		break;
+	}
+
+    	if (c->tqunicode() < '0' || c->tqunicode() > '9')
+	    continue;
+
+	uint escape = c->tqunicode() - '0';
+    	++c;
+
+    	if (escape > d.min_escape)
+	    continue;
+
+    	if (escape < d.min_escape) {
+	    d.min_escape = escape;
+	    d.occurrences = 0;
+	    d.escape_len = 0;
+	    d.locale_occurrences = 0;
+	}
+
+#if TQT_VERSION < 0x040000
+    	// ### remove preprocessor in TQt 4.0
+	/* Since in TQt < 4.0 only the first instance is tqreplaced,
+	   escape_len should hold the length of only the first escape
+	   sequence */
+    	if (d.occurrences == 0)
+#endif
+    	{
+	    ++d.occurrences;
+    	    if (locale_arg) {
+    	    	++d.locale_occurrences;
+		d.escape_len += 3;
+	    }
+	    else
+		d.escape_len += 2;
+	}
+    }
+
+    return d;
+}
+
+static TQString tqreplaceArgEscapes(const TQString &s, const ArgEscapeData &d, int field_width,
+    	    	    	    	    const TQString &arg, const TQString &larg)
+{
+    const TQChar *uc_begin = s.tqunicode();
+    const TQChar *uc_end = uc_begin + s.length();
+
+    uint abs_field_width = TQABS(field_width);
+    uint result_len = s.length()
+    	    	    	- d.escape_len
+			+ (d.occurrences - d.locale_occurrences)
+			    *TQMAX(abs_field_width, arg.length())
+			+ d.locale_occurrences
+			    *TQMAX(abs_field_width, larg.length());
+
+    TQString result;
+    result.setLength(result_len);
+    TQChar *result_buff = (TQChar*) result.tqunicode();
+
+    TQChar *rc = result_buff;
+    const TQChar *c = uc_begin;
+    uint repl_cnt = 0;
+    while (c != uc_end) {
+    	/* We don't have to check if we run off the end of the string with c,
+	   because as long as d.occurrences > 0 we KNOW there are valid escape
+	   sequences. */
+
+    	const TQChar *text_start = c;
+
+    	while (c->tqunicode() != '%')
+	    ++c;
+
+	const TQChar *escape_start = c++;
+
+	bool locale_arg = FALSE;
+    	if (c->tqunicode() == 'L') {
+	    locale_arg = TRUE;
+	    ++c;
+	}
+
+    	if (c->tqunicode() != '0' + d.min_escape) {
+	    memcpy(rc, text_start, (c - text_start)*sizeof(TQChar));
+	    rc += c - text_start;
+	}
+	else {
+    	    ++c;
+
+	    memcpy(rc, text_start, (escape_start - text_start)*sizeof(TQChar));
+	    rc += escape_start - text_start;
+
+    	    uint pad_chars;
+    	    if (locale_arg)
+	    	pad_chars = TQMAX(abs_field_width, larg.length()) - larg.length();
+	    else
+	    	pad_chars = TQMAX(abs_field_width, arg.length()) - arg.length();
+
+    	    if (field_width > 0) { // left padded
+		for (uint i = 0; i < pad_chars; ++i)
+//	    	    (rc++)->tqunicode() = ' ';
+	    	    *(rc++) = ' ';
+	    }
+
+    	    if (locale_arg) {
+	    	memcpy(rc, larg.tqunicode(), larg.length()*sizeof(TQChar));
+		rc += larg.length();
+	    }
+	    else {
+	    	memcpy(rc, arg.tqunicode(), arg.length()*sizeof(TQChar));
+	    	rc += arg.length();
+	    }
+
+    	    if (field_width < 0) { // right padded
+		for (uint i = 0; i < pad_chars; ++i)
+//	    	    (rc++)->tqunicode() = ' ';
+	    	    *(rc++) = ' ';
+	    }
+
+	    if (++repl_cnt == d.occurrences) {
+		memcpy(rc, c, (uc_end - c)*sizeof(TQChar));
+		rc += uc_end - c;
+		TQ_ASSERT(rc - result_buff == (int)result_len);
+		c = uc_end;
+	    }
+	}
+    }
+
+    return result;
+}
+
+/*!
+    This function will return a string that tqreplaces the lowest
+    numbered occurrence of \c %1, \c %2, ..., \c %9 with \a a.
+
+    The \a fieldWidth value specifies the minimum amount of space that
+    \a a is padded to. A positive value will produce right-aligned
+    text, whereas a negative value will produce left-aligned text.
+
+    The following example shows how we could create a 'status' string
+    when processing a list of files:
+    \code
+    TQString status = TQString( "Processing file %1 of %2: %3" )
+			.tqarg( i )         // current file's number
+			.tqarg( total )     // number of files to process
+			.tqarg( fileName ); // current file's name
+    \endcode
+
+    It is generally fine to use filenames and numbers as we have done
+    in the example above. But note that using tqarg() to construct
+    natural language sentences does not usually translate well into
+    other languages because sentence structure and word order often
+    differ between languages.
+
+    If there is no place marker (\c %1, \c %2, etc.), a warning
+    message (qWarning()) is output and the result is undefined.
+
+    \warning If any placeholder occurs more than once, the result is undefined.
+
+*/
+TQString TQString::tqarg( const TQString& a, int fieldWidth ) const
+{
+    ArgEscapeData d = tqfindArgEscapes(*this);
+
+    if (d.occurrences == 0) {
+        qWarning( "TQString::tqarg(): Argument missing: %s, %s", latin1(),
+                  a.latin1() );
+        return *this;
+    }
+
+    return tqreplaceArgEscapes(*this, d, fieldWidth, a, a);
+}
+
+/*!
+    \fn TQString TQString::tqarg( const TQString& a1, const TQString& a2 ) const
+
+    \overload
+
+    This is the same as str.tqarg(\a a1).tqarg(\a a2), except that
+    the strings are tqreplaced in one pass. This can make a difference
+    if \a a1 tqcontains e.g. \c{%1}:
+
+    \code
+    TQString str( "%1 %2" );
+    str.tqarg( "Hello", "world" );        // returns "Hello world"
+    str.tqarg( "Hello" ).tqarg( "world" );  // returns "Hello world"
+
+    str.tqarg( "(%1)", "Hello" );           // returns "(%1) Hello"
+    str.tqarg( "(%1)" ).tqarg( "Hello" );     // returns "(Hello) %2"
+    \endcode
+*/
+
+/*!
+    \fn TQString TQString::tqarg( const TQString& a1, const TQString& a2,
+			      const TQString& a3 ) const
+    \overload
+
+    This is the same as calling str.tqarg(\a a1).tqarg(\a a2).tqarg(\a a3),
+    except that the strings are tqreplaced in one pass.
+*/
+
+/*!
+    \fn TQString TQString::tqarg( const TQString& a1, const TQString& a2,
+			      const TQString& a3, const TQString& a4 ) const
+    \overload
+
+    This is the same as calling
+    str.tqarg(\a a1).tqarg(\a a2).tqarg(\a a3).tqarg(\a a4),
+    except that the strings are tqreplaced in one pass.
+*/
+
+/*!
+    \overload
+
+    The \a fieldWidth value specifies the minimum amount of space that
+    \a a is padded to. A positive value will produce a right-aligned
+    number, whereas a negative value will produce a left-aligned
+    number.
+
+    \a a is expressed in base \a base, which is 10 by default and must
+    be between 2 and 36.
+
+    The '%' can be followed by an 'L', in which case the sequence is
+    tqreplaced with a localized representation of \a a. The conversion
+    uses the default locale. The default locale is determined from the
+    system's locale settings at application startup. It can be changed
+    using TQLocale::setDefault(). The 'L' flag is ignored if \a base is
+    not 10.
+
+    \code
+	TQString str;
+	str = TQString( "Decimal 63 is %1 in hexadecimal" )
+		.tqarg( 63, 0, 16 );
+	// str == "Decimal 63 is 3f in hexadecimal"
+
+	TQLocale::setDefault(TQLocale::English, TQLocale::UnitedStates);
+	str = TQString( "%1 %L2 %L3" )
+		.tqarg( 12345 )
+		.tqarg( 12345 )
+		.tqarg( 12345, 0, 16 );
+	// str == "12345 12,345 3039"
+    \endcode
+*/
+TQString TQString::tqarg( long a, int fieldWidth, int base ) const
+{
+    return tqarg((TQ_LLONG)a, fieldWidth, base);
+}
+
+/*!
+    \overload
+
+    \a a is expressed in base \a base, which is 10 by default and must
+    be between 2 and 36. If \a base is 10, the '%L' syntax can be used
+    to produce localized strings.
+*/
+TQString TQString::tqarg( ulong a, int fieldWidth, int base ) const
+{
+    return tqarg((TQ_ULLONG)a, fieldWidth, base);
+}
+
+/*!
+    \overload
+
+    \a a is expressed in base \a base, which is 10 by default and must
+    be between 2 and 36. If \a base is 10, the '%L' syntax can be used
+    to produce localized strings.
+*/
+TQString TQString::tqarg( TQ_LLONG a, int fieldWidth, int base ) const
+{
+    ArgEscapeData d = tqfindArgEscapes(*this);
+
+    if (d.occurrences == 0) {
+        qWarning( "TQString::tqarg(): Argument missing: %s, %lld", latin1(),
+                  a );
+        return *this;
+    }
+
+    TQString arg;
+    if (d.occurrences > d.locale_occurrences)
+    	arg = number(a, base);
+
+    TQString locale_arg;
+    if (d.locale_occurrences > 0) {
+	TQLocale locale;
+	locale_arg = locale.d->longLongToString(a, -1, base, -1, TQLocalePrivate::ThousandsGroup);
+    }
+
+    return tqreplaceArgEscapes(*this, d, fieldWidth, arg, locale_arg);
+}
+
+/*!
+    \overload
+
+    \a a is expressed in base \a base, which is 10 by default and must
+    be between 2 and 36. If \a base is 10, the '%L' syntax can be used
+    to produce localized strings.
+*/
+TQString TQString::tqarg( TQ_ULLONG a, int fieldWidth, int base ) const
+{
+    ArgEscapeData d = tqfindArgEscapes(*this);
+
+    if (d.occurrences == 0) {
+        qWarning( "TQString::tqarg(): Argument missing: %s, %llu", latin1(),
+                  a );
+        return *this;
+    }
+
+    TQString arg;
+    if (d.occurrences > d.locale_occurrences)
+    	arg = number(a, base);
+
+    TQString locale_arg;
+    if (d.locale_occurrences > 0) {
+	TQLocale locale;
+	locale_arg = locale.d->unsLongLongToString(a, -1, base, -1, TQLocalePrivate::ThousandsGroup);
+    }
+
+    return tqreplaceArgEscapes(*this, d, fieldWidth, arg, locale_arg);
+}
+
+/*!
+    \fn TQString TQString::tqarg( int a, int fieldWidth, int base ) const
+
+    \overload
+
+    \a a is expressed in base \a base, which is 10 by default and must
+    be between 2 and 36. If \a base is 10, the '%L' syntax can be used
+    to produce localized strings.
+*/
+
+/*!
+    \fn TQString TQString::tqarg( uint a, int fieldWidth, int base ) const
+
+    \overload
+
+    \a a is expressed in base \a base, which is 10 by default and must
+    be between 2 and 36. If \a base is 10, the '%L' syntax can be used
+    to produce localized strings.
+*/
+
+/*!
+    \fn TQString TQString::tqarg( short a, int fieldWidth, int base ) const
+
+    \overload
+
+    \a a is expressed in base \a base, which is 10 by default and must
+    be between 2 and 36. If \a base is 10, the '%L' syntax can be used
+    to produce localized strings.
+*/
+
+/*!
+    \fn TQString TQString::tqarg( ushort a, int fieldWidth, int base ) const
+
+    \overload
+
+    \a a is expressed in base \a base, which is 10 by default and must
+    be between 2 and 36. If \a base is 10, the '%L' syntax can be used
+    to produce localized strings.
+*/
+
+
+/*!
+    \overload
+
+    \a a is assumed to be in the Latin-1 character set.
+*/
+TQString TQString::tqarg( char a, int fieldWidth ) const
+{
+    TQString c;
+    c += a;
+    return tqarg( c, fieldWidth );
+}
+
+/*!
+    \overload
+*/
+TQString TQString::tqarg( TQChar a, int fieldWidth ) const
+{
+    TQString c;
+    c += a;
+    return tqarg( c, fieldWidth );
+}
+
+/*!
+    \overload
+
+    \target arg-formats
+
+    Argument \a a is formatted according to the \a fmt format specified,
+    which is 'g' by default and can be any of the following:
+
+    \table
+    \header \i Format \i Meaning
+    \row \i \c e \i format as [-]9.9e[+|-]999
+    \row \i \c E \i format as [-]9.9E[+|-]999
+    \row \i \c f \i format as [-]9.9
+    \row \i \c g \i use \c e or \c f format, whichever is the most concise
+    \row \i \c G \i use \c E or \c f format, whichever is the most concise
+    \endtable
+
+    With 'e', 'E', and 'f', \a prec is the number of digits after the
+    decimal point. With 'g' and 'G', \a prec is the maximum number of
+    significant digits (trailing zeroes are omitted).
+
+    \code
+        double d = 12.34;
+        TQString ds = TQString( "'E' format, precision 3, gives %1" )
+                        .tqarg( d, 0, 'E', 3 );
+        // ds == "'E' format, precision 3, gives 1.234E+01"
+    \endcode
+
+    The '%L' syntax can be used to produce localized strings.
+*/
+TQString TQString::tqarg( double a, int fieldWidth, char fmt, int prec ) const
+{
+    ArgEscapeData d = tqfindArgEscapes(*this);
+
+    if (d.occurrences == 0) {
+        qWarning( "TQString::tqarg(): Argument missing: %s, %g", latin1(),
+                  a );
+        return *this;
+    }
+
+    TQString arg;
+    if (d.occurrences > d.locale_occurrences)
+    	arg = number(a, fmt, prec);
+
+    TQString locale_arg;
+    if (d.locale_occurrences > 0) {
+	TQLocale locale;
+
+	TQLocalePrivate::DoubleForm form = TQLocalePrivate::DFDecimal;
+	uint flags = 0;
+
+	if (tqIsUpper(fmt))
+    	    flags = TQLocalePrivate::CapitalEorX;
+	fmt = tqToLower(fmt);
+
+	switch (fmt) {
+	    case 'f':
+		form = TQLocalePrivate::DFDecimal;
+		break;
+	    case 'e':
+		form = TQLocalePrivate::DFExponent;
+		break;
+	    case 'g':
+		form = TQLocalePrivate::DFSignificantDigits;
+		break;
+	    default:
+#if defined(TQT_CHECK_RANGE)
+		qWarning( "TQString::setNum: Invalid format char '%c'", fmt );
+#endif
+		break;
+	}
+
+    	flags |= TQLocalePrivate::ThousandsGroup;
+
+	locale_arg = locale.d->doubleToString(a, prec, form, -1, flags);
+    }
+
+    return tqreplaceArgEscapes(*this, d, fieldWidth, arg, locale_arg);
+}
+
+TQString TQString::tqmultiArg( int numArgs, const TQString& a1, const TQString& a2, const TQString& a3, const TQString& a4 ) const
+{
+    TQString result;
+    union {
+	int digitUsed[10];
+	int argForDigit[10];
+    };
+    register const TQChar *uc = this->tqunicode();
+    const TQString *args[4];
+    const int len = (int) length();
+    const int end = len - 1;
+    int lastDigit = -1;
+    int i;
+
+    memset( digitUsed, 0, sizeof(digitUsed) );
+    args[0] = &a1;
+    args[1] = &a2;
+    args[2] = &a3;
+    args[3] = &a4;
+
+    for ( i = 0; i < end; i++ ) {
+	if ( uc[i] == '%' ) {
+	    int digit = uc[i + 1].tqunicode() - '0';
+	    if ( digit >= 0 && digit <= 9 )
+		digitUsed[digit]++;
+	}
+    }
+
+    for ( i = 0; i < numArgs; i++ ) {
+	do {
+	    ++lastDigit;
+	} while ( lastDigit < 10 && digitUsed[lastDigit] == 0 );
+
+	if ( lastDigit == 10 ) {
+	    qWarning( "TQString::arg(): Argument missing: %s, %s",
+		      latin1(), args[i]->latin1() );
+	    numArgs = i;
+	    lastDigit = 9;
+	    break;
+	}
+	argForDigit[lastDigit] = i;
+    }
+
+    i = 0;
+    while ( i < len ) {
+	if ( uc[i] == '%' && i != end ) {
+	    int digit = uc[i + 1].tqunicode() - '0';
+	    if ( digit >= 0 && digit <= lastDigit ) {
+		result += *args[argForDigit[digit]];
+		i += 2;
+		continue;
+	    }
+	}
+	result += uc[i++];
+    }
+    return result;
+}
+
+TQString &TQString::setAscii( const char *str, int len )
+{
+#ifndef TQT_NO_TEXTCODEC
+    if ( TQTextCodec::codecForCStrings() ) {
+	*this = TQString::fromAscii( str, len );
+	return *this;
+    }
+#endif // TQT_NO_TEXTCODEC
+    return setLatin1( str, len );
+}
+
+TQString &TQString::setLatin1( const char *ch, int len ) {
+	*this = fromLatin1(ch, len); return *this;
+}
+
+bool TQString::simpleText() const {
+	if ( !tqstring_issimpletext ) checkSimpleText();
+	return tqstring_issimpletext;
+}
+
+/*! \internal
+ */
+void TQString::checkSimpleText() const
+{
+    TQChar *p = const_cast<TQChar*>(tqunicode());
+    TQChar *end = p + length();
+    while ( p < end ) {
+	ushort uc = p->tqunicode();
+	// sort out regions of complex text formatting
+	if ( uc > 0x058f && ( uc < 0x1100 || uc > 0xfb0f ) ) {
+	    tqstring_issimpletext = FALSE;
+	    return;
+	}
+	p++;
+    }
+    tqstring_issimpletext = TRUE;
+}
+
+/*!
+    Resizes the string to \a len characters and copies \a
+    tqunicode_as_ushorts into the string (on some X11 client platforms
+    this will involve a byte-swapping pass).
+
+    If \a tqunicode_as_ushorts is 0, nothing is copied, but the string
+    is still resized to \a len. If \a len is zero, the string becomes
+    a \link isNull() null\endlink string.
+
+    \sa setLatin1(), isNull()
+*/
+TQString TQString::setUnicodeCodes( const ushort* tqunicode_as_ushorts, uint len )
+{
+     return TQString(setUnicode((const TQChar*)tqunicode_as_ushorts, len));
+}
+
+#else // USE_QT4
+
+static int ucstrcmp( const TQString &as, const TQString &bs )
+{
+    const TQChar *a = as.tqunicode();
+    const TQChar *b = bs.tqunicode();
+    if ( a == b )
+	return 0;
+    if ( a == 0 )
+	return 1;
+    if ( b == 0 )
+	return -1;
+    int l=TQMIN(as.length(),bs.length());
+    while ( l-- && *a == *b )
+	a++,b++;
+    if ( l==-1 )
+	return ( as.length()-bs.length() );
+    return a->tqunicode() - b->tqunicode();
+}
+
+static int ucstrncmp( const TQChar *a, const TQChar *b, int l )
+{
+    while ( l-- && *a == *b )
+	a++,b++;
+    if ( l==-1 )
+	return 0;
+    return a->tqunicode() - b->tqunicode();
+}
+
+static int ucstrnicmp( const TQChar *a, const TQChar *b, int l )
+{
+    while ( l-- && ::lower( *a ) == ::lower( *b ) )
+	a++,b++;
+    if ( l==-1 )
+	return 0;
+    return ::lower( *a ).tqunicode() - ::lower( *b ).tqunicode();
+}
+
+static uint computeNewMax( uint len )
+{
+    if (len >= 0x80000000)
+        return len;
+
+    uint newMax = 4;
+    while ( newMax < len )
+	newMax *= 2;
+    // try to save some memory
+    if ( newMax >= 1024 * 1024 && len <= newMax - (newMax >> 2) )
+	newMax -= newMax >> 2;
+    return newMax;
+}
+
+static bool qIsUpper(char c)
+{
+    return c >= 'A' && c <= 'Z';
+}
+
+static bool qIsDigit(char c)
+{
+    return c >= '0' && c <= '9';
+}
+
+static char qToLower(char c)
+{
+    if (c >= 'A' && c <= 'Z')
+    	return c - 'A' + 'a';
+    else
+    	return c;
+}
+
+/*!
+    \class TQCharRef tqstring.h
+    \reentrant
+    \brief The TQCharRef class is a helper class for TQString.
+
+    \ingroup text
+
+    When you get an object of type TQCharRef, if you can assign to it,
+    the assignment will apply to the character in the string from
+    which you got the reference. That is its whole purpose in life.
+    The TQCharRef becomes invalid once modifications are made to the
+    string: if you want to keep the character, copy it into a TQChar.
+
+    Most of the TQChar member functions also exist in TQCharRef.
+    However, they are not explicitly documented here.
+
+    \sa TQString::operator[]() TQString::at() TQChar
+*/
+
+/*!
+    \class TQChar tqstring.h
+    \reentrant
+    \brief The TQChar class provides a lightweight Unicode character.
+
+    \ingroup text
+
+    Unicode characters are (so far) 16-bit entities without any markup
+    or structure. This class represents such an entity. It is
+    lightweight, so it can be used everywhere. Most compilers treat it
+    like a "short int".  (In a few years it may be necessary to make
+    TQChar 32-bit when more than 65536 Unicode code points have been
+    defined and come into use.)
+
+    TQChar provides a full complement of testing/classification
+    functions, converting to and from other formats, converting from
+    composed to decomposed Unicode, and trying to compare and
+    case-convert if you ask it to.
+
+    The classification functions include functions like those in
+    ctype.h, but operating on the full range of Unicode characters.
+    They all return TRUE if the character is a certain type of
+    character; otherwise they return FALSE. These classification
+    functions are isNull() (returns TRUE if the character is U+0000),
+    isPrint() (TRUE if the character is any sort of printable
+    character, including whitespace), isPunct() (any sort of
+    punctation), isMark() (Unicode Mark), isLetter (a letter),
+    isNumber() (any sort of numeric character), isLetterOrNumber(),
+    and isDigit() (decimal digits). All of these are wrappers around
+    category() which return the Unicode-defined category of each
+    character.
+
+    TQChar further provides direction(), which indicates the "natural"
+    writing direction of this character. The joining() function
+    indicates how the character joins with its neighbors (needed
+    mostly for Arabic) and finally mirrored(), which indicates whether
+    the character needs to be mirrored when it is printed in its
+    "unnatural" writing direction.
+
+    Composed Unicode characters (like &aring;) can be converted to
+    decomposed Unicode ("a" followed by "ring above") by using
+    decomposition().
+
+    In Unicode, comparison is not necessarily possible and case
+    conversion is very difficult at best. Unicode, covering the
+    "entire" world, also includes most of the world's case and sorting
+    problems. TQt tries, but not very hard: operator==() and friends
+    will do comparison based purely on the numeric Unicode value (code
+    point) of the characters, and upper() and lower() will do case
+    changes when the character has a well-defined upper/lower-case
+    equivalent. There is no provision for locale-dependent case
+    folding rules or comparison; these functions are meant to be fast
+    so they can be used unambiguously in data structures. (See
+    TQString::localeAwareCompare() though.)
+
+    The conversion functions include tqunicode() (to a scalar), latin1()
+    (to scalar, but converts all non-Latin-1 characters to 0), row()
+    (gives the Unicode row), cell() (gives the Unicode cell),
+    digitValue() (gives the integer value of any of the numerous digit
+    characters), and a host of constructors.
+
+    More information can be found in the document \link tqunicode.html
+    About Unicode. \endlink
+
+    \sa TQString TQCharRef
+*/
+
+/*!
+    \enum TQChar::Category
+
+    This enum maps the Unicode character categories.
+
+    The following characters are normative in Unicode:
+
+    \value Mark_NonSpacing  Unicode class name Mn
+
+    \value Mark_SpacingCombining  Unicode class name Mc
+
+    \value Mark_Enclosing  Unicode class name Me
+
+    \value Number_DecimalDigit  Unicode class name Nd
+
+    \value Number_Letter  Unicode class name Nl
+
+    \value Number_Other  Unicode class name No
+
+    \value Separator_Space  Unicode class name Zs
+
+    \value Separator_Line  Unicode class name Zl
+
+    \value Separator_Paragraph  Unicode class name Zp
+
+    \value Other_Control  Unicode class name Cc
+
+    \value Other_Format  Unicode class name Cf
+
+    \value Other_Surrogate  Unicode class name Cs
+
+    \value Other_PrivateUse  Unicode class name Co
+
+    \value Other_NotAssigned  Unicode class name Cn
+
+
+    The following categories are informative in Unicode:
+
+    \value Letter_Uppercase  Unicode class name Lu
+
+    \value Letter_Lowercase  Unicode class name Ll
+
+    \value Letter_Titlecase  Unicode class name Lt
+
+    \value Letter_Modifier  Unicode class name Lm
+
+    \value Letter_Other Unicode class name Lo
+
+    \value Punctuation_Connector  Unicode class name Pc
+
+    \value Punctuation_Dash  Unicode class name Pd
+
+    \value Punctuation_Open  Unicode class name Ps
+
+    \value Punctuation_Close  Unicode class name Pe
+
+    \value Punctuation_InitialQuote  Unicode class name Pi
+
+    \value Punctuation_FinalQuote  Unicode class name Pf
+
+    \value Punctuation_Other  Unicode class name Po
+
+    \value Symbol_Math  Unicode class name Sm
+
+    \value Symbol_Currency  Unicode class name Sc
+
+    \value Symbol_Modifier  Unicode class name Sk
+
+    \value Symbol_Other  Unicode class name So
+
+
+    There are two categories that are specific to TQt:
+
+    \value NoCategory  used when TQt is dazed and confused and cannot
+    make sense of anything.
+
+    \value Punctuation_Dask  old typo alias for Punctuation_Dash
+
+*/
+
+/*!
+    \enum TQChar::Direction
+
+    This enum type defines the Unicode direction attributes. See \link
+    http://www.tqunicode.org/ the Unicode Standard\endlink for a
+    description of the values.
+
+    In order to conform to C/C++ naming conventions "Dir" is prepended
+    to the codes used in the Unicode Standard.
+*/
+
+/*!
+    \enum TQChar::Decomposition
+
+    This enum type defines the Unicode decomposition attributes. See
+    \link http://www.tqunicode.org/ the Unicode Standard\endlink for a
+    description of the values.
+*/
+
+/*!
+    \enum TQChar::Joining
+
+    This enum type defines the Unicode joining attributes. See \link
+    http://www.tqunicode.org/ the Unicode Standard\endlink for a
+    description of the values.
+*/
+
+/*!
+    \enum TQChar::CombiningClass
+
+    This enum type defines names for some of the Unicode combining
+    classes. See \link http://www.tqunicode.org/ the Unicode
+    Standard\endlink for a description of the values.
+*/
+
+/*!
+    \fn void TQChar::setCell( uchar cell )
+    \internal
+*/
+
+/*!
+    \fn void TQChar::setRow( uchar row )
+    \internal
+*/
+
+
+/*!
+    \fn TQChar::TQChar()
+
+    Constructs a null TQChar (one that isNull()).
+*/
+
+
+/*!
+    \fn TQChar::TQChar( char c )
+
+    Constructs a TQChar corresponding to ASCII/Latin-1 character \a c.
+*/
+
+
+/*!
+    \fn TQChar::TQChar( uchar c )
+
+    Constructs a TQChar corresponding to ASCII/Latin-1 character \a c.
+*/
+
+
+/*!
+    \fn TQChar::TQChar( uchar c, uchar r )
+
+    Constructs a TQChar for Unicode cell \a c in row \a r.
+*/
+
+
+/*!
+    \fn TQChar::TQChar( const TQChar& c )
+
+    Constructs a copy of \a c. This is a deep copy, if such a
+    lightweight object can be said to have deep copies.
+*/
+
+
+/*!
+    \fn TQChar::TQChar( ushort rc )
+
+    Constructs a TQChar for the character with Unicode code point \a rc.
+*/
+
+
+/*!
+    \fn TQChar::TQChar( short rc )
+
+    Constructs a TQChar for the character with Unicode code point \a rc.
+*/
+
+
+/*!
+    \fn TQChar::TQChar( uint rc )
+
+    Constructs a TQChar for the character with Unicode code point \a rc.
+*/
+
+
+/*!
+    \fn TQChar::TQChar( int rc )
+
+    Constructs a TQChar for the character with Unicode code point \a rc.
+*/
+
+
+/*!
+    \fn bool  TQChar::networkOrdered ()
+
+    \obsolete
+
+    Returns TRUE if this character is in network byte order (MSB
+    first); otherwise returns FALSE. This is platform dependent.
+*/
+
+
+/*!
+    \fn bool TQChar::isNull() const
+
+    Returns TRUE if the character is the Unicode character 0x0000
+    (ASCII NUL); otherwise returns FALSE.
+*/
+
+/*!
+    \fn uchar TQChar::cell () const
+
+    Returns the cell (least significant byte) of the Unicode
+    character.
+*/
+
+/*!
+    \fn uchar TQChar::row () const
+
+    Returns the row (most significant byte) of the Unicode character.
+*/
+
+/*!
+    Returns TRUE if the character is a printable character; otherwise
+    returns FALSE. This is any character not of category Cc or Cn.
+
+    Note that this gives no indication of whether the character is
+    available in a particular \link TQFont font\endlink.
+*/
+bool TQChar::isPrint() const
+{
+    Category c = ::category( *this );
+    return !(c == Other_Control || c == Other_NotAssigned);
+}
+
+/*!
+    Returns TRUE if the character is a separator character
+    (Separator_* categories); otherwise returns FALSE.
+*/
+bool TQChar::isSpace() const
+{
+    return ::isSpace( *this );
+}
+
+/*!
+    Returns TRUE if the character is a mark (Mark_* categories);
+    otherwise returns FALSE.
+*/
+bool TQChar::isMark() const
+{
+    Category c = ::category( *this );
+    return c >= Mark_NonSpacing && c <= Mark_Enclosing;
+}
+
+/*!
+    Returns TRUE if the character is a punctuation mark (Punctuation_*
+    categories); otherwise returns FALSE.
+*/
+bool TQChar::isPunct() const
+{
+    Category c = ::category( *this );
+    return (c >= Punctuation_Connector && c <= Punctuation_Other);
+}
+
+/*!
+    Returns TRUE if the character is a letter (Letter_* categories);
+    otherwise returns FALSE.
+*/
+bool TQChar::isLetter() const
+{
+    Category c = ::category( *this );
+    return (c >= Letter_Uppercase && c <= Letter_Other);
+}
+
+/*!
+    Returns TRUE if the character is a number (of any sort - Number_*
+    categories); otherwise returns FALSE.
+
+    \sa isDigit()
+*/
+bool TQChar::isNumber() const
+{
+    Category c = ::category( *this );
+    return c >= Number_DecimalDigit && c <= Number_Other;
+}
+
+/*!
+    Returns TRUE if the character is a letter or number (Letter_* or
+    Number_* categories); otherwise returns FALSE.
+*/
+bool TQChar::isLetterOrNumber() const
+{
+    Category c = ::category( *this );
+    return (c >= Letter_Uppercase && c <= Letter_Other)
+	|| (c >= Number_DecimalDigit && c <= Number_Other);
+}
+
+
+/*!
+    Returns TRUE if the character is a decimal digit
+    (Number_DecimalDigit); otherwise returns FALSE.
+*/
+bool TQChar::isDigit() const
+{
+    return (::category( *this ) == Number_DecimalDigit);
+}
+
+
+/*!
+    Returns TRUE if the character is a symbol (Symbol_* categories);
+    otherwise returns FALSE.
+*/
+bool TQChar::isSymbol() const
+{
+    Category c = ::category( *this );
+    return c >= Symbol_Math && c <= Symbol_Other;
+}
+
+/*!
+    Returns the numeric value of the digit, or -1 if the character is
+    not a digit.
+*/
+int TQChar::digitValue() const
+{
+#ifndef TQT_NO_UNICODETABLES
+    register int pos = TQUnicodeTables::decimal_info[row()];
+    if( !pos )
+	return -1;
+    return TQUnicodeTables::decimal_info[(pos<<8) + cell()];
+#else
+    // ##### just latin1
+    if ( ucs < '0' || ucs > '9' )
+	return -1;
+    else
+	return ucs - '0';
+#endif
+}
+
+/*!
+    Returns the character category.
+
+    \sa Category
+*/
+TQChar::Category TQChar::category() const
+{
+     return ::category( *this );
+}
+
+/*!
+    Returns the character's direction.
+
+    \sa Direction
+*/
+TQChar::Direction TQChar::direction() const
+{
+     return ::direction( *this );
+}
+
+/*!
+    \warning This function is not supported (it may change to use
+    Unicode character classes).
+
+    Returns information about the joining properties of the character
+    (needed for example, for Arabic).
+*/
+TQChar::Joining TQChar::joining() const
+{
+    return ::joining( *this );
+}
+
+
+/*!
+    Returns TRUE if the character is a mirrored character (one that
+    should be reversed if the text direction is reversed); otherwise
+    returns FALSE.
+*/
+bool TQChar::mirrored() const
+{
+    return ::mirrored( *this );
+}
+
+/*!
+    Returns the mirrored character if this character is a mirrored
+    character, otherwise returns the character itself.
+*/
+TQChar TQChar::mirroredChar() const
+{
+    return ::mirroredChar( *this );
+}
+
+#ifndef TQT_NO_UNICODETABLES
+// ### REMOVE ME 4.0
+static TQString shared_decomp;
+#endif
+/*!
+    \nonreentrant
+
+    Decomposes a character into its parts. Returns TQString::null if no
+    decomposition exists.
+*/
+const TQString &TQChar::decomposition() const
+{
+#ifndef TQT_NO_UNICODETABLES
+    register int pos = TQUnicodeTables::decomposition_info[row()];
+    if(!pos) return TQString::null;
+
+    pos = TQUnicodeTables::decomposition_info[(pos<<8)+cell()];
+    if(!pos) return TQString::null;
+    pos+=2;
+
+    TQString s;
+    TQ_UINT16 c;
+    while ( (c = TQUnicodeTables::decomposition_map[pos++]) != 0 )
+	s += TQChar( c );
+    // ### In 4.0, return s, and not shared_decomp.  shared_decomp
+    // prevents this function from being reentrant.
+    shared_decomp = s;
+    return shared_decomp;
+#else
+    return TQString::null;
+#endif
+}
+
+/*!
+    Returns the tag defining the composition of the character. Returns
+    TQChar::Single if no decomposition exists.
+*/
+TQChar::Decomposition TQChar::decompositionTag() const
+{
+#ifndef TQT_NO_UNICODETABLES
+    register int pos = TQUnicodeTables::decomposition_info[row()];
+    if(!pos) return TQChar::Single;
+
+    pos = TQUnicodeTables::decomposition_info[(pos<<8)+cell()];
+    if(!pos) return TQChar::Single;
+
+    return (TQChar::Decomposition) TQUnicodeTables::decomposition_map[pos];
+#else
+    return Single; // ########### FIX eg. just latin1
+#endif
+}
+
+/*!
+    Returns the combining class for the character as defined in the
+    Unicode standard. This is mainly useful as a positioning hint for
+    marks attached to a base character.
+
+    The TQt text rendering engine uses this information to correctly
+    position non spacing marks around a base character.
+*/
+unsigned char TQChar::combiningClass() const
+{
+    return ::combiningClass( *this );
+}
+
+
+/*!
+    Returns the lowercase equivalent if the character is uppercase;
+    otherwise returns the character itself.
+*/
+TQChar TQChar::lower() const
+{
+     return ::lower( *this );
+}
+
+/*!
+    Returns the uppercase equivalent if the character is lowercase;
+    otherwise returns the character itself.
+*/
+TQChar TQChar::upper() const
+{
+     return ::upper( *this );
+}
+
+/*!
+    \fn TQChar::operator char() const
+
+    Returns the Latin-1 character equivalent to the TQChar, or 0. This
+    is mainly useful for non-internationalized software.
+
+    \sa tqunicode()
+*/
+
+/*!
+    \fn ushort TQChar::tqunicode() const
+
+    Returns the numeric Unicode value equal to the TQChar. Normally,
+    you should use TQChar objects as they are equivalent, but for some
+    low-level tasks (e.g. indexing into an array of Unicode
+    information), this function is useful.
+*/
+
+/*!
+    \fn ushort & TQChar::tqunicode()
+
+    \overload
+
+    Returns a reference to the numeric Unicode value equal to the
+    TQChar.
+*/
+
+/*****************************************************************************
+  Documentation of TQChar related functions
+ *****************************************************************************/
+
+/*!
+    \fn bool operator==( TQChar c1, TQChar c2 )
+
+    \relates TQChar
+
+    Returns TRUE if \a c1 and \a c2 are the same Unicode character;
+    otherwise returns FALSE.
+*/
+
+/*!
+    \fn bool operator==( char ch, TQChar c )
+
+    \overload
+    \relates TQChar
+
+    Returns TRUE if \a c is the ASCII/Latin-1 character \a ch;
+    otherwise returns FALSE.
+*/
+
+/*!
+    \fn bool operator==( TQChar c, char ch )
+
+    \overload
+    \relates TQChar
+
+    Returns TRUE if \a c is the ASCII/Latin-1 character \a ch;
+    otherwise returns FALSE.
+*/
+
+/*!
+    \fn int operator!=( TQChar c1, TQChar c2 )
+
+    \relates TQChar
+
+    Returns TRUE if \a c1 and \a c2 are not the same Unicode
+    character; otherwise returns FALSE.
+*/
+
+/*!
+    \fn int operator!=( char ch, TQChar c )
+
+    \overload
+    \relates TQChar
+
+    Returns TRUE if \a c is not the ASCII/Latin-1 character \a ch;
+    otherwise returns FALSE.
+*/
+
+/*!
+    \fn int operator!=( TQChar c, char ch )
+
+    \overload
+    \relates TQChar
+
+    Returns TRUE if \a c is not the ASCII/Latin-1 character \a ch;
+    otherwise returns FALSE.
+*/
+
+/*!
+    \fn int operator<=( TQChar c1, TQChar c2 )
+
+    \relates TQChar
+
+    Returns TRUE if the numeric Unicode value of \a c1 is less than
+    that of \a c2, or they are the same Unicode character; otherwise
+    returns FALSE.
+*/
+
+/*!
+    \fn int operator<=( TQChar c, char ch )
+
+    \overload
+    \relates TQChar
+
+    Returns TRUE if the numeric Unicode value of \a c is less than or
+    equal to that of the ASCII/Latin-1 character \a ch; otherwise
+    returns FALSE.
+*/
+
+/*!
+    \fn int operator<=( char ch, TQChar c )
+
+    \overload
+    \relates TQChar
+
+    Returns TRUE if the numeric Unicode value of the ASCII/Latin-1
+    character \a ch is less than or equal to that of \a c; otherwise
+    returns FALSE.
+*/
+
+/*!
+    \fn int operator>=( TQChar c1, TQChar c2 )
+
+    \relates TQChar
+
+    Returns TRUE if the numeric Unicode value of \a c1 is greater than
+    that of \a c2, or they are the same Unicode character; otherwise
+    returns FALSE.
+*/
+
+/*!
+    \fn int operator>=( TQChar c, char ch )
+
+    \overload
+    \relates TQChar
+
+    Returns TRUE if the numeric Unicode value of \a c is greater than
+    or equal to that of the ASCII/Latin-1 character \a ch; otherwise
+    returns FALSE.
+*/
+
+/*!
+    \fn int operator>=( char ch, TQChar c )
+
+    \overload
+    \relates TQChar
+
+    Returns TRUE if the numeric Unicode value of the ASCII/Latin-1
+    character \a ch is greater than or equal to that of \a c;
+    otherwise returns FALSE.
+*/
+
+/*!
+    \fn int operator<( TQChar c1, TQChar c2 )
+
+    \relates TQChar
+
+    Returns TRUE if the numeric Unicode value of \a c1 is less than
+    that of \a c2; otherwise returns FALSE.
+*/
+
+/*!
+    \fn int operator<( TQChar c, char ch )
+
+    \overload
+    \relates TQChar
+
+    Returns TRUE if the numeric Unicode value of \a c is less than that
+    of the ASCII/Latin-1 character \a ch; otherwise returns FALSE.
+*/
+
+/*!
+    \fn int operator<( char ch, TQChar c )
+
+    \overload
+    \relates TQChar
+
+    Returns TRUE if the numeric Unicode value of the ASCII/Latin-1
+    character \a ch is less than that of \a c; otherwise returns
+    FALSE.
+*/
+
+/*!
+    \fn int operator>( TQChar c1, TQChar c2 )
+
+    \relates TQChar
+
+    Returns TRUE if the numeric Unicode value of \a c1 is greater than
+    that of \a c2; otherwise returns FALSE.
+*/
+
+/*!
+    \fn int operator>( TQChar c, char ch )
+
+    \overload
+    \relates TQChar
+
+    Returns TRUE if the numeric Unicode value of \a c is greater than
+    that of the ASCII/Latin-1 character \a ch; otherwise returns FALSE.
+*/
+
+/*!
+    \fn int operator>( char ch, TQChar c )
+
+    \overload
+    \relates TQChar
+
+    Returns TRUE if the numeric Unicode value of the ASCII/Latin-1
+    character \a ch is greater than that of \a c; otherwise returns
+    FALSE.
+*/
+
+#ifndef TQT_NO_UNICODETABLES
+
+// small class used internally in TQString::Compose()
+class TQLigature
+{
+public:
+    TQLigature( TQChar c );
+
+    TQ_UINT16 first() { cur = ligatures; return cur ? *cur : 0; }
+    TQ_UINT16 next() { return cur && *cur ? *(cur++) : 0; }
+    TQ_UINT16 current() { return cur ? *cur : 0; }
+
+    int match(TQString & str, unsigned int index);
+    TQChar head();
+    TQChar::Decomposition tag();
+
+private:
+    TQ_UINT16 *ligatures;
+    TQ_UINT16 *cur;
+};
+
+TQLigature::TQLigature( TQChar c )
+{
+    register int pos = TQUnicodeTables::ligature_info[c.row()];
+    if( !pos )
+	ligatures = 0;
+    else
+    {
+	pos = TQUnicodeTables::ligature_info[(pos<<8)+c.cell()];
+	ligatures = (TQ_UINT16 *)&(TQUnicodeTables::ligature_map[pos]);
+    }
+    cur = ligatures;
+}
+
+TQChar TQLigature::head()
+{
+    if(current())
+	return TQChar(TQUnicodeTables::decomposition_map[current()+1]);
+
+    return TQChar::null;
+}
+
+TQChar::Decomposition TQLigature::tag()
+{
+    if(current())
+	return (TQChar::Decomposition) TQUnicodeTables::decomposition_map[current()];
+
+    return TQChar::Canonical;
+}
+
+int TQLigature::match(TQString & str, unsigned int index)
+{
+    unsigned int i=index;
+
+    if(!current()) return 0;
+
+    TQ_UINT16 lig = current() + 2;
+    TQ_UINT16 ch;
+
+    while ((i < str.length()) && (ch = TQUnicodeTables::decomposition_map[lig])) {
+	if (str[(int)i] != TQChar(ch))
+	    return 0;
+	i++;
+	lig++;
+    }
+
+    if (!TQUnicodeTables::decomposition_map[lig])
+    {
+	return i-index;
+    }
+    return 0;
+}
+
+
+// this function is just used in TQString::compose()
+static inline bool format(TQChar::Decomposition tag, TQString & str,
+			  int index, int len)
+{
+    unsigned int l = index + len;
+    unsigned int r = index;
+
+    bool left = FALSE, right = FALSE;
+
+    left = ((l < str.length()) &&
+	    ((str[(int)l].joining() == TQChar::Dual) ||
+	     (str[(int)l].joining() == TQChar::Right)));
+    if (r > 0) {
+	r--;
+	//printf("joining(right) = %d\n", str[(int)r].joining());
+	right = (str[(int)r].joining() == TQChar::Dual);
+    }
+
+
+    switch (tag) {
+    case TQChar::Medial:
+	return (left & right);
+    case TQChar::Initial:
+	return (left && !right);
+    case TQChar::Final:
+	return (right);// && !left);
+    case TQChar::Isolated:
+    default:
+	return (!right && !left);
+    }
+} // format()
+#endif
+
+/*
+  TQString::compose() and visual() were developed by Gordon Tisher
+  <tisher@uniserve.ca>, with input from Lars Knoll <knoll@mpi-hd.mpg.de>,
+  who developed the tqunicode data tables.
+*/
+/*!
+    \warning This function is not supported in TQt 3.x. It is provided
+    for experimental and illustrative purposes only. It is mainly of
+    interest to those experimenting with Arabic and other
+    composition-rich texts.
+
+    Applies possible ligatures to a TQString. Useful when
+    composition-rich text requires rendering with glyph-poor fonts,
+    but it also makes compositions such as TQChar(0x0041) ('A') and
+    TQChar(0x0308) (Unicode accent diaresis), giving TQChar(0x00c4)
+    (German A Umlaut).
+*/
+void TQString::compose()
+{
+#ifndef TQT_NO_UNICODETABLES
+    unsigned int index=0, len;
+    unsigned int cindex = 0;
+
+    TQChar code, head;
+
+    TQMemArray<TQChar> dia;
+
+    TQString composed = *this;
+
+    while (index < length()) {
+	code = at(index);
+	//printf("\n\nligature for 0x%x:\n", code.tqunicode());
+	TQLigature ligature(code);
+	ligature.first();
+	while ( ligature.current() ) {
+	    if ((len = ligature.match(*this, index)) != 0) {
+		head = ligature.head();
+		unsigned short code = head.tqunicode();
+		// we exclude Arabic presentation forms A and a few
+		// other ligatures, which are undefined in most fonts
+		if(!(code > 0xfb50 && code < 0xfe80) &&
+		   !(code > 0xfb00 && code < 0xfb2a)) {
+				// joining info is only needed for Arabic
+		    if (format(ligature.tag(), *this, index, len)) {
+			//printf("using ligature 0x%x, len=%d\n",code,len);
+			// tqreplace letter
+			composed.tqreplace(cindex, len, TQChar(head));
+			index += len-1;
+			// we continue searching in case we have a final
+			// form because medial ones are preferred.
+			if ( len != 1 || ligature.tag() !=TQChar::Final )
+			    break;
+		    }
+		}
+	    }
+	    ligature.next();
+	}
+	cindex++;
+	index++;
+    }
+    *this = composed;
+#endif
+}
+
+
+// These macros are used for efficient allocation of TQChar strings.
+// IMPORTANT! If you change these, make sure you also change the
+// "delete tqunicode" statement in ~TQStringData() in tqstring.h correspondingly!
+
+#define TQT_ALLOC_TQCHAR_VEC( N ) (TQChar*) new char[ sizeof(TQChar)*( N ) ]
+#define TQT_DELETE_TQCHAR_VEC( P ) delete[] ((char*)( P ))
+
+
+/*!
+    This utility function converts the 8-bit string \a ba to Unicode,
+    returning the result.
+
+    The caller is responsible for deleting the return value with
+    delete[].
+*/
+
+TQChar* TQString::latin1ToUnicode( const TQByteArray& ba, uint* len )
+{
+    if ( ba.isNull() ) {
+	*len = 0;
+	return 0;
+    }
+    int l = 0;
+    while ( l < (int)ba.size() && ba[l] )
+	l++;
+    const char* str = ba.data();
+    TQChar *uc = new TQChar[ l ];   // Can't use macro, since function is public
+    TQChar *result = uc;
+    if ( len )
+	*len = l;
+    while (l--)
+	*uc++ = *str++;
+    return result;
+}
+
+static TQChar* internalLatin1ToUnicode( const TQByteArray& ba, uint* len )
+{
+    if ( ba.isNull() ) {
+	*len = 0;
+	return 0;
+    }
+    int l = 0;
+    while ( l < (int)ba.size() && ba[l] )
+	l++;
+    const char* str = ba.data();
+    TQChar *uc = TQT_ALLOC_TQCHAR_VEC( l );
+    TQChar *result = uc;
+    if ( len )
+	*len = l;
+    while (l--)
+	*uc++ = *str++;
+    return result;
+}
+
+/*!
+    \overload
+
+    This utility function converts the '\0'-terminated 8-bit string \a
+    str to Unicode, returning the result and setting \a *len to the
+    length of the Unicode string.
+
+    The caller is responsible for deleting the return value with
+    delete[].
+*/
+
+TQChar* TQString::latin1ToUnicode( const char *str, uint* len, uint maxlen )
+{
+    TQChar* result = 0;
+    uint l = 0;
+    if ( str ) {
+	if ( maxlen != (uint)-1 ) {
+	    while ( l < maxlen && str[l] )
+		l++;
+	} else {
+	    // Faster?
+	    l = int(strlen( str ));
+	}
+	TQChar *uc = new TQChar[ l ]; // Can't use macro since function is public
+	result = uc;
+	uint i = l;
+	while ( i-- )
+	    *uc++ = *str++;
+    }
+    if ( len )
+	*len = l;
+    return result;
+}
+
+static TQChar* internalLatin1ToUnicode( const char *str, uint* len,
+				      uint maxlen = (uint)-1 )
+{
+    TQChar* result = 0;
+    uint l = 0;
+    if ( str ) {
+	if ( maxlen != (uint)-1 ) {
+	    while ( l < maxlen && str[l] )
+		l++;
+	} else {
+	    // Faster?
+	    l = int(strlen( str ));
+	}
+	TQChar *uc = TQT_ALLOC_TQCHAR_VEC( l );
+	result = uc;
+	uint i = l;
+	while ( i-- )
+	    *uc++ = *str++;
+    }
+    if ( len )
+	*len = l;
+    return result;
+}
+
+/*!
+    This utility function converts \a l 16-bit characters from \a uc
+    to ASCII, returning a '\0'-terminated string.
+
+    The caller is responsible for deleting the resultant string with
+    delete[].
+*/
+char* TQString::tqunicodeToLatin1(const TQChar *uc, uint l)
+{
+    if (!uc) {
+	return 0;
+    }
+    char *a = new char[l+1];
+    char *result = a;
+    while (l--) {
+	*a++ = (uc->tqunicode() > 0xff) ? '?' : (char)uc->tqunicode();
+	uc++;
+    }
+    *a = '\0';
+    return result;
+}
+
+/*****************************************************************************
+  TQString member functions
+ *****************************************************************************/
+
+/*!
+    \class TQString tqstring.h
+    \reentrant
+
+    \brief The TQString class provides an abstraction of Unicode text
+    and the classic C '\0'-terminated char array.
+
+    \ingroup tools
+    \ingroup shared
+    \ingroup text
+    \mainclass
+
+    TQString uses \link shclass.html implicit sharing\endlink, which
+    makes it very efficient and easy to use.
+
+    In all of the TQString methods that take \c {const char *}
+    parameters, the \c {const char *} is interpreted as a classic
+    C-style '\0'-terminated ASCII string. It is legal for the \c
+    {const char *} parameter to be 0. If the \c {const char *} is not
+    '\0'-terminated, the results are undefined. Functions that copy
+    classic C strings into a TQString will not copy the terminating
+    '\0' character. The TQChar array of the TQString (as returned by
+    tqunicode()) is generally not terminated by a '\0'. If you need to
+    pass a TQString to a function that requires a C '\0'-terminated
+    string use latin1().
+
+    \keyword TQString::null
+    A TQString that has not been assigned to anything is \e null, i.e.
+    both the length and data pointer is 0. A TQString that references
+    the empty string ("", a single '\0' char) is \e empty. Both null
+    and empty TQStrings are legal parameters to the methods. Assigning
+    \c{(const char *) 0} to TQString gives a null TQString. For
+    convenience, \c TQString::null is a null TQString. When sorting,
+    empty strings come first, followed by non-empty strings, followed
+    by null strings. We recommend using \c{if ( !str.isNull() )} to
+    check for a non-null string rather than \c{if ( !str )}; see \l
+    operator!() for an explanation.
+
+    Note that if you tqfind that you are mixing usage of \l TQCString,
+    TQString, and \l TQByteArray, this causes lots of unnecessary
+    copying and might indicate that the true nature of the data you
+    are dealing with is uncertain. If the data is '\0'-terminated 8-bit
+    data, use \l TQCString; if it is unterminated (i.e. tqcontains '\0's)
+    8-bit data, use \l TQByteArray; if it is text, use TQString.
+
+    Lists of strings are handled by the TQStringList class. You can
+    split a string into a list of strings using TQStringList::split(),
+    and join a list of strings into a single string with an optional
+    separator using TQStringList::join(). You can obtain a list of
+    strings from a string list that contain a particular substring or
+    that match a particular \link tqregexp.html regex\endlink using
+    TQStringList::grep().
+
+    <b>Note for C programmers</b>
+
+    Due to C++'s type system and the fact that TQString is implicitly
+    shared, TQStrings can be treated like ints or other simple base
+    types. For example:
+
+    \code
+    TQString boolToString( bool b )
+    {
+	TQString result;
+	if ( b )
+	    result = "True";
+	else
+	    result = "False";
+	return result;
+    }
+    \endcode
+
+    The variable, result, is an auto variable allocated on the stack.
+    When return is called, because we're returning by value, The copy
+    constructor is called and a copy of the string is returned. (No
+    actual copying takes place thanks to the implicit sharing, see
+    below.)
+
+    Throughout TQt's source code you will encounter TQString usages like
+    this:
+    \code
+    TQString func( const TQString& input )
+    {
+	TQString output = input;
+	// process output
+	return output;
+    }
+    \endcode
+
+    The 'copying' of input to output is almost as fast as copying a
+    pointer because behind the scenes copying is achieved by
+    incrementing a reference count. TQString (like all TQt's implicitly
+    shared classes) operates on a copy-on-write basis, only copying if
+    an instance is actually changed.
+
+    If you wish to create a deep copy of a TQString without losing any
+    Unicode information then you should use TQDeepCopy.
+
+    \sa TQChar TQCString TQByteArray TQConstString
+*/
+
+/*! \enum TQt::ComparisonFlags
+\internal
+*/
+/*!
+    \enum TQt::StringComparisonMode
+
+    This enum type is used to set the string comparison mode when
+    searching for an item. It is used by TQListBox, TQListView and
+    TQIconView, for example. We'll refer to the string being searched
+    as the 'target' string.
+
+    \value CaseSensitive The strings must match case sensitively.
+    \value ExactMatch The target and search strings must match exactly.
+    \value BeginsWith The target string begins with the search string.
+    \value EndsWith The target string ends with the search string.
+    \value Contains The target string tqcontains the search string.
+
+    If you OR these flags together (excluding \c CaseSensitive), the
+    search criteria be applied in the following order: \c ExactMatch,
+    \c BeginsWith, \c EndsWith, \c Contains.
+
+    Matching is case-insensitive unless \c CaseSensitive is set. \c
+    CaseSensitive can be OR-ed with any combination of the other
+    flags.
+
+*/
+TQ_EXPORT TQStringData *TQString::shared_null = 0;
+TQT_STATIC_CONST_IMPL TQString TQString::null;
+TQT_STATIC_CONST_IMPL TQChar TQChar::null;
+TQT_STATIC_CONST_IMPL TQChar TQChar::tqreplacement((ushort)0xfffd);
+TQT_STATIC_CONST_IMPL TQChar TQChar::byteOrderMark((ushort)0xfeff);
+TQT_STATIC_CONST_IMPL TQChar TQChar::byteOrderSwapped((ushort)0xfffe);
+TQT_STATIC_CONST_IMPL TQChar TQChar::nbsp((ushort)0x00a0);
+
+TQStringData* TQString::makeSharedNull()
+{
+    TQString::shared_null = new TQStringData;
+#if defined( TQ_OS_MAC ) || defined(TQ_OS_SOLARIS) || defined(TQ_OS_HPUX) || defined(TQ_OS_AIX)
+    TQString *that = const_cast<TQString *>(&TQString::null);
+    that->d = TQString::shared_null;
+#endif
+    return TQString::shared_null;
+}
+
+/*!
+    \fn TQString::TQString()
+
+    Constructs a null string, i.e. both the length and data pointer
+    are 0.
+
+    \sa isNull()
+*/
+
+/*!
+    Constructs a string of length one, containing the character \a ch.
+*/
+TQString::TQString( TQChar ch )
+{
+    d = new TQStringData( TQT_ALLOC_TQCHAR_VEC( 1 ), 1, 1 );
+    d->tqunicode[0] = ch;
+}
+
+/*!
+    Constructs an implicitly shared copy of \a s. This is very fast
+    since it only involves incrementing a reference count.
+*/
+TQString::TQString( const TQString &s ) :
+    d(s.d)
+{
+    d->ref();
+}
+
+#ifdef USE_QT4
+
+// Interoperability
+// FIXME
+// These conversions are probably too weak
+
+/*!
+    QT4 INTEROPERABILITY
+*/
+TQString::TQString( const QString &qs )
+{
+	setAscii( TQString(qs).ascii() );
+}
+
+/*!
+    QT4 INTEROPERABILITY
+*/
+TQString::operator QString() const
+{
+	return QString::fromUtf8( this->utf8() );
+}
+
+/*!
+    QT4 INTEROPERABILITY
+*/
+TQString &TQString::operator=( const QString &qs )
+{
+	return setAscii( TQString(qs).ascii() );
+}
+
+bool operator==( const QString &s1, const TQString &s2 )
+{
+	return (TQString(s1).ascii() == s2.ascii());
+}
+
+#endif // USE_QT4
+
+/*!
+  \internal
+
+  Private function.
+
+  Constructs a string with preallocated space for \a size characters.
+
+  The string is empty.
+
+  \sa isNull()
+*/
+
+TQString::TQString( int size, bool /*dummy*/ )
+{
+    if ( size ) {
+	int l = size;
+	TQChar* uc = TQT_ALLOC_TQCHAR_VEC( l );
+	d = new TQStringData( uc, 0, l );
+    } else {
+	d = shared_null ? shared_null : (shared_null=new TQStringData);
+	d->ref();
+    }
+}
+
+/*!
+    Constructs a string that is a deep copy of \a ba interpreted as a
+    classic C string.
+*/
+
+TQString::TQString( const TQByteArray& ba )
+{
+#ifndef TQT_NO_TEXTCODEC
+    if ( TQTextCodec::codecForCStrings() ) {
+	d = 0;
+	*this = fromAscii( ba.data(), ba.size() );
+	return;
+    }
+#endif
+    uint l;
+    TQChar *uc = internalLatin1ToUnicode(ba,&l);
+    d = new TQStringData(uc,l,l);
+}
+
+/*!
+    Constructs a string that is a deep copy of the first \a length
+    characters in the TQChar array.
+
+    If \a tqunicode and \a length are 0, then a null string is created.
+
+    If only \a tqunicode is 0, the string is empty but has \a length
+    characters of space preallocated: TQString expands automatically
+    anyway, but this may speed up some cases a little. We recommend
+    using the plain constructor and setLength() for this purpose since
+    it will result in more readable code.
+
+    \sa isNull() setLength()
+*/
+
+TQString::TQString( const TQChar* tqunicode, uint length )
+{
+    if ( !tqunicode && !length ) {
+	d = shared_null ? shared_null : makeSharedNull();
+	d->ref();
+    } else {
+	TQChar* uc = TQT_ALLOC_TQCHAR_VEC( length );
+	if ( tqunicode )
+	    memcpy(uc, tqunicode, length*sizeof(TQChar));
+	d = new TQStringData(uc,tqunicode ? length : 0,length);
+    }
+}
+
+/*!
+    Constructs a string that is a deep copy of \a str, interpreted as
+    a classic C string. The encoding is assumed to be Latin-1, unless
+    you change it using TQTextCodec::setCodecForCStrings().
+
+    If \a str is 0, then a null string is created.
+
+    This is a cast constructor, but it is perfectly safe: converting a
+    Latin-1 \c{const char *} to TQString preserves all the information. You
+    can disable this constructor by defining \c TQT_NO_CAST_ASCII when
+    you compile your applications. You can also make TQString objects
+    by using setLatin1(), tqfromLatin1(), fromLocal8Bit(), and
+    fromUtf8(). Or whatever encoding is appropriate for the 8-bit data
+    you have.
+
+    \sa isNull(), fromAscii()
+*/
+
+TQString::TQString( const char *str )
+{
+#ifndef TQT_NO_TEXTCODEC
+    if ( TQTextCodec::codecForCStrings() ) {
+	d = 0;
+	*this = fromAscii( str );
+	return;
+    }
+#endif
+    uint l;
+    TQChar *uc = internalLatin1ToUnicode(str,&l);
+    d = new TQStringData(uc,l,l);
+}
+
+#ifndef TQT_NO_STL
+/*!
+    Constructs a string that is a deep copy of \a str.
+
+    This is the same as fromAscii(\a str).
+*/
+
+TQString::TQString( const std::string &str )
+{
+#ifndef TQT_NO_TEXTCODEC
+    if ( TQTextCodec::codecForCStrings() ) {
+	d = 0;
+	*this = fromAscii( str.c_str() );
+	return;
+    }
+#endif
+    uint l;
+    TQChar *uc = internalLatin1ToUnicode(str.c_str(),&l);
+    d = new TQStringData(uc,l,l);
+}
+#endif
+
+/*!
+    \fn TQString::~TQString()
+
+    Destroys the string and frees the string's data if this is the
+    last reference to the string.
+*/
+
+
+/*!
+    Deallocates any space reserved solely by this TQString.
+
+    If the string does not share its data with another TQString
+    instance, nothing happens; otherwise the function creates a new,
+    unique copy of this string. This function is called whenever the
+    string is modified.
+*/
+
+void TQString::real_detach()
+{
+    setLength( length() );
+}
+
+void TQString::deref()
+{
+    if ( d && d->deref() ) {
+	if ( d != shared_null )
+	    delete d;
+	d = 0;
+    }
+}
+
+void TQStringData::deleteSelf()
+{
+    delete this;
+}
+
+/*!
+    \fn TQString& TQString::operator=( TQChar c )
+
+    Sets the string to contain just the single character \a c.
+*/
+
+/*!
+    \fn TQString& TQString::operator=( const std::string& s )
+
+    \overload
+
+    Makes a deep copy of \a s and returns a reference to the deep
+    copy.
+*/
+
+/*!
+    \fn TQString& TQString::operator=( char c )
+
+    \overload
+
+    Sets the string to contain just the single character \a c.
+*/
+
+/*!
+    \overload
+
+    Assigns a shallow copy of \a s to this string and returns a
+    reference to this string. This is very fast because the string
+    isn't actually copied.
+*/
+TQString &TQString::operator=( const TQString &s )
+{
+    s.d->ref();
+    deref();
+    d = s.d;
+    return *this;
+}
+
+/*!
+    \overload
+
+    Assigns a deep copy of \a cstr, interpreted as a classic C
+    string, to this string. Returns a reference to this string.
+*/
+TQString &TQString::operator=( const TQCString& cstr )
+{
+    return setAscii( cstr );
+}
+
+
+/*!
+    \overload
+
+    Assigns a deep copy of \a str, interpreted as a classic C string
+    to this string and returns a reference to this string.
+
+    If \a str is 0, then a null string is created.
+
+    \sa isNull()
+*/
+TQString &TQString::operator=( const char *str )
+{
+    return setAscii(str);
+}
+
+
+/*!
+    \fn bool TQString::isNull() const
+
+    Returns TRUE if the string is null; otherwise returns FALSE. A
+    null string is always empty.
+
+    \code
+	TQString a;          // a.tqunicode() == 0, a.length() == 0
+	a.isNull();         // TRUE, because a.tqunicode() == 0
+	a.isEmpty();        // TRUE, because a.length() == 0
+    \endcode
+
+    \sa isEmpty(), length()
+*/
+
+/*!
+    \fn bool TQString::isEmpty() const
+
+    Returns TRUE if the string is empty, i.e. if length() == 0;
+    otherwise returns FALSE. Null strings are also empty.
+
+    \code
+	TQString a( "" );
+	a.isEmpty();        // TRUE
+	a.isNull();         // FALSE
+
+	TQString b;
+	b.isEmpty();        // TRUE
+	b.isNull();         // TRUE
+    \endcode
+
+    \sa isNull(), length()
+*/
+
+/*!
+    \fn uint TQString::length() const
+
+    Returns the length of the string.
+
+    Null strings and empty strings have zero length.
+
+    \sa isNull(), isEmpty()
+*/
+
+/*!
+    If \a newLen is less than the length of the string, then the
+    string is truncated at position \a newLen. Otherwise nothing
+    happens.
+
+    \code
+	TQString s = "truncate me";
+	s.truncate( 5 );            // s == "trunc"
+    \endcode
+
+    \sa setLength()
+*/
+
+void TQString::truncate( uint newLen )
+{
+    if ( newLen < d->len )
+	setLength( newLen );
+}
+
+/*!
+    Ensures that at least \a newLen characters are allocated to the
+    string, and sets the length of the string to \a newLen. Any new
+    space allocated tqcontains arbitrary data.
+
+    \sa reserve(), truncate()
+*/
+void TQString::setLength( uint newLen )
+{
+    if ( d->count != 1 || newLen > d->maxl ||
+	 ( newLen * 4 < d->maxl && d->maxl > 4 ) ) {
+	// detach, grow or shrink
+	uint newMax = computeNewMax( newLen );
+	TQChar* nd = TQT_ALLOC_TQCHAR_VEC( newMax );
+	if ( nd ) {
+	    uint len = TQMIN( d->len, newLen );
+	    memcpy( nd, d->tqunicode, sizeof(TQChar) * len );
+	    deref();
+	    d = new TQStringData( nd, newLen, newMax );
+	}
+    } else {
+	d->len = newLen;
+	d->setDirty();
+    }
+}
+
+/*!
+    \fn uint TQString::capacity() const
+
+    Returns the number of characters this string can hold
+    in the allocated memory.
+
+    \sa reserve(), squeeze()
+*/
+
+/*!
+    Ensures that at least \a minCapacity characters are allocated to
+    the string.
+
+    This function is useful for code that needs to build up a long
+    string and wants to avoid repeated reallocation. In this example,
+    we want to add to the string until some condition is true, and
+    we're fairly sure that size is big enough:
+    \code
+	TQString result;
+	int len = 0;
+	result.reserve(maxLen);
+	while (...) {
+	    result[len++] = ...         // fill part of the space
+	}
+	result.squeeze();
+    \endcode
+
+    If \e maxLen is an underestimate, the worst that will happen is
+    that the loop will slow down.
+
+    If it is not possible to allocate enough memory, the string
+    remains unchanged.
+
+    \sa capacity(), squeeze(), setLength()
+*/
+
+void TQString::reserve( uint minCapacity )
+{
+    if ( d->maxl < minCapacity ) {
+	TQChar *nd = TQT_ALLOC_TQCHAR_VEC( minCapacity );
+	if ( nd ) {
+	    uint len = d->len;
+	    if ( len )
+		memcpy( nd, d->tqunicode, sizeof(TQChar) * len );
+	    deref();
+	    d = new TQStringData( nd, len, minCapacity );
+	}
+    }
+}
+
+
+/*!
+    Squeezes the string's capacity to the current content.
+
+    \sa capacity(), reserve()
+*/
+void TQString::squeeze()
+{
+    if ( d->maxl > d->len ) {
+	TQChar *nd = TQT_ALLOC_TQCHAR_VEC( d->len );
+	if ( nd ) {
+	    uint len = d->len;
+	    if ( len )
+		memcpy( nd, d->tqunicode, sizeof(TQChar) * len );
+	    deref();
+	    d = new TQStringData( nd, len, len );
+	}
+    }
+}
+
+/*!
+    \internal
+
+    Like setLength, but doesn't shrink the allocated memory.
+*/
+void TQString::grow( uint newLen )
+{
+    if ( d->count != 1 || newLen > d->maxl ) {
+	setLength( newLen );
+    } else {
+	d->len = newLen;
+	d->setDirty();
+    }
+}
+
+struct ArgEscapeData
+{
+    uint min_escape;	    // lowest escape sequence number
+    uint occurrences;	    // number of occurences of the lowest escape
+    	    	    	    // sequence number
+    uint locale_occurrences; // number of occurences of the lowest escape
+    	    	    	    // sequence number which contain 'L'
+    uint escape_len;	    // total length of escape sequences which will
+    	    	    	    // be tqreplaced
+};
+
+static ArgEscapeData tqfindArgEscapes(const TQString &s)
+{
+    const TQChar *uc_begin = s.tqunicode();
+    const TQChar *uc_end = uc_begin + s.length();
+
+    ArgEscapeData d;
+
+    d.min_escape = 10;
+    d.occurrences = 0;
+    d.escape_len = 0;
+    d.locale_occurrences = 0;
+
+    const TQChar *c = uc_begin;
+    while (c != uc_end) {
+    	while (c != uc_end && c->tqunicode() != '%')
+	    ++c;
+
+	if (c == uc_end || ++c == uc_end)
+	    break;
+
+	bool locale_arg = FALSE;
+    	if (c->tqunicode() == 'L') {
+	    locale_arg = TRUE;
+	    if (++c == uc_end)
+		break;
+	}
+
+    	if (c->tqunicode() < '0' || c->tqunicode() > '9')
+	    continue;
+
+	uint escape = c->tqunicode() - '0';
+    	++c;
+
+    	if (escape > d.min_escape)
+	    continue;
+
+    	if (escape < d.min_escape) {
+	    d.min_escape = escape;
+	    d.occurrences = 0;
+	    d.escape_len = 0;
+	    d.locale_occurrences = 0;
+	}
+
+#if TQT_VERSION < 0x040000
+    	// ### remove preprocessor in TQt 4.0
+	/* Since in TQt < 4.0 only the first instance is tqreplaced,
+	   escape_len should hold the length of only the first escape
+	   sequence */
+    	if (d.occurrences == 0)
+#endif
+    	{
+	    ++d.occurrences;
+    	    if (locale_arg) {
+    	    	++d.locale_occurrences;
+		d.escape_len += 3;
+	    }
+	    else
+		d.escape_len += 2;
+	}
+    }
+
+    return d;
+}
+
+static TQString tqreplaceArgEscapes(const TQString &s, const ArgEscapeData &d, int field_width,
+    	    	    	    	    const TQString &arg, const TQString &larg)
+{
+    const TQChar *uc_begin = s.tqunicode();
+    const TQChar *uc_end = uc_begin + s.length();
+
+    uint abs_field_width = TQABS(field_width);
+    uint result_len = s.length()
+    	    	    	- d.escape_len
+			+ (d.occurrences - d.locale_occurrences)
+			    *TQMAX(abs_field_width, arg.length())
+			+ d.locale_occurrences
+			    *TQMAX(abs_field_width, larg.length());
+
+    TQString result;
+    result.setLength(result_len);
+    TQChar *result_buff = (TQChar*) result.tqunicode();
+
+    TQChar *rc = result_buff;
+    const TQChar *c = uc_begin;
+    uint repl_cnt = 0;
+    while (c != uc_end) {
+    	/* We don't have to check if we run off the end of the string with c,
+	   because as long as d.occurrences > 0 we KNOW there are valid escape
+	   sequences. */
+
+    	const TQChar *text_start = c;
+
+    	while (c->tqunicode() != '%')
+	    ++c;
+
+	const TQChar *escape_start = c++;
+
+	bool locale_arg = FALSE;
+    	if (c->tqunicode() == 'L') {
+	    locale_arg = TRUE;
+	    ++c;
+	}
+
+    	if (c->tqunicode() != '0' + d.min_escape) {
+	    memcpy(rc, text_start, (c - text_start)*sizeof(TQChar));
+	    rc += c - text_start;
+	}
+	else {
+    	    ++c;
+
+	    memcpy(rc, text_start, (escape_start - text_start)*sizeof(TQChar));
+	    rc += escape_start - text_start;
+
+    	    uint pad_chars;
+    	    if (locale_arg)
+	    	pad_chars = TQMAX(abs_field_width, larg.length()) - larg.length();
+	    else
+	    	pad_chars = TQMAX(abs_field_width, arg.length()) - arg.length();
+
+    	    if (field_width > 0) { // left padded
+		for (uint i = 0; i < pad_chars; ++i)
+	    	    (rc++)->tqunicode() = ' ';
+	    }
+
+    	    if (locale_arg) {
+	    	memcpy(rc, larg.tqunicode(), larg.length()*sizeof(TQChar));
+		rc += larg.length();
+	    }
+	    else {
+	    	memcpy(rc, arg.tqunicode(), arg.length()*sizeof(TQChar));
+	    	rc += arg.length();
+	    }
+
+    	    if (field_width < 0) { // right padded
+		for (uint i = 0; i < pad_chars; ++i)
+	    	    (rc++)->tqunicode() = ' ';
+	    }
+
+	    if (++repl_cnt == d.occurrences) {
+		memcpy(rc, c, (uc_end - c)*sizeof(TQChar));
+		rc += uc_end - c;
+		TQ_ASSERT(rc - result_buff == (int)result_len);
+		c = uc_end;
+	    }
+	}
+    }
+
+    return result;
+}
+
+/*!
+    This function will return a string that tqreplaces the lowest
+    numbered occurrence of \c %1, \c %2, ..., \c %9 with \a a.
+
+    The \a fieldWidth value specifies the minimum amount of space that
+    \a a is padded to. A positive value will produce right-aligned
+    text, whereas a negative value will produce left-aligned text.
+
+    The following example shows how we could create a 'status' string
+    when processing a list of files:
+    \code
+    TQString status = TQString( "Processing file %1 of %2: %3" )
+			.arg( i )         // current file's number
+			.arg( total )     // number of files to process
+			.arg( fileName ); // current file's name
+    \endcode
+
+    It is generally fine to use filenames and numbers as we have done
+    in the example above. But note that using arg() to construct
+    natural language sentences does not usually translate well into
+    other languages because sentence structure and word order often
+    differ between languages.
+
+    If there is no place marker (\c %1, \c %2, etc.), a warning
+    message (qWarning()) is output and the result is undefined.
+
+    \warning If any placeholder occurs more than once, the result is undefined.
+
+*/
+TQString TQString::arg( const TQString& a, int fieldWidth ) const
+{
+    ArgEscapeData d = tqfindArgEscapes(*this);
+
+    if (d.occurrences == 0) {
+        qWarning( "TQString::arg(): Argument missing: %s, %s", latin1(),
+                  a.latin1() );
+        return *this;
+    }
+
+    return tqreplaceArgEscapes(*this, d, fieldWidth, a, a);
+}
+
+/*!
+    \fn TQString TQString::arg( const TQString& a1, const TQString& a2 ) const
+
+    \overload
+
+    This is the same as str.arg(\a a1).arg(\a a2), except that
+    the strings are tqreplaced in one pass. This can make a difference
+    if \a a1 tqcontains e.g. \c{%1}:
+
+    \code
+    TQString str( "%1 %2" );
+    str.arg( "Hello", "world" );        // returns "Hello world"
+    str.arg( "Hello" ).arg( "world" );  // returns "Hello world"
+
+    str.arg( "(%1)", "Hello" );           // returns "(%1) Hello"
+    str.arg( "(%1)" ).arg( "Hello" );     // returns "(Hello) %2"
+    \endcode
+*/
+
+/*!
+    \fn TQString TQString::arg( const TQString& a1, const TQString& a2,
+			      const TQString& a3 ) const
+    \overload
+
+    This is the same as calling str.arg(\a a1).arg(\a a2).arg(\a a3),
+    except that the strings are tqreplaced in one pass.
+*/
+
+/*!
+    \fn TQString TQString::arg( const TQString& a1, const TQString& a2,
+			      const TQString& a3, const TQString& a4 ) const
+    \overload
+
+    This is the same as calling
+    str.arg(\a a1).arg(\a a2).arg(\a a3).arg(\a a4),
+    except that the strings are tqreplaced in one pass.
+*/
+
+/*!
+    \overload
+
+    The \a fieldWidth value specifies the minimum amount of space that
+    \a a is padded to. A positive value will produce a right-aligned
+    number, whereas a negative value will produce a left-aligned
+    number.
+
+    \a a is expressed in base \a base, which is 10 by default and must
+    be between 2 and 36.
+
+    The '%' can be followed by an 'L', in which case the sequence is
+    tqreplaced with a localized representation of \a a. The conversion
+    uses the default locale. The default locale is determined from the
+    system's locale settings at application startup. It can be changed
+    using TQLocale::setDefault(). The 'L' flag is ignored if \a base is
+    not 10.
+
+    \code
+	TQString str;
+	str = TQString( "Decimal 63 is %1 in hexadecimal" )
+		.arg( 63, 0, 16 );
+	// str == "Decimal 63 is 3f in hexadecimal"
+
+	TQLocale::setDefault(TQLocale::English, TQLocale::UnitedStates);
+	str = TQString( "%1 %L2 %L3" )
+		.arg( 12345 )
+		.arg( 12345 )
+		.arg( 12345, 0, 16 );
+	// str == "12345 12,345 3039"
+    \endcode
+*/
+TQString TQString::arg( long a, int fieldWidth, int base ) const
+{
+    return arg((TQ_LLONG)a, fieldWidth, base);
+}
+
+/*!
+    \overload
+
+    \a a is expressed in base \a base, which is 10 by default and must
+    be between 2 and 36. If \a base is 10, the '%L' syntax can be used
+    to produce localized strings.
+*/
+TQString TQString::arg( ulong a, int fieldWidth, int base ) const
+{
+    return arg((TQ_ULLONG)a, fieldWidth, base);
+}
+
+/*!
+    \overload
+
+    \a a is expressed in base \a base, which is 10 by default and must
+    be between 2 and 36. If \a base is 10, the '%L' syntax can be used
+    to produce localized strings.
+*/
+TQString TQString::arg( TQ_LLONG a, int fieldWidth, int base ) const
+{
+    ArgEscapeData d = tqfindArgEscapes(*this);
+
+    if (d.occurrences == 0) {
+        qWarning( "TQString::arg(): Argument missing: %s, %lld", latin1(),
+                  a );
+        return *this;
+    }
+
+    TQString arg;
+    if (d.occurrences > d.locale_occurrences)
+    	arg = number(a, base);
+
+    TQString locale_arg;
+    if (d.locale_occurrences > 0) {
+	TQLocale locale;
+	locale_arg = locale.d->longLongToString(a, -1, base, -1, TQLocalePrivate::ThousandsGroup);
+    }
+
+    return tqreplaceArgEscapes(*this, d, fieldWidth, arg, locale_arg);
+}
+
+/*!
+    \overload
+
+    \a a is expressed in base \a base, which is 10 by default and must
+    be between 2 and 36. If \a base is 10, the '%L' syntax can be used
+    to produce localized strings.
+*/
+TQString TQString::arg( TQ_ULLONG a, int fieldWidth, int base ) const
+{
+    ArgEscapeData d = tqfindArgEscapes(*this);
+
+    if (d.occurrences == 0) {
+        qWarning( "TQString::arg(): Argument missing: %s, %llu", latin1(),
+                  a );
+        return *this;
+    }
+
+    TQString arg;
+    if (d.occurrences > d.locale_occurrences)
+    	arg = number(a, base);
+
+    TQString locale_arg;
+    if (d.locale_occurrences > 0) {
+	TQLocale locale;
+	locale_arg = locale.d->unsLongLongToString(a, -1, base, -1, TQLocalePrivate::ThousandsGroup);
+    }
+
+    return tqreplaceArgEscapes(*this, d, fieldWidth, arg, locale_arg);
+}
+
+/*!
+    \fn TQString TQString::arg( int a, int fieldWidth, int base ) const
+
+    \overload
+
+    \a a is expressed in base \a base, which is 10 by default and must
+    be between 2 and 36. If \a base is 10, the '%L' syntax can be used
+    to produce localized strings.
+*/
+
+/*!
+    \fn TQString TQString::arg( uint a, int fieldWidth, int base ) const
+
+    \overload
+
+    \a a is expressed in base \a base, which is 10 by default and must
+    be between 2 and 36. If \a base is 10, the '%L' syntax can be used
+    to produce localized strings.
+*/
+
+/*!
+    \fn TQString TQString::arg( short a, int fieldWidth, int base ) const
+
+    \overload
+
+    \a a is expressed in base \a base, which is 10 by default and must
+    be between 2 and 36. If \a base is 10, the '%L' syntax can be used
+    to produce localized strings.
+*/
+
+/*!
+    \fn TQString TQString::arg( ushort a, int fieldWidth, int base ) const
+
+    \overload
+
+    \a a is expressed in base \a base, which is 10 by default and must
+    be between 2 and 36. If \a base is 10, the '%L' syntax can be used
+    to produce localized strings.
+*/
+
+
+/*!
+    \overload
+
+    \a a is assumed to be in the Latin-1 character set.
+*/
+TQString TQString::arg( char a, int fieldWidth ) const
+{
+    TQString c;
+    c += a;
+    return arg( c, fieldWidth );
+}
+
+/*!
+    \overload
+*/
+TQString TQString::arg( TQChar a, int fieldWidth ) const
+{
+    TQString c;
+    c += a;
+    return arg( c, fieldWidth );
+}
+
+/*!
+    \overload
+
+    \target arg-formats
+
+    Argument \a a is formatted according to the \a fmt format specified,
+    which is 'g' by default and can be any of the following:
+
+    \table
+    \header \i Format \i Meaning
+    \row \i \c e \i format as [-]9.9e[+|-]999
+    \row \i \c E \i format as [-]9.9E[+|-]999
+    \row \i \c f \i format as [-]9.9
+    \row \i \c g \i use \c e or \c f format, whichever is the most concise
+    \row \i \c G \i use \c E or \c f format, whichever is the most concise
+    \endtable
+
+    With 'e', 'E', and 'f', \a prec is the number of digits after the
+    decimal point. With 'g' and 'G', \a prec is the maximum number of
+    significant digits (trailing zeroes are omitted).
+
+    \code
+        double d = 12.34;
+        TQString ds = TQString( "'E' format, precision 3, gives %1" )
+                        .arg( d, 0, 'E', 3 );
+        // ds == "'E' format, precision 3, gives 1.234E+01"
+    \endcode
+
+    The '%L' syntax can be used to produce localized strings.
+*/
+TQString TQString::arg( double a, int fieldWidth, char fmt, int prec ) const
+{
+    ArgEscapeData d = tqfindArgEscapes(*this);
+
+    if (d.occurrences == 0) {
+        qWarning( "TQString::arg(): Argument missing: %s, %g", latin1(),
+                  a );
+        return *this;
+    }
+
+    TQString arg;
+    if (d.occurrences > d.locale_occurrences)
+    	arg = number(a, fmt, prec);
+
+    TQString locale_arg;
+    if (d.locale_occurrences > 0) {
+	TQLocale locale;
+
+	TQLocalePrivate::DoubleForm form = TQLocalePrivate::DFDecimal;
+	uint flags = 0;
+
+	if (qIsUpper(fmt))
+    	    flags = TQLocalePrivate::CapitalEorX;
+	fmt = qToLower(fmt);
+
+	switch (fmt) {
+	    case 'f':
+		form = TQLocalePrivate::DFDecimal;
+		break;
+	    case 'e':
+		form = TQLocalePrivate::DFExponent;
+		break;
+	    case 'g':
+		form = TQLocalePrivate::DFSignificantDigits;
+		break;
+	    default:
+#if defined(TQT_CHECK_RANGE)
+		qWarning( "TQString::setNum: Invalid format char '%c'", fmt );
+#endif
+		break;
+	}
+
+    	flags |= TQLocalePrivate::ThousandsGroup;
+
+	locale_arg = locale.d->doubleToString(a, prec, form, -1, flags);
+    }
+
+    return tqreplaceArgEscapes(*this, d, fieldWidth, arg, locale_arg);
+}
+
+TQString TQString::multiArg( int numArgs, const TQString& a1, const TQString& a2,
+			   const TQString& a3, const TQString& a4 ) const
+{
+    TQString result;
+    union {
+	int digitUsed[10];
+	int argForDigit[10];
+    };
+    register const TQChar *uc = d->tqunicode;
+    const TQString *args[4];
+    const int len = (int) length();
+    const int end = len - 1;
+    int lastDigit = -1;
+    int i;
+
+    memset( digitUsed, 0, sizeof(digitUsed) );
+    args[0] = &a1;
+    args[1] = &a2;
+    args[2] = &a3;
+    args[3] = &a4;
+
+    for ( i = 0; i < end; i++ ) {
+	if ( uc[i] == '%' ) {
+	    int digit = uc[i + 1].tqunicode() - '0';
+	    if ( digit >= 0 && digit <= 9 )
+		digitUsed[digit]++;
+	}
+    }
+
+    for ( i = 0; i < numArgs; i++ ) {
+	do {
+	    ++lastDigit;
+	} while ( lastDigit < 10 && digitUsed[lastDigit] == 0 );
+
+	if ( lastDigit == 10 ) {
+	    qWarning( "TQString::arg(): Argument missing: %s, %s",
+		      latin1(), args[i]->latin1() );
+	    numArgs = i;
+	    lastDigit = 9;
+	    break;
+	}
+	argForDigit[lastDigit] = i;
+    }
+
+    i = 0;
+    while ( i < len ) {
+	if ( uc[i] == '%' && i != end ) {
+	    int digit = uc[i + 1].tqunicode() - '0';
+	    if ( digit >= 0 && digit <= lastDigit ) {
+		result += *args[argForDigit[digit]];
+		i += 2;
+		continue;
+	    }
+	}
+	result += uc[i++];
+    }
+    return result;
+}
+
+
+/*!
+    Safely builds a formatted string from the format string \a cformat
+    and an arbitrary list of arguments. The format string supports all
+    the escape sequences of printf() in the standard C library.
+
+    The %s escape sequence expects a utf8() encoded string. The format
+    string \e cformat is expected to be in latin1. If you need a
+    Unicode format string, use arg() instead. For typesafe string
+    building, with full Unicode support, you can use TQTextOStream like
+    this:
+
+    \code
+	TQString str;
+	TQString s = ...;
+	int x = ...;
+	TQTextOStream( &str ) << s << " : " << x;
+    \endcode
+
+    For \link TQObject::tr() translations,\endlink especially if the
+    strings tqcontains more than one escape sequence, you should
+    consider using the arg() function instead. This allows the order
+    of the tqreplacements to be controlled by the translator, and has
+    Unicode support.
+
+    The %lc escape sequence expects a tqunicode character of type ushort
+    (as returned by TQChar::tqunicode()).
+    The %ls escape sequence expects a pointer to a zero-terminated
+    array of tqunicode characters of type ushort (as returned by
+    TQString::ucs2()).
+
+    \sa arg()
+*/
+
+#ifndef TQT_NO_SPRINTF
+TQString &TQString::sprintf( const char* cformat, ... )
+{
+    TQLocale locale(TQLocale::C);
+
+    va_list ap;
+    va_start( ap, cformat );
+
+    if ( !cformat || !*cformat ) {
+	// TQt 1.x compat
+	*this = tqfromLatin1( "" );
+	return *this;
+    }
+
+    // Parse cformat
+
+    TQString result;
+    const char *c = cformat;
+    for (;;) {
+    	// Copy non-escape chars to result
+    	while (*c != '\0' && *c != '%')
+	    result.append(*c++);
+
+	if (*c == '\0')
+	    break;
+
+	// Found '%'
+	const char *escape_start = c;
+	++c;
+
+	if (*c == '\0') {
+	    result.append('%'); // a % at the end of the string - treat as non-escape text
+	    break;
+	}
+    	if (*c == '%') {
+	    result.append('%'); // %%
+	    ++c;
+	    continue;
+	}
+
+	// Parse flag characters
+	unsigned flags = 0;
+	bool no_more_flags = FALSE;
+	do {
+	    switch (*c) {
+		case '#': flags |= TQLocalePrivate::Alternate; break;
+		case '0': flags |= TQLocalePrivate::ZeroPadded; break;
+		case '-': flags |= TQLocalePrivate::LeftAdjusted; break;
+		case ' ': flags |= TQLocalePrivate::BlankBeforePositive; break;
+		case '+': flags |= TQLocalePrivate::AlwaysShowSign; break;
+		case '\'': flags |= TQLocalePrivate::ThousandsGroup; break;
+		default: no_more_flags = TRUE; break;
+    	    }
+
+	    if (!no_more_flags)
+	    	++c;
+	} while (!no_more_flags);
+
+	if (*c == '\0') {
+	    result.append(escape_start); // incomplete escape, treat as non-escape text
+	    break;
+	}
+
+	// Parse field width
+	int width = -1; // -1 means unspecified
+	if (qIsDigit(*c)) {
+	    TQString width_str;
+	    while (*c != '\0' && qIsDigit(*c))
+	    	width_str.append(*c++);
+
+	    // can't be negative - started with a digit
+    	    // tqcontains at least one digit
+	    width = width_str.toInt();
+	}
+	else if (*c == '*') {
+	    width = va_arg(ap, int);
+	    if (width < 0)
+	    	width = -1; // treat all negative numbers as unspecified
+	    ++c;
+	}
+
+	if (*c == '\0') {
+	    result.append(escape_start); // incomplete escape, treat as non-escape text
+	    break;
+	}
+
+	// Parse precision
+	int precision = -1; // -1 means unspecified
+	if (*c == '.') {
+	    ++c;
+	    if (qIsDigit(*c)) {
+		TQString precision_str;
+		while (*c != '\0' && qIsDigit(*c))
+	    	    precision_str.append(*c++);
+
+		// can't be negative - started with a digit
+    	    	// tqcontains at least one digit
+		precision = precision_str.toInt();
+	    }
+	    else if (*c == '*') {
+		precision = va_arg(ap, int);
+		if (precision < 0)
+	    	    precision = -1; // treat all negative numbers as unspecified
+		++c;
+	    }
+	}
+
+	if (*c == '\0') {
+	    result.append(escape_start); // incomplete escape, treat as non-escape text
+	    break;
+	}
+
+    	// Parse the length modifier
+    	enum LengthMod { lm_none, lm_hh, lm_h, lm_l, lm_ll, lm_L, lm_j, lm_z, lm_t };
+	LengthMod length_mod = lm_none;
+	switch (*c) {
+	    case 'h':
+	    	++c;
+		if (*c == 'h') {
+		    length_mod = lm_hh;
+		    ++c;
+		}
+		else
+		    length_mod = lm_h;
+		break;
+
+	    case 'l':
+	    	++c;
+		if (*c == 'l') {
+		    length_mod = lm_ll;
+		    ++c;
+		}
+		else
+		    length_mod = lm_l;
+		break;
+
+	    case 'L':
+	    	++c;
+		length_mod = lm_L;
+		break;
+
+	    case 'j':
+	    	++c;
+		length_mod = lm_j;
+		break;
+
+	    case 'z':
+	    case 'Z':
+	    	++c;
+		length_mod = lm_z;
+		break;
+
+	    case 't':
+	    	++c;
+		length_mod = lm_t;
+		break;
+
+	    default: break;
+	}
+
+	if (*c == '\0') {
+	    result.append(escape_start); // incomplete escape, treat as non-escape text
+	    break;
+	}
+
+	// Parse the conversion specifier and do the conversion
+	TQString subst;
+	switch (*c) {
+	    case 'd':
+	    case 'i': {
+	    	TQ_LLONG i;
+		switch (length_mod) {
+		    case lm_none: i = va_arg(ap, int); break;
+		    case lm_hh: i = va_arg(ap, int); break;
+		    case lm_h: i = va_arg(ap, int); break;
+		    case lm_l: i = va_arg(ap, long int); break;
+		    case lm_ll: i = va_arg(ap, TQ_LLONG); break;
+		    case lm_j: i = va_arg(ap, long int); break;
+		    case lm_z: i = va_arg(ap, size_t); break;
+		    case lm_t: i = va_arg(ap, int); break;
+                    default: i = 0; break;
+		}
+		subst = locale.d->longLongToString(i, precision, 10, width, flags);
+		++c;
+		break;
+    	    }
+	    case 'o':
+	    case 'u':
+	    case 'x':
+	    case 'X': {
+	    	TQ_ULLONG u;
+		switch (length_mod) {
+		    case lm_none: u = va_arg(ap, unsigned int); break;
+		    case lm_hh: u = va_arg(ap, unsigned int); break;
+		    case lm_h: u = va_arg(ap, unsigned int); break;
+		    case lm_l: u = va_arg(ap, unsigned long int); break;
+		    case lm_ll: u = va_arg(ap, TQ_ULLONG); break;
+                    default: u = 0; break;
+		}
+
+		if (qIsUpper(*c))
+		    flags |= TQLocalePrivate::CapitalEorX;
+
+    	    	int base = 10;
+		switch (qToLower(*c)) {
+		    case 'o':
+	    		base = 8; break;
+		    case 'u':
+			base = 10; break;
+		    case 'x':
+			base = 16; break;
+		    default: break;
+		}
+		subst = locale.d->unsLongLongToString(u, precision, base, width, flags);
+		++c;
+		break;
+    	    }
+	    case 'E':
+	    case 'e':
+    	    case 'F':
+	    case 'f':
+	    case 'G':
+	    case 'g':
+	    case 'A':
+	    case 'a': {
+	    	double d;
+		if (length_mod == lm_L)
+		    d = va_arg(ap, long double); // not supported - converted to a double
+		else
+		    d = va_arg(ap, double);
+
+		if (qIsUpper(*c))
+		    flags |= TQLocalePrivate::CapitalEorX;
+
+    	    	TQLocalePrivate::DoubleForm form = TQLocalePrivate::DFDecimal;
+		switch (qToLower(*c)) {
+		    case 'e': form = TQLocalePrivate::DFExponent; break;
+		    case 'a': 	    	    	// not supported - decimal form used instead
+		    case 'f': form = TQLocalePrivate::DFDecimal; break;
+		    case 'g': form = TQLocalePrivate::DFSignificantDigits; break;
+		    default: break;
+		}
+		subst = locale.d->doubleToString(d, precision, form, width, flags);
+		++c;
+		break;
+	    }
+	    case 'c': {
+	    	if (length_mod == lm_l)
+		    subst = TQChar((ushort) va_arg(ap, int));
+    	    	else
+		    subst = (uchar) va_arg(ap, int);
+		++c;
+		break;
+	    }
+	    case 's': {
+	    	if (length_mod == lm_l) {
+		    const ushort *buff = va_arg(ap, const ushort*);
+		    const ushort *ch = buff;
+		    while (*ch != 0)
+		    	++ch;
+		    subst.setUnicodeCodes(buff, ch - buff);
+		} else
+	    	    subst = TQString::fromUtf8(va_arg(ap, const char*));
+		if (precision != -1)
+		    subst.truncate(precision);
+		++c;
+		break;
+	    }
+	    case 'p': {
+		TQ_ULLONG i;
+#ifdef TQ_OS_WIN64
+	    	i = (TQ_ULLONG) va_arg(ap, void*);
+#else
+		i = (TQ_ULONG) va_arg(ap, void*);
+#endif
+
+#ifdef TQ_OS_WIN32
+		flags |= TQLocalePrivate::CapitalEorX; // Windows does 1234ABCD
+#else
+		flags |= TQLocalePrivate::Alternate; // Unix and Mac do 0x1234abcd
+#endif
+
+		subst = locale.d->unsLongLongToString(i, precision, 16, width, flags);
+		++c;
+		break;
+	    }
+	    case 'n':
+	    	switch (length_mod) {
+		    case lm_hh: {
+		    	signed char *n = va_arg(ap, signed char*);
+			*n = result.length();
+			break;
+		    }
+		    case lm_h: {
+		    	short int *n = va_arg(ap, short int*);
+			*n = result.length();
+    	    	    	break;
+		    }
+		    case lm_l: {
+		    	long int *n = va_arg(ap, long int*);
+			*n = result.length();
+			break;
+		    }
+		    case lm_ll: {
+		    	TQ_LLONG *n = va_arg(ap, TQ_LLONG*);
+			volatile uint tmp = result.length(); // egcs-2.91.66 gets internal
+			*n = tmp;			     // compiler error without volatile
+			break;
+		    }
+		    default: {
+		    	int *n = va_arg(ap, int*);
+			*n = result.length();
+			break;
+		    }
+		}
+		++c;
+		break;
+
+	    default: // bad escape, treat as non-escape text
+	    	for (const char *cc = escape_start; cc != c; ++cc)
+		    result.append(*cc);
+		continue;
+	}
+
+	if (flags & TQLocalePrivate::LeftAdjusted)
+	    result.append(subst.leftJustify(width));
+	else
+	    result.append(subst.rightJustify(width));
+    }
+
+    va_end(ap);
+    *this = result;
+
+    return *this;
+}
+#endif
+
+/*!
+    Fills the string with \a len characters of value \a c, and returns
+    a reference to the string.
+
+    If \a len is negative (the default), the current string length is
+    used.
+
+    \code
+	TQString str;
+	str.fill( 'g', 5 );      // string == "ggggg"
+    \endcode
+*/
+
+TQString& TQString::fill( TQChar c, int len )
+{
+    if ( len < 0 )
+	len = length();
+    if ( len == 0 ) {
+	*this = "";
+    } else {
+	deref();
+	TQChar * nd = TQT_ALLOC_TQCHAR_VEC( len );
+	d = new TQStringData(nd,len,len);
+	while (len--) *nd++ = c;
+    }
+    return *this;
+}
+
+
+/*!
+  \fn TQString TQString::copy() const
+
+  \obsolete
+
+  In TQt 2.0 and later, all calls to this function are needless. Just
+  remove them.
+*/
+
+/*!
+    \overload
+
+    Finds the first occurrence of the character \a c, starting at
+    position \a index. If \a index is -1, the search starts at the
+    last character; if -2, at the next to last character and so on.
+    (See tqfindRev() for searching backwards.)
+
+    If \a cs is TRUE (the default), the search is case sensitive;
+    otherwise the search is case insensitive.
+
+    Returns the position of \a c or -1 if \a c could not be found.
+*/
+
+int TQString::tqfind( TQChar c, int index, bool cs ) const
+{
+    const uint l = length();
+    if ( index < 0 )
+	index += l;
+    if ( (uint)index >= l )
+	return -1;
+    register const TQChar *uc = tqunicode()+index;
+    const TQChar *end = tqunicode() + l;
+    if ( cs ) {
+	while ( uc < end && *uc != c )
+	    uc++;
+    } else {
+	c = ::lower( c );
+	while ( uc < end && ::lower( *uc ) != c )
+	    uc++;
+    }
+    if ( uint(uc - tqunicode()) >= l )
+	return -1;
+    return (int)(uc - tqunicode());
+}
+
+/* an implementation of the Boyer-Moore search algorithm
+*/
+
+/* initializes the skiptable to know haw far ahead we can skip on a wrong match
+*/
+static void bm_init_skiptable( const TQString &pattern, uint *skiptable, bool cs )
+{
+    int i = 0;
+    register uint *st = skiptable;
+    int l = pattern.length();
+    while ( i++ < 0x100/8 ) {
+	*(st++) = l;
+	*(st++) = l;
+	*(st++) = l;
+	*(st++) = l;
+	*(st++) = l;
+	*(st++) = l;
+	*(st++) = l;
+	*(st++) = l;
+    }
+    const TQChar *uc = pattern.tqunicode();
+    if ( cs ) {
+	while ( l-- ) {
+	    skiptable[ uc->cell() ] = l;
+	    uc++;
+	}
+    } else {
+	while ( l-- ) {
+	    skiptable[ ::lower( *uc ).cell() ] = l;
+	    uc++;
+	}
+    }
+}
+
+static int bm_tqfind( const TQString &str, int index, const TQString &pattern, uint *skiptable, bool cs )
+{
+    const uint l = str.length();
+    if ( pattern.isEmpty() )
+	return index > (int)l ? -1 : index;
+
+    const TQChar *uc = str.tqunicode();
+    const TQChar *puc = pattern.tqunicode();
+    const uint pl = pattern.length();
+    const uint pl_minus_one = pl - 1;
+
+    register const TQChar *current = uc + index + pl_minus_one;
+    const TQChar *end = uc + l;
+    if ( cs ) {
+	while ( current < end ) {
+	    uint skip = skiptable[ current->cell() ];
+	    if ( !skip ) {
+		// possible match
+		while ( skip < pl ) {
+		    if ( *(current - skip ) != puc[pl_minus_one-skip] )
+			break;
+		    skip++;
+		}
+		if ( skip > pl_minus_one ) { // we have a match
+		    return (current - uc) - skip + 1;
+		}
+		// in case we don't have a match we are a bit inefficient as we only skip by one
+		// when we have the non matching char in the string.
+		if ( skiptable[ (current-skip)->cell() ] == pl )
+		    skip = pl - skip;
+		else
+		    skip = 1;
+	    }
+	    current += skip;
+	}
+    } else {
+	while ( current < end ) {
+	    uint skip = skiptable[ ::lower( *current ).cell() ];
+	    if ( !skip ) {
+		// possible match
+		while ( skip < pl ) {
+		    if ( ::lower( *(current - skip) ) != ::lower( puc[pl_minus_one-skip] ) )
+			break;
+		    skip++;
+		}
+		if ( skip > pl_minus_one ) // we have a match
+		    return (current - uc) - skip + 1;
+		// in case we don't have a match we are a bit inefficient as we only skip by one
+		// when we have the non matching char in the string.
+		if ( skiptable[ ::lower(*(current - skip)).cell() ] == pl )
+		    skip = pl - skip;
+		else
+		    skip = 1;
+	    }
+	    current += skip;
+	}
+    }
+    // not found
+    return -1;
+}
+
+
+#define REHASH( a ) \
+    if ( sl_minus_1 < sizeof(uint) * CHAR_BIT ) \
+	hashHaystack -= (a) << sl_minus_1; \
+    hashHaystack <<= 1
+
+/*!
+    \overload
+
+    Finds the first occurrence of the string \a str, starting at
+    position \a index. If \a index is -1, the search starts at the
+    last character, if it is -2, at the next to last character and so
+    on. (See tqfindRev() for searching backwards.)
+
+    If \a cs is TRUE (the default), the search is case sensitive;
+    otherwise the search is case insensitive.
+
+    Returns the position of \a str or -1 if \a str could not be found.
+*/
+
+int TQString::tqfind( const TQString& str, int index, bool cs ) const
+{
+    const uint l = length();
+    const uint sl = str.length();
+    if ( index < 0 )
+	index += l;
+    if ( sl + index > l )
+	return -1;
+    if ( !sl )
+	return index;
+    if (!l)
+	return -1;
+
+#if defined(TQ_OS_MACX) && defined(TQT_MACOSX_VERSION) && TQT_MACOSX_VERSION >= 0x1020
+    if ( sl == 1 )
+	return tqfind( *str.tqunicode(), index, cs );
+#endif
+
+    // we use the Boyer-Moore algorithm in cases where the overhead
+    // for the hash table should pay off, otherwise we use a simple
+    // hash function
+    if ( l > 500 && sl > 5 ) {
+	uint skiptable[0x100];
+	bm_init_skiptable( str, skiptable, cs );
+	return bm_tqfind( *this, index, str, skiptable, cs );
+    }
+
+    /*
+      We use some hashing for efficiency's sake. Instead of
+      comparing strings, we compare the hash value of str with that of
+      a part of this TQString. Only if that matches, we call ucstrncmp
+      or ucstrnicmp.
+    */
+    const TQChar* needle = str.tqunicode();
+    const TQChar* haystack = tqunicode() + index;
+    const TQChar* end = tqunicode() + (l-sl);
+    const uint sl_minus_1 = sl-1;
+    uint hashNeedle = 0, hashHaystack = 0, i;
+
+    if ( cs ) {
+	for ( i = 0; i < sl; ++i ) {
+	    hashNeedle = ((hashNeedle<<1) + needle[i].tqunicode() );
+	    hashHaystack = ((hashHaystack<<1) + haystack[i].tqunicode() );
+	}
+	hashHaystack -= (haystack+sl_minus_1)->tqunicode();
+
+	while ( haystack <= end ) {
+	    hashHaystack += (haystack+sl_minus_1)->tqunicode();
+ 	    if ( hashHaystack == hashNeedle
+		 && ucstrncmp( needle, haystack, sl ) == 0 )
+		return haystack-tqunicode();
+
+	    REHASH( haystack->tqunicode() );
+	    ++haystack;
+	}
+    } else {
+	for ( i = 0; i < sl; ++i ) {
+	    hashNeedle = ((hashNeedle<<1) +
+			  ::lower( needle[i].tqunicode() ).tqunicode() );
+	    hashHaystack = ((hashHaystack<<1) +
+			    ::lower( haystack[i].tqunicode() ).tqunicode() );
+	}
+
+	hashHaystack -= ::lower(*(haystack+sl_minus_1)).tqunicode();
+	while ( haystack <= end ) {
+	    hashHaystack += ::lower(*(haystack+sl_minus_1)).tqunicode();
+	    if ( hashHaystack == hashNeedle
+		 && ucstrnicmp( needle, haystack, sl ) == 0 )
+		return haystack-tqunicode();
+
+	    REHASH( ::lower(*haystack).tqunicode() );
+	    ++haystack;
+	}
+    }
+    return -1;
+}
+
+/*!
+    \fn int TQString::tqfindRev( const char* str, int index ) const
+
+    Equivalent to tqfindRev(TQString(\a str), \a index).
+*/
+
+/*!
+    \fn int TQString::tqfind( const char* str, int index ) const
+
+    \overload
+
+    Equivalent to tqfind(TQString(\a str), \a index).
+*/
+
+/*!
+    \overload
+
+    Finds the first occurrence of the character \a c, starting at
+    position \a index and searching backwards. If the index is -1, the
+    search starts at the last character, if it is -2, at the next to
+    last character and so on.
+
+    Returns the position of \a c or -1 if \a c could not be found.
+
+    If \a cs is TRUE (the default), the search is case sensitive;
+    otherwise the search is case insensitive.
+
+    \code
+	TQString string( "bananas" );
+	int i = string.tqfindRev( 'a' );      // i == 5
+    \endcode
+*/
+
+int TQString::tqfindRev( TQChar c, int index, bool cs ) const
+{
+#if defined(TQ_OS_MACX) && defined(TQT_MACOSX_VERSION) && TQT_MACOSX_VERSION < 0x1020
+    return tqfindRev( TQString( c ), index, cs );
+#else
+    const uint l = length();
+    if ( index < 0 )
+	index += l;
+    if ( (uint)index >= l )
+	return -1;
+    const TQChar *end = tqunicode();
+    register const TQChar *uc = end + index;
+    if ( cs ) {
+	while ( uc >= end && *uc != c )
+	    uc--;
+    } else {
+	c = ::lower( c );
+	while ( uc >= end && ::lower( *uc ) != c )
+	    uc--;
+    }
+    return uc - end;
+#endif
+}
+
+/*!
+    \overload
+
+    Finds the first occurrence of the string \a str, starting at
+    position \a index and searching backwards. If the index is -1, the
+    search starts at the last character, if it is -2, at the next to
+    last character and so on.
+
+    Returns the position of \a str or -1 if \a str could not be found.
+
+    If \a cs is TRUE (the default), the search is case sensitive;
+    otherwise the search is case insensitive.
+
+    \code
+    TQString string("bananas");
+    int i = string.tqfindRev( "ana" );      // i == 3
+    \endcode
+*/
+
+int TQString::tqfindRev( const TQString& str, int index, bool cs ) const
+{
+    /*
+      See TQString::tqfind() for explanations.
+    */
+    const uint l = length();
+    if ( index < 0 )
+	index += l;
+    const uint sl = str.length();
+    int delta = l-sl;
+    if ( index < 0 || index > (int)l || delta < 0 )
+	return -1;
+    if ( index > delta )
+	index = delta;
+
+#if defined(TQ_OS_MACX) && defined(TQT_MACOSX_VERSION) && TQT_MACOSX_VERSION >= 0x1020
+    if ( sl == 1 )
+	return tqfindRev( *str.tqunicode(), index, cs );
+#endif
+
+    const TQChar* needle = str.tqunicode();
+    const TQChar* haystack = tqunicode() + index;
+    const TQChar* end = tqunicode();
+    const uint sl_minus_1 = sl-1;
+    const TQChar* n = needle+sl_minus_1;
+    const TQChar* h = haystack+sl_minus_1;
+    uint hashNeedle = 0, hashHaystack = 0, i;
+
+    if ( cs ) {
+	for ( i = 0; i < sl; ++i ) {
+	    hashNeedle = ((hashNeedle<<1) + (n-i)->tqunicode() );
+	    hashHaystack = ((hashHaystack<<1) + (h-i)->tqunicode() );
+	}
+	hashHaystack -= haystack->tqunicode();
+
+	while ( haystack >= end ) {
+	    hashHaystack += haystack->tqunicode();
+ 	    if ( hashHaystack == hashNeedle
+		 && ucstrncmp( needle, haystack, sl ) == 0 )
+		return haystack-tqunicode();
+	    --haystack;
+	    REHASH( (haystack+sl)->tqunicode() );
+	}
+    } else {
+	for ( i = 0; i < sl; ++i ) {
+	    hashNeedle = ((hashNeedle<<1)
+			  + ::lower( (n-i)->tqunicode() ).tqunicode() );
+	    hashHaystack = ((hashHaystack<<1)
+			    + ::lower( (h-i)->tqunicode() ).tqunicode() );
+	}
+	hashHaystack -= ::lower(*haystack).tqunicode();
+
+	while ( haystack >= end ) {
+	    hashHaystack += ::lower(*haystack).tqunicode();
+	    if ( hashHaystack == hashNeedle
+		 && ucstrnicmp( needle, haystack, sl ) == 0 )
+		return haystack-tqunicode();
+	    --haystack;
+	    REHASH( ::lower(*(haystack+sl)).tqunicode() );
+	}
+    }
+    return -1;
+}
+
+#undef REHASH
+
+/*!
+    \enum TQString::SectionFlags
+
+    \value SectionDefault Empty fields are counted, leading and
+    trailing separators are not included, and the separator is
+    compared case sensitively.
+
+    \value SectionSkipEmpty Treat empty fields as if they don't exist,
+    i.e. they are not considered as far as \e start and \e end are
+    concerned.
+
+    \value SectionIncludeLeadingSep Include the leading separator (if
+    any) in the result string.
+
+    \value SectionIncludeTrailingSep Include the trailing separator
+    (if any) in the result string.
+
+    \value SectionCaseInsensitiveSeps Compare the separator
+    case-insensitively.
+
+    Any of the last four values can be OR-ed together to form a flag.
+
+    \sa section()
+*/
+
+/*!
+    \fn TQString TQString::section( TQChar sep, int start, int end = 0xffffffff, int flags = SectionDefault ) const
+
+    This function returns a section of the string.
+
+    This string is treated as a sequence of fields separated by the
+    character, \a sep. The returned string consists of the fields from
+    position \a start to position \a end inclusive. If \a end is not
+    specified, all fields from position \a start to the end of the
+    string are included. Fields are numbered 0, 1, 2, etc., counting
+    from the left, and -1, -2, etc., counting from right to left.
+
+    The \a flags argument can be used to affect some aspects of the
+    function's behaviour, e.g. whether to be case sensitive, whether
+    to skip empty fields and how to deal with leading and trailing
+    separators; see \l{SectionFlags}.
+
+    \code
+    TQString csv( "forename,middlename,surname,phone" );
+    TQString s = csv.section( ',', 2, 2 );   // s == "surname"
+
+    TQString path( "/usr/local/bin/myapp" ); // First field is empty
+    TQString s = path.section( '/', 3, 4 );  // s == "bin/myapp"
+    TQString s = path.section( '/', 3, 3, SectionSkipEmpty ); // s == "myapp"
+    \endcode
+
+    If \a start or \a end is negative, we count fields from the right
+    of the string, the right-most field being -1, the one from
+    right-most field being -2, and so on.
+
+    \code
+    TQString csv( "forename,middlename,surname,phone" );
+    TQString s = csv.section( ',', -3, -2 );  // s == "middlename,surname"
+
+    TQString path( "/usr/local/bin/myapp" ); // First field is empty
+    TQString s = path.section( '/', -1 ); // s == "myapp"
+    \endcode
+
+    \sa TQStringList::split()
+*/
+
+/*!
+    \overload
+
+    This function returns a section of the string.
+
+    This string is treated as a sequence of fields separated by the
+    string, \a sep. The returned string consists of the fields from
+    position \a start to position \a end inclusive. If \a end is not
+    specified, all fields from position \a start to the end of the
+    string are included. Fields are numbered 0, 1, 2, etc., counting
+    from the left, and -1, -2, etc., counting from right to left.
+
+    The \a flags argument can be used to affect some aspects of the
+    function's behaviour, e.g. whether to be case sensitive, whether
+    to skip empty fields and how to deal with leading and trailing
+    separators; see \l{SectionFlags}.
+
+    \code
+    TQString data( "forename**middlename**surname**phone" );
+    TQString s = data.section( "**", 2, 2 ); // s == "surname"
+    \endcode
+
+    If \a start or \a end is negative, we count fields from the right
+    of the string, the right-most field being -1, the one from
+    right-most field being -2, and so on.
+
+    \code
+    TQString data( "forename**middlename**surname**phone" );
+    TQString s = data.section( "**", -3, -2 ); // s == "middlename**surname"
+    \endcode
+
+    \sa TQStringList::split()
+*/
+
+TQString TQString::section( const TQString &sep, int start, int end, int flags ) const
+{
+    TQStringList sections = TQStringList::split(sep, *this, TRUE);
+    if(sections.isEmpty())
+	return TQString();
+    if(!(flags & SectionSkipEmpty)) {
+	if(start < 0)
+	    start += int(sections.count());
+	if(end < 0)
+	    end += int(sections.count());
+    } else {
+	int skip = 0;
+	for(TQStringList::Iterator it = sections.begin(); it != sections.end(); ++it) {
+	    if((*it).isEmpty())
+		skip++;
+	}
+	if(start < 0)
+	    start += int(sections.count()) - skip;
+	if(end < 0)
+	    end += int(sections.count()) - skip;
+    }
+    int x = 0, run = 0;
+    TQString ret;
+    for(TQStringList::Iterator it = sections.begin(); x <= end && it != sections.end(); ++it) {
+	if(x >= start) {
+	    if((*it).isEmpty()) {
+		run++;
+	    } else {
+		if(!ret.isEmpty() || !(flags & SectionSkipEmpty)) {
+		    int i_end = run;
+		    if(!ret.isEmpty() && !(flags & SectionIncludeTrailingSep))
+			i_end++;
+		    if((flags & SectionIncludeLeadingSep) && it != sections.begin() && x == start)
+			i_end++;
+		    for(int i = 0; i < i_end; i++)
+			ret += sep;
+		} else if((flags & SectionIncludeLeadingSep) && it != sections.begin()) {
+		    ret += sep;
+		}
+		run = 0;
+		ret += (*it);
+		if((flags & SectionIncludeTrailingSep) && it != sections.end())
+		    ret += sep;
+	    }
+	}
+	if(!(*it).isEmpty() || !(flags & SectionSkipEmpty))
+	    x++;
+    }
+    return ret;
+}
+
+#ifndef TQT_NO_REGEXP
+class section_chunk {
+public:
+    section_chunk(int l, TQString s) { length = l; string = s; }
+    int length;
+    TQString string;
+};
+/*!
+    \overload
+
+    This function returns a section of the string.
+
+    This string is treated as a sequence of fields separated by the
+    regular expression, \a reg. The returned string consists of the
+    fields from position \a start to position \a end inclusive. If \a
+    end is not specified, all fields from position \a start to the end
+    of the string are included. Fields are numbered 0, 1, 2, etc., counting
+    from the left, and -1, -2, etc., counting from right to left.
+
+    The \a flags argument can be used to affect some aspects of the
+    function's behaviour, e.g. whether to be case sensitive, whether
+    to skip empty fields and how to deal with leading and trailing
+    separators; see \l{SectionFlags}.
+
+    \code
+    TQString line( "forename\tmiddlename  surname \t \t phone" );
+    TQRegExp sep( "\s+" );
+    TQString s = line.section( sep, 2, 2 ); // s == "surname"
+    \endcode
+
+    If \a start or \a end is negative, we count fields from the right
+    of the string, the right-most field being -1, the one from
+    right-most field being -2, and so on.
+
+    \code
+    TQString line( "forename\tmiddlename  surname \t \t phone" );
+    TQRegExp sep( "\\s+" );
+    TQString s = line.section( sep, -3, -2 ); // s == "middlename  surname"
+    \endcode
+
+    \warning Using this TQRegExp version is much more expensive than
+    the overloaded string and character versions.
+
+    \sa TQStringList::split() simplifyWhiteSpace()
+*/
+
+TQString TQString::section( const TQRegExp &reg, int start, int end, int flags ) const
+{
+    const TQChar *uc = tqunicode();
+    if(!uc)
+	return TQString();
+
+    TQRegExp sep(reg);
+    sep.setCaseSensitive(!(flags & SectionCaseInsensitiveSeps));
+
+    TQPtrList<section_chunk> l;
+    l.setAutoDelete(TRUE);
+    int n = length(), m = 0, last_m = 0, last = 0, last_len = 0;
+
+    while ( ( m = sep.search( *this, m ) ) != -1 ) {
+	l.append(new section_chunk(last_len, TQString(uc + last_m, m - last_m)));
+	last_m = m;
+        last_len = sep.matchedLength();
+	if((m += TQMAX(sep.matchedLength(), 1)) >= n) {
+	    last = 1;
+	    break;
+	}
+    }
+    if(!last)
+	l.append(new section_chunk(last_len, TQString(uc + last_m, n - last_m)));
+
+    if(start < 0)
+	start = l.count() + start;
+    if(end == -1)
+	end = l.count();
+    else if(end < 0)
+	end = l.count() + end;
+
+    int i = 0;
+    TQString ret;
+    for ( section_chunk *chk=l.first(); chk; chk=l.next(), i++ ) {
+	if((flags & SectionSkipEmpty) && chk->length == (int)chk->string.length()) {
+	    if(i <= start)
+		start++;
+	    end++;
+	}
+	if(i == start) {
+	    ret = (flags & SectionIncludeLeadingSep) ? chk->string : chk->string.mid(chk->length);
+	} else if(i > start) {
+	    ret += chk->string;
+	}
+	if(i == end) {
+	    if((chk=l.next()) && flags & SectionIncludeTrailingSep)
+		ret += chk->string.left(chk->length);
+	    break;
+	}
+    }
+    return ret;
+}
+#endif
+
+/*!
+    \fn TQString TQString::section( char sep, int start, int end = 0xffffffff, int flags = SectionDefault ) const
+
+    \overload
+*/
+
+/*!
+    \fn TQString TQString::section( const char *sep, int start, int end = 0xffffffff, int flags = SectionDefault ) const
+
+    \overload
+*/
+
+
+/*!
+    Returns the number of times the character \a c occurs in the
+    string.
+
+    If \a cs is TRUE (the default), the search is case sensitive;
+    otherwise the search is case insensitive.
+
+    \code
+    TQString string( "Trolltech and TQt" );
+    int n = string.tqcontains( 't', FALSE );
+    // n == 3
+    \endcode
+*/
+
+int TQString::tqcontains( TQChar c, bool cs ) const
+{
+    int count = 0;
+    const TQChar *uc = tqunicode();
+    if ( !uc )
+	return 0;
+    int n = length();
+    if ( cs ) {
+        while ( n-- ) {
+			if ( *uc == c )
+			count++;
+			uc++;
+		}
+    } else {
+	    c = ::lower( c );
+	    while ( n-- ) {
+	        if ( ::lower( *uc ) == c )
+		    count++;
+	        uc++;
+	    }
+    }
+    return count;
+}
+
+/*!
+    \overload
+
+    Returns the number of times the string \a str occurs in the string.
+
+    If \a cs is TRUE (the default), the search is case sensitive;
+    otherwise the search is case insensitive.
+*/
+int TQString::tqcontains( const char* str, bool cs ) const
+{
+    return tqcontains( TQString(str), cs );
+}
+
+/*!
+    \fn int TQString::tqcontains( char c, bool cs ) const
+
+    \overload
+*/
+
+/*!
+    \fn int TQString::tqfind( char c, int index, bool cs ) const
+
+    \overload
+
+    Find character \a c starting from position \a index.
+
+    If \a cs is TRUE (the default), the search is case sensitive;
+    otherwise the search is case insensitive.
+*/
+
+/*!
+    \fn int TQString::tqfindRev( char c, int index, bool cs ) const
+
+    \overload
+
+    Find character \a c starting from position \a index and working
+    backwards.
+
+    If \a cs is TRUE (the default), the search is case sensitive;
+    otherwise the search is case insensitive.
+*/
+
+/*!
+    \overload
+
+    Returns the number of times \a str occurs in the string.
+
+    If \a cs is TRUE (the default), the search is case sensitive;
+    otherwise the search is case insensitive.
+
+    This function counts overlapping strings, so in the example below,
+    there are two instances of "ana" in "bananas".
+
+    \code
+    TQString str( "bananas" );
+    int i = str.tqcontains( "ana" );  // i == 2
+    \endcode
+
+    \sa tqfindRev()
+*/
+
+int TQString::tqcontains( const TQString &str, bool cs ) const
+{
+    if ( isNull() )
+	return 0;
+    int count = 0;
+    uint skiptable[0x100];
+    bm_init_skiptable( str, skiptable, cs );
+    int i = -1;
+    // use boyer-moore for the ultimate speed experience
+    while ( ( i = bm_tqfind( *this, i + 1, str, skiptable, cs ) ) != -1 )
+	count++;
+    return count;
+}
+
+/*!
+    Returns a substring that tqcontains the \a len leftmost characters
+    of the string.
+
+    The whole string is returned if \a len exceeds the length of the
+    string.
+
+    \code
+	TQString s = "Pineapple";
+	TQString t = s.left( 4 );    // t == "Pine"
+    \endcode
+
+    \sa right(), mid(), isEmpty()
+*/
+
+TQString TQString::left( uint len ) const
+{
+    if ( isEmpty() ) {
+	return TQString();
+    } else if ( len == 0 ) {                    // ## just for 1.x compat:
+	return tqfromLatin1( "" );
+    } else if ( len >= length() ) {
+	return *this;
+    } else {
+	TQString s( len, TRUE );
+	memcpy( s.d->tqunicode, d->tqunicode, len * sizeof(TQChar) );
+	s.d->len = len;
+	return s;
+    }
+}
+
+/*!
+    Returns a string that tqcontains the \a len rightmost characters of
+    the string.
+
+    If \a len is greater than the length of the string then the whole
+    string is returned.
+
+    \code
+	TQString string( "Pineapple" );
+	TQString t = string.right( 5 );   // t == "apple"
+    \endcode
+
+    \sa left(), mid(), isEmpty()
+*/
+
+TQString TQString::right( uint len ) const
+{
+    if ( isEmpty() ) {
+	return TQString();
+    } else if ( len == 0 ) {                    // ## just for 1.x compat:
+	return tqfromLatin1( "" );
+    } else {
+	uint l = length();
+	if ( len >= l )
+	    return *this;
+	TQString s( len, TRUE );
+	memcpy( s.d->tqunicode, d->tqunicode+(l-len), len*sizeof(TQChar) );
+	s.d->len = len;
+	return s;
+    }
+}
+
+/*!
+    Returns a string that tqcontains the \a len characters of this
+    string, starting at position \a index.
+
+    Returns a null string if the string is empty or \a index is out of
+    range. Returns the whole string from \a index if \a index + \a len
+    exceeds the length of the string.
+
+    \code
+	TQString s( "Five pineapples" );
+	TQString t = s.mid( 5, 4 );                  // t == "pine"
+    \endcode
+
+    \sa left(), right()
+*/
+
+TQString TQString::mid( uint index, uint len ) const
+{
+    uint slen = length();
+    if ( isEmpty() || index >= slen ) {
+	return TQString();
+    } else if ( len == 0 ) {                    // ## just for 1.x compat:
+	return tqfromLatin1( "" );
+    } else {
+	if ( len > slen-index )
+	    len = slen - index;
+	if ( index == 0 && len == slen )
+	    return *this;
+	register const TQChar *p = tqunicode()+index;
+	TQString s( len, TRUE );
+	memcpy( s.d->tqunicode, p, len * sizeof(TQChar) );
+	s.d->len = len;
+	return s;
+    }
+}
+
+/*!
+    Returns a string of length \a width that tqcontains this string
+    padded by the \a fill character.
+
+    If \a truncate is FALSE and the length of the string is more than
+    \a width, then the returned string is a copy of the string.
+
+    If \a truncate is TRUE and the length of the string is more than
+    \a width, then any characters in a copy of the string after length
+    \a width are removed, and the copy is returned.
+
+    \code
+	TQString s( "apple" );
+	TQString t = s.leftJustify( 8, '.' );        // t == "apple..."
+    \endcode
+
+    \sa rightJustify()
+*/
+
+TQString TQString::leftJustify( uint width, TQChar fill, bool truncate ) const
+{
+    TQString result;
+    int len = length();
+    int padlen = width - len;
+    if ( padlen > 0 ) {
+	result.setLength(len+padlen);
+	if ( len )
+	    memcpy( result.d->tqunicode, tqunicode(), sizeof(TQChar)*len );
+	TQChar* uc = result.d->tqunicode + len;
+	while (padlen--)
+	    *uc++ = fill;
+    } else {
+	if ( truncate )
+	    result = left( width );
+	else
+	    result = *this;
+    }
+    return result;
+}
+
+/*!
+    Returns a string of length \a width that tqcontains the \a fill
+    character followed by the string.
+
+    If \a truncate is FALSE and the length of the string is more than
+    \a width, then the returned string is a copy of the string.
+
+    If \a truncate is TRUE and the length of the string is more than
+    \a width, then the resulting string is truncated at position \a
+    width.
+
+    \code
+	TQString string( "apple" );
+	TQString t = string.rightJustify( 8, '.' );  // t == "...apple"
+    \endcode
+
+    \sa leftJustify()
+*/
+
+TQString TQString::rightJustify( uint width, TQChar fill, bool truncate ) const
+{
+    TQString result;
+    int len = length();
+    int padlen = width - len;
+    if ( padlen > 0 ) {
+	result.setLength( len+padlen );
+	TQChar* uc = result.d->tqunicode;
+	while (padlen--)
+	    *uc++ = fill;
+	if ( len )
+	    memcpy( uc, tqunicode(), sizeof(TQChar)*len );
+    } else {
+	if ( truncate )
+	    result = left( width );
+	else
+	    result = *this;
+    }
+    return result;
+}
+
+/*!
+    Returns a lowercase copy of the string.
+
+    \code
+	TQString string( "TROlltECH" );
+	str = string.lower();   // str == "trolltech"
+    \endcode
+
+    \sa upper()
+*/
+
+TQString TQString::lower() const
+{
+    int l = length();
+    register TQChar *p = d->tqunicode;
+    while ( l ) {
+	if ( *p != ::lower(*p) ) {
+	    TQString s( *this );
+	    s.real_detach();
+	    p = s.d->tqunicode + ( p - d->tqunicode );
+	    while ( l ) {
+		*p = ::lower( *p );
+		l--;
+		p++;
+	    }
+	    return s;
+	}
+	l--;
+	p++;
+    }
+    return *this;
+}
+
+/*!
+    Returns an uppercase copy of the string.
+
+    \code
+	TQString string( "TeXt" );
+	str = string.upper();     // t == "TEXT"
+    \endcode
+
+    \sa lower()
+*/
+
+TQString TQString::upper() const
+{
+    int l = length();
+    register TQChar *p = d->tqunicode;
+    while ( l ) {
+	if ( *p != ::upper(*p) ) {
+	    TQString s( *this );
+	    s.real_detach();
+	    p = s.d->tqunicode + ( p - d->tqunicode );
+	    while ( l ) {
+		*p = ::upper( *p );
+		l--;
+		p++;
+	    }
+	    return s;
+	}
+	l--;
+	p++;
+    }
+    return *this;
+}
+
+
+/*!
+    Returns a string that has whitespace removed from the start and
+    the end.
+
+    Whitespace means any character for which TQChar::isSpace() returns
+    TRUE. This includes Unicode characters with decimal values 9
+    (TAB), 10 (LF), 11 (VT), 12 (FF), 13 (CR) and 32 (Space), and may
+    also include other Unicode characters.
+
+    \code
+	TQString string = "   white space   ";
+	TQString s = string.stripWhiteSpace();       // s == "white space"
+    \endcode
+
+    \sa simplifyWhiteSpace()
+*/
+
+TQString TQString::stripWhiteSpace() const
+{
+    if ( isEmpty() )                            // nothing to do
+	return *this;
+    register const TQChar *s = tqunicode();
+    if ( !s->isSpace() && !s[length()-1].isSpace() )
+	return *this;
+
+    int start = 0;
+    int end = length() - 1;
+    while ( start<=end && s[start].isSpace() )  // skip white space from start
+	start++;
+    if ( start <= end ) {                          // only white space
+	while ( end && s[end].isSpace() )           // skip white space from end
+	    end--;
+    }
+    int l = end - start + 1;
+    if ( l <= 0 )
+    	return TQString::tqfromLatin1("");
+
+    TQString result( l, TRUE );
+    memcpy( result.d->tqunicode, &s[start], sizeof(TQChar)*l );
+    result.d->len = l;
+    return result;
+}
+
+
+/*!
+    Returns a string that has whitespace removed from the start and
+    the end, and which has each sequence of internal whitespace
+    tqreplaced with a single space.
+
+    Whitespace means any character for which TQChar::isSpace() returns
+    TRUE. This includes Unicode characters with decimal values 9
+    (TAB), 10 (LF), 11 (VT), 12 (FF), 13 (CR), and 32 (Space).
+
+    \code
+	TQString string = "  lots\t of\nwhite    space ";
+	TQString t = string.simplifyWhiteSpace();
+	// t == "lots of white space"
+    \endcode
+
+    \sa stripWhiteSpace()
+*/
+
+TQString TQString::simplifyWhiteSpace() const
+{
+    if ( isEmpty() )
+	return *this;
+    TQString result;
+    result.setLength( length() );
+    const TQChar *from = tqunicode();
+    const TQChar *fromend = from+length();
+    int outc=0;
+    TQChar *to   = result.d->tqunicode;
+    for (;;) {
+	while ( from!=fromend && from->isSpace() )
+	    from++;
+	while ( from!=fromend && !from->isSpace() )
+	    to[outc++] = *from++;
+	if ( from!=fromend )
+	    to[outc++] = ' ';
+	else
+	    break;
+    }
+    if ( outc > 0 && to[outc-1] == ' ' )
+	outc--;
+    result.truncate( outc );
+    return result;
+}
+
+
+/*!
+    Inserts \a s into the string at position \a index.
+
+    If \a index is beyond the end of the string, the string is
+    extended with spaces to length \a index and \a s is then appended
+    and returns a reference to the string.
+
+    \code
+	TQString string( "I like fish" );
+	str = string.insert( 2, "don't " );
+	// str == "I don't like fish"
+    \endcode
+
+    \sa remove(), tqreplace()
+*/
+
+TQString &TQString::insert( uint index, const TQString &s )
+{
+    // the sub function takes care of &s == this case.
+    return insert( index, s.tqunicode(), s.length() );
+}
+
+/*! \fn TQString &TQString::insert( uint index, const TQByteArray &s )
+    \overload
+
+    Inserts \a s into the string at position \a index and returns
+    a reference to the string.
+*/
+
+/*! \fn TQString &TQString::insert( uint index, const char *s )
+    \overload
+
+    Inserts \a s into the string at position \a index and returns
+    a reference to the string.
+*/
+
+#ifndef TQT_NO_CAST_ASCII
+TQString &TQString::insertHelper( uint index, const char *s, uint len )
+{
+    if ( s ) {
+#ifndef TQT_NO_TEXTCODEC
+	if ( TQTextCodec::codecForCStrings() )
+	    return insert( index, fromAscii( s, len ) );
+#endif
+	if ( len == UINT_MAX )
+	    len = int(strlen( s ));
+	if ( len == 0 )
+	    return *this;
+
+	uint olen = length();
+	int nlen = olen + len;
+
+	if ( index >= olen ) {                      // insert after end of string
+	    grow( len + index );
+	    int n = index - olen;
+	    TQChar* uc = d->tqunicode + olen;
+	    while ( n-- )
+		*uc++ = ' ';
+
+	    uc = d->tqunicode + index;
+	    while ( len-- )
+		*uc++ = *s++;
+	} else {                                    // normal insert
+	    grow( nlen );
+	    memmove( d->tqunicode + index + len, tqunicode() + index,
+		    sizeof(TQChar) * (olen - index) );
+
+	    TQChar* uc = d->tqunicode + index;
+	    while ( len-- )
+		*uc++ = *s++;
+	}
+    }
+    return *this;
+}
+#endif
+
+/*!
+    \overload
+
+    Inserts the first \a len characters in \a s into the string at
+    position \a index and returns a reference to the string.
+*/
+
+TQString &TQString::insert( uint index, const TQChar* s, uint len )
+{
+    if ( len == 0 )
+	return *this;
+    uint olen = length();
+    int nlen = olen + len;
+
+    if ( s >= d->tqunicode && (uint)(s - d->tqunicode) < d->maxl ) {
+	// Part of me - take a copy.
+	TQChar *tmp = TQT_ALLOC_TQCHAR_VEC( len );
+	memcpy(tmp,s,len*sizeof(TQChar));
+	insert(index,tmp,len);
+	TQT_DELETE_TQCHAR_VEC( tmp );
+	return *this;
+    }
+
+    if ( index >= olen ) {                      // insert after end of string
+	grow( len + index );
+	int n = index - olen;
+	TQChar* uc = d->tqunicode+olen;
+	while (n--)
+	    *uc++ = ' ';
+	memcpy( d->tqunicode+index, s, sizeof(TQChar)*len );
+    } else {                                    // normal insert
+	grow( nlen );
+	memmove( d->tqunicode + index + len, tqunicode() + index,
+		 sizeof(TQChar) * (olen - index) );
+	memcpy( d->tqunicode + index, s, sizeof(TQChar) * len );
+    }
+    return *this;
+}
+
+/*!
+    \overload
+
+    Insert \a c into the string at position \a index and returns a
+    reference to the string.
+
+    If \a index is beyond the end of the string, the string is
+    extended with spaces (ASCII 32) to length \a index and \a c is
+    then appended.
+*/
+
+TQString &TQString::insert( uint index, TQChar c ) // insert char
+{
+    TQString s( c );
+    return insert( index, s );
+}
+
+/*!
+    \fn TQString& TQString::insert( uint index, char c )
+
+    \overload
+
+    Insert character \a c at position \a index.
+*/
+
+/*!
+    \fn TQString &TQString::prepend( const TQString &s )
+
+    Inserts \a s at the beginning of the string and returns a
+    reference to the string.
+
+    Equivalent to insert(0, \a s).
+
+    \code
+	TQString string = "42";
+	string.prepend( "The answer is " );
+	// string == "The answer is 42"
+    \endcode
+
+    \sa insert()
+*/
+
+/*!
+    \fn TQString& TQString::prepend( char ch )
+
+    \overload
+
+    Inserts \a ch at the beginning of the string and returns a
+    reference to the string.
+
+    Equivalent to insert(0, \a ch).
+
+    \sa insert()
+*/
+
+/*!
+    \fn TQString& TQString::prepend( TQChar ch )
+
+    \overload
+
+    Inserts \a ch at the beginning of the string and returns a
+    reference to the string.
+
+    Equivalent to insert(0, \a ch).
+
+    \sa insert()
+*/
+
+/*! \fn TQString& TQString::prepend( const TQByteArray &s )
+  \overload
+
+  Inserts \a s at the beginning of the string and returns a reference to the string.
+
+  Equivalent to insert(0, \a s).
+
+  \sa insert()
+ */
+
+/*! \fn TQString& TQString::prepend( const std::string &s )
+  \overload
+
+  Inserts \a s at the beginning of the string and returns a reference to the string.
+
+  Equivalent to insert(0, \a s).
+
+  \sa insert()
+*/
+
+/*!
+  \overload
+
+  Inserts \a s at the beginning of the string and returns a reference to the string.
+
+  Equivalent to insert(0, \a s).
+
+  \sa insert()
+ */
+TQString &TQString::prepend( const char *s )
+{
+    return insert( 0, TQString(s) );
+}
+
+/*!
+    Removes \a len characters from the string starting at position \a
+    index, and returns a reference to the string.
+
+    If \a index is beyond the length of the string, nothing happens.
+    If \a index is within the string, but \a index + \a len is beyond
+    the end of the string, the string is truncated at position \a
+    index.
+
+    \code
+	TQString string( "Montreal" );
+	string.remove( 1, 4 );      // string == "Meal"
+    \endcode
+
+    \sa insert(), tqreplace()
+*/
+
+TQString &TQString::remove( uint index, uint len )
+{
+    uint olen = length();
+    if ( index >= olen  ) {
+	// range problems
+    } else if ( index + len >= olen ) {  // index ok
+	setLength( index );
+    } else if ( len != 0 ) {
+	real_detach();
+	memmove( d->tqunicode+index, d->tqunicode+index+len,
+		 sizeof(TQChar)*(olen-index-len) );
+	setLength( olen-len );
+    }
+    return *this;
+}
+
+/*! \overload
+
+    Removes every occurrence of the character \a c in the string.
+    Returns a reference to the string.
+
+    This is the same as tqreplace(\a c, "").
+*/
+TQString &TQString::remove( TQChar c )
+{
+    int i = 0;
+    while ( i < (int) length() ) {
+	if ( constref(i) == c ) {
+	    remove( i, 1 );
+	} else {
+	    i++;
+	}
+    }
+    return *this;
+}
+
+/*! \overload
+
+    \fn TQString &TQString::remove( char c )
+
+    Removes every occurrence of the character \a c in the string.
+    Returns a reference to the string.
+
+    This is the same as tqreplace(\a c, "").
+*/
+
+/*! \overload
+
+    Removes every occurrence of \a str in the string. Returns a
+    reference to the string.
+
+    If \a cs is TRUE (the default), the search is case sensitive;
+    otherwise the search is case insensitive.
+
+    This is the same as tqreplace(\a str, "", \a cs).
+*/
+TQString &TQString::remove( const TQString & str, bool cs )
+{
+    if ( str.isEmpty() ) {
+	if ( isNull() )
+	    real_detach();
+    } else {
+	int index = 0;
+	while ( (index = tqfind(str, index, cs)) != -1 )
+	    remove( index, str.length() );
+    }
+    return *this;
+}
+
+TQString &TQString::remove( const TQString & str )
+{
+    return remove( str, TRUE );
+}
+
+/*! \overload
+
+    Replaces every occurrence of \a c1 with the char \a c2. Returns a
+    reference to the string.
+*/
+TQString &TQString::tqreplace( TQChar c1, TQChar c2 )
+{
+    if ( isEmpty() )
+	return *this;
+
+    real_detach();
+    uint i = 0;
+    while ( i < d->len ) {
+	if ( d->tqunicode[i] == c1 )
+	    d->tqunicode[i] = c2;
+	i++;
+    }
+    return *this;
+}
+
+#ifndef TQT_NO_REGEXP_CAPTURE
+
+/*! \overload
+
+    Removes every occurrence of the regular expression \a rx in the
+    string. Returns a reference to the string.
+
+    This is the same as tqreplace(\a rx, "").
+*/
+
+TQString &TQString::remove( const TQRegExp & rx )
+{
+    return tqreplace( rx, TQString::null );
+}
+
+#endif
+
+/*!
+    \overload
+
+    Removes every occurrence of \a str in the string. Returns a
+    reference to the string.
+*/
+TQString &TQString::remove( const char *str )
+{
+    return remove( TQString::fromAscii(str), TRUE );
+}
+
+/*!
+    Replaces \a len characters from the string with \a s, starting at
+    position \a index, and returns a reference to the string.
+
+    If \a index is beyond the length of the string, nothing is deleted
+    and \a s is appended at the end of the string. If \a index is
+    valid, but \a index + \a len is beyond the end of the string,
+    the string is truncated at position \a index, then \a s is
+    appended at the end.
+
+    \code
+	TQString string( "Say yes!" );
+	string = string.tqreplace( 4, 3, "NO" );
+	// string == "Say NO!"
+    \endcode
+
+    \warning TQt 3.3.3 and earlier had different semantics for the
+    case \a index >= length(), which contradicted the documentation.
+    To avoid portability problems between TQt 3 versions and with TQt
+    4, we recommend that you never call the function with \a index >=
+    length().
+
+    \sa insert(), remove()
+*/
+
+TQString &TQString::tqreplace( uint index, uint len, const TQString &s )
+{
+    return tqreplace( index, len, s.tqunicode(), s.length() );
+}
+
+/*! \overload
+
+    This is the same as tqreplace(\a index, \a len, TQString(\a c)).
+*/
+TQString &TQString::tqreplace( uint index, uint len, TQChar c )
+{
+    return tqreplace( index, len, &c, 1 );
+}
+
+/*! \overload
+    \fn TQString &TQString::tqreplace( uint index, uint len, char c )
+
+    This is the same as tqreplace(\a index, \a len, TQChar(\a c)).
+*/
+
+/*!
+    \overload
+
+    Replaces \a len characters with \a slen characters of TQChar data
+    from \a s, starting at position \a index, and returns a reference
+    to the string.
+
+    \sa insert(), remove()
+*/
+
+TQString &TQString::tqreplace( uint index, uint len, const TQChar* s, uint slen )
+{
+    if (index > length())
+        index = length();
+    real_detach();
+    if ( len == slen && index + len <= length() ) {
+	// Optimized common case: tqreplace without size change
+	memcpy( d->tqunicode+index, s, len * sizeof(TQChar) );
+    } else if ( s >= d->tqunicode && (uint)(s - d->tqunicode) < d->maxl ) {
+	// Part of me - take a copy.
+	TQChar *tmp = TQT_ALLOC_TQCHAR_VEC( slen );
+	memcpy( tmp, s, slen * sizeof(TQChar) );
+	tqreplace( index, len, tmp, slen );
+	TQT_DELETE_TQCHAR_VEC( tmp );
+    } else {
+	remove( index, len );
+	insert( index, s, slen );
+    }
+    return *this;
+}
+
+/*! \overload
+
+    Replaces every occurrence of the character \a c in the string
+    with \a after. Returns a reference to the string.
+
+    If \a cs is TRUE (the default), the search is case sensitive;
+    otherwise the search is case insensitive.
+
+    Example:
+    \code
+    TQString s = "a,b,c";
+    s.tqreplace( TQChar(','), " or " );
+    // s == "a or b or c"
+    \endcode
+*/
+TQString &TQString::tqreplace( TQChar c, const TQString & after, bool cs )
+{
+    return tqreplace( TQString( c ), after, cs );
+}
+
+TQString &TQString::tqreplace( TQChar c, const TQString & after )
+{
+    return tqreplace( TQString( c ), after, TRUE );
+}
+
+/*! \overload
+    \fn TQString &TQString::tqreplace( char c, const TQString & after, bool cs )
+
+    Replaces every occurrence of the character \a c in the string
+    with \a after. Returns a reference to the string.
+
+    If \a cs is TRUE (the default), the search is case sensitive;
+    otherwise the search is case insensitive.
+*/
+
+/*! \overload
+
+    Replaces every occurrence of the string \a before in the string
+    with the string \a after. Returns a reference to the string.
+
+    If \a cs is TRUE (the default), the search is case sensitive;
+    otherwise the search is case insensitive.
+
+    Example:
+    \code
+    TQString s = "Greek is Greek";
+    s.tqreplace( "Greek", "English" );
+    // s == "English is English"
+    \endcode
+*/
+TQString &TQString::tqreplace( const TQString & before, const TQString & after,
+			   bool cs )
+{
+    if ( isEmpty() ) {
+	if ( !before.isEmpty() )
+	    return *this;
+    } else {
+	if ( cs && before == after )
+	    return *this;
+    }
+
+    real_detach();
+
+    int index = 0;
+    uint skiptable[256];
+    bm_init_skiptable( before, skiptable, cs );
+    const int bl = before.length();
+    const int al = after.length();
+
+    if ( bl == al ) {
+	if ( bl ) {
+	    const TQChar *auc = after.tqunicode();
+	    while ( (index = bm_tqfind(*this, index, before, skiptable, cs) ) != -1 ) {
+		memcpy( d->tqunicode + index, auc, al * sizeof(TQChar) );
+		index += bl;
+	    }
+	}
+    } else if ( al < bl ) {
+	const TQChar *auc = after.tqunicode();
+	uint to = 0;
+	uint movestart = 0;
+	uint num = 0;
+	while ( (index = bm_tqfind(*this, index, before, skiptable, cs)) != -1 ) {
+	    if ( num ) {
+		int msize = index - movestart;
+		if ( msize > 0 ) {
+		    memmove( d->tqunicode + to, d->tqunicode + movestart, msize*sizeof(TQChar) );
+		    to += msize;
+		}
+	    } else {
+		to = index;
+	    }
+	    if ( al ) {
+		memcpy( d->tqunicode+to, auc, al*sizeof(TQChar) );
+		to += al;
+	    }
+	    index += bl;
+	    movestart = index;
+	    num++;
+	}
+	if ( num ) {
+	    int msize = d->len - movestart;
+	    if ( msize > 0 )
+		memmove( d->tqunicode + to, d->tqunicode + movestart, msize*sizeof(TQChar) );
+	    setLength( d->len - num*(bl-al) );
+	}
+    } else {
+	// the most complex case. We don't want to loose performance by doing repeated
+	// copies and reallocs of the string.
+	while ( index != -1 ) {
+	    uint indices[4096];
+	    uint pos = 0;
+	    while ( pos < 4095 ) {
+		index = bm_tqfind( *this, index, before, skiptable, cs );
+		if ( index == -1 )
+		    break;
+		indices[pos++] = index;
+		index += bl;
+		// avoid infinite loop
+		if ( !bl )
+		    index++;
+	    }
+	    if ( !pos )
+		break;
+
+	    // we have a table of tqreplacement positions, use them for fast replacing
+	    int adjust = pos*(al-bl);
+	    // index has to be adjusted in case we get back into the loop above.
+	    if ( index != -1 )
+		index += adjust;
+	    uint newlen = d->len + adjust;
+	    int moveend = d->len;
+	    if ( newlen > d->len )
+		setLength( newlen );
+
+	    while ( pos ) {
+		pos--;
+		int movestart = indices[pos] + bl;
+		int insertstart = indices[pos] + pos*(al-bl);
+		int moveto = insertstart + al;
+		memmove( d->tqunicode + moveto, d->tqunicode + movestart, (moveend - movestart)*sizeof(TQChar) );
+		memcpy( d->tqunicode + insertstart, after.tqunicode(), al*sizeof(TQChar) );
+		moveend = movestart-bl;
+	    }
+	}
+    }
+    return *this;
+}
+
+TQString &TQString::tqreplace( const TQString & before, const TQString & after )
+{
+    return tqreplace( before, after, TRUE );
+}
+
+#ifndef TQT_NO_REGEXP_CAPTURE
+/*! \overload
+
+  Replaces every occurrence of the regexp \a rx in the string with
+  \a after. Returns a reference to the string. For example:
+  \code
+    TQString s = "banana";
+    s.tqreplace( TQRegExp("an"), "" );
+    // s == "ba"
+  \endcode
+
+  For regexps containing \link tqregexp.html#capturing-text capturing
+  parentheses \endlink, occurrences of <b>\\1</b>, <b>\\2</b>, ...,
+  in \a after are tqreplaced with \a{rx}.cap(1), cap(2), ...
+
+  \code
+    TQString t = "A <i>bon mot</i>.";
+    t.tqreplace( TQRegExp("<i>([^<]*)</i>"), "\\emph{\\1}" );
+    // t == "A \\emph{bon mot}."
+  \endcode
+
+  \sa tqfind(), tqfindRev(), TQRegExp::cap()
+*/
+
+TQString &TQString::tqreplace( const TQRegExp &rx, const TQString &after )
+{
+    TQRegExp rx2 = rx;
+
+    if ( isEmpty() && rx2.search(*this) == -1 )
+	return *this;
+
+    real_detach();
+
+    int index = 0;
+    int numCaptures = rx2.numCaptures();
+    int al = after.length();
+    TQRegExp::CaretMode caretMode = TQRegExp::CaretAtZero;
+
+    if ( numCaptures > 0 ) {
+	if ( numCaptures > 9 )
+	    numCaptures = 9;
+
+	const TQChar *uc = after.tqunicode();
+	int numBackRefs = 0;
+
+	for ( int i = 0; i < al - 1; i++ ) {
+	    if ( uc[i] == '\\' ) {
+		int no = uc[i + 1].digitValue();
+		if ( no > 0 && no <= numCaptures )
+		    numBackRefs++;
+	    }
+	}
+
+	/*
+	  This is the harder case where we have back-references.
+	  We don't try to optimize it.
+	*/
+	if ( numBackRefs > 0 ) {
+	    int *capturePositions = new int[numBackRefs];
+	    int *captureNumbers = new int[numBackRefs];
+	    int j = 0;
+
+	    for ( int i = 0; i < al - 1; i++ ) {
+		if ( uc[i] == '\\' ) {
+		    int no = uc[i + 1].digitValue();
+		    if ( no > 0 && no <= numCaptures ) {
+			capturePositions[j] = i;
+			captureNumbers[j] = no;
+			j++;
+		    }
+		}
+	    }
+
+	    while ( index <= (int)length() ) {
+		index = rx2.search( *this, index, caretMode );
+		if ( index == -1 )
+		    break;
+
+		TQString after2 = after;
+		for ( j = numBackRefs - 1; j >= 0; j-- )
+		    after2.tqreplace( capturePositions[j], 2,
+				    rx2.cap(captureNumbers[j]) );
+
+		tqreplace( index, rx2.matchedLength(), after2 );
+		index += after2.length();
+
+		if ( rx2.matchedLength() == 0 ) {
+		    // avoid infinite loop on 0-length matches (e.g., [a-z]*)
+		    index++;
+		}
+		caretMode = TQRegExp::CaretWontMatch;
+	    }
+	    delete[] capturePositions;
+	    delete[] captureNumbers;
+	    return *this;
+	}
+    }
+
+    /*
+      This is the simple and optimized case where we don't have
+      back-references.
+    */
+    while ( index != -1 ) {
+	struct {
+	    int pos;
+	    int length;
+	} tqreplacements[2048];
+
+	uint pos = 0;
+	int adjust = 0;
+	while ( pos < 2047 ) {
+	    index = rx2.search( *this, index, caretMode );
+	    if ( index == -1 )
+		break;
+	    int ml = rx2.matchedLength();
+	    tqreplacements[pos].pos = index;
+	    tqreplacements[pos++].length = ml;
+	    index += ml;
+	    adjust += al - ml;
+	    // avoid infinite loop
+	    if ( !ml )
+		index++;
+	}
+	if ( !pos )
+	    break;
+	tqreplacements[pos].pos = d->len;
+	uint newlen = d->len + adjust;
+
+	// to continue searching at the right position after we did
+	// the first round of tqreplacements
+	if ( index != -1 )
+	    index += adjust;
+	TQChar *newuc = TQT_ALLOC_TQCHAR_VEC( newlen + 1 );
+	TQChar *uc = newuc;
+	int copystart = 0;
+	uint i = 0;
+	while ( i < pos ) {
+	    int copyend = tqreplacements[i].pos;
+	    int size = copyend - copystart;
+	    memcpy( uc, d->tqunicode + copystart, size * sizeof(TQChar) );
+	    uc += size;
+	    memcpy( uc, after.tqunicode(), al * sizeof(TQChar) );
+	    uc += al;
+	    copystart = copyend + tqreplacements[i].length;
+	    i++;
+	}
+	memcpy( uc, d->tqunicode + copystart,
+		(d->len - copystart) * sizeof(TQChar) );
+	TQT_DELETE_TQCHAR_VEC( d->tqunicode );
+	d->tqunicode = newuc;
+	d->len = newlen;
+	d->maxl = newlen + 1;
+	d->setDirty();
+	caretMode = TQRegExp::CaretWontMatch;
+    }
+    return *this;
+}
+#endif
+
+#ifndef TQT_NO_REGEXP
+/*!
+    Finds the first match of the regular expression \a rx, starting
+    from position \a index. If \a index is -1, the search starts at
+    the last character; if -2, at the next to last character and so
+    on. (See tqfindRev() for searching backwards.)
+
+    Returns the position of the first match of \a rx or -1 if no match
+    was found.
+
+    \code
+	TQString string( "bananas" );
+	int i = string.tqfind( TQRegExp("an"), 0 );    // i == 1
+    \endcode
+
+    \sa tqfindRev() tqreplace() tqcontains()
+*/
+
+int TQString::tqfind( const TQRegExp &rx, int index ) const
+{
+    return rx.search( *this, index );
+}
+
+/*!
+    \overload
+
+    Finds the first match of the regexp \a rx, starting at position \a
+    index and searching backwards. If the index is -1, the search
+    starts at the last character, if it is -2, at the next to last
+    character and so on. (See tqfindRev() for searching backwards.)
+
+    Returns the position of the match or -1 if no match was found.
+
+    \code
+	TQString string( "bananas" );
+	int i = string.tqfindRev( TQRegExp("an") );      // i == 3
+    \endcode
+
+    \sa tqfind()
+*/
+
+int TQString::tqfindRev( const TQRegExp &rx, int index ) const
+{
+    return rx.searchRev( *this, index );
+}
+
+/*!
+    \overload
+
+    Returns the number of times the regexp, \a rx, matches in the
+    string.
+
+    This function counts overlapping matches, so in the example below,
+    there are four instances of "ana" or "ama".
+
+    \code
+	TQString str = "banana and panama";
+	TQRegExp rxp = TQRegExp( "a[nm]a", TRUE, FALSE );
+	int i = str.tqcontains( rxp );    // i == 4
+    \endcode
+
+    \sa tqfind() tqfindRev()
+*/
+
+int TQString::tqcontains( const TQRegExp &rx ) const
+{
+    int count = 0;
+    int index = -1;
+    int len = length();
+    while ( index < len - 1 ) {                 // count overlapping matches
+	index = rx.search( *this, index + 1 );
+	if ( index == -1 )
+	    break;
+	count++;
+    }
+    return count;
+}
+
+#endif //TQT_NO_REGEXP
+
+/*!
+    Returns the string converted to a \c long using base \a
+    base, which is 10 by default and must be between 2 and 36 or 0. If
+    \a base is 0, the base is determined automatically using the
+    following rules:
+    <ul>
+    <li>If the string begins with "0x", it is assumed to
+    be hexadecimal;
+    <li>If it begins with "0", it is assumed to be octal;
+    <li>Otherwise it is assumed to be decimal.
+    </ul>
+
+    Returns 0 if the conversion fails.
+
+    If \a ok is not 0: if a conversion error occurs, \a *ok is set to
+    FALSE; otherwise \a *ok is set to TRUE.
+
+    Leading and trailing whitespace is ignored by this function.
+
+    For information on how string-to-number functions in TQString handle
+    localized input, see toDouble().
+
+    \sa number()
+*/
+
+long TQString::toLong( bool *ok, int base ) const
+{
+    TQ_LLONG v = toLongLong( ok, base );
+    if ( v < LONG_MIN || v > LONG_MAX ) {
+	if ( ok )
+	    *ok = FALSE;
+	v = 0;
+    }
+    return long(v);
+}
+
+/*!
+    Returns the string converted to a \c {long long} using base \a
+    base, which is 10 by default and must be between 2 and 36 or 0. If
+    \a base is 0, the base is determined automatically using the
+    following rules:
+    <ul>
+    <li>If the string begins with "0x", it is assumed to
+    be hexadecimal;
+    <li>If it begins with "0", it is assumed to be octal;
+    <li>Otherwise it is assumed to be decimal.
+    </ul>
+
+    Returns 0 if the conversion fails.
+
+    If \a ok is not 0: if a conversion error occurs, \a *ok is set to
+    FALSE; otherwise \a *ok is set to TRUE.
+
+    Leading and trailing whitespace is ignored by this function.
+
+    For information on how string-to-number functions in TQString handle
+    localized input, see toDouble().
+
+    \sa number()
+*/
+
+TQ_LLONG TQString::toLongLong( bool *ok, int base ) const
+{
+#if defined(TQT_CHECK_RANGE)
+    if ( base != 0 && (base < 2 || base > 36) ) {
+	qWarning( "TQString::toLongLong: Invalid base (%d)", base );
+	base = 10;
+    }
+#endif
+
+    bool my_ok;
+    TQLocale def_locale;
+    TQ_LLONG result = def_locale.d->stringToLongLong(*this, base, &my_ok, TQLocalePrivate::FailOnGroupSeparators);
+    if (my_ok) {
+    	if (ok != 0)
+	    *ok = TRUE;
+	return result;
+    }
+
+    // If the default was not "C", try the "C" locale
+    if (def_locale.language() == TQLocale::C) {
+    	if (ok != 0)
+	    *ok = FALSE;
+	return 0;
+    }
+
+    TQLocale c_locale(TQLocale::C);
+    return c_locale.d->stringToLongLong(*this, base, ok, TQLocalePrivate::FailOnGroupSeparators);
+}
+
+/*!
+    Returns the string converted to an \c {unsigned long} using base \a
+    base, which is 10 by default and must be between 2 and 36 or 0. If
+    \a base is 0, the base is determined automatically using the
+    following rules:
+    <ul>
+    <li>If the string begins with "0x", it is assumed to
+    be hexadecimal;
+    <li>If it begins with "0", it is assumed to be octal;
+    <li>Otherwise it is assumed to be decimal.
+    </ul>
+
+    Returns 0 if the conversion fails.
+
+    If \a ok is not 0: if a conversion error occurs, \a *ok is set to
+    FALSE; otherwise \a *ok is set to TRUE.
+
+    Leading and trailing whitespace is ignored by this function.
+
+    For information on how string-to-number functions in TQString handle
+    localized input, see toDouble().
+
+    \sa number()
+*/
+
+ulong TQString::toULong( bool *ok, int base ) const
+{
+    TQ_ULLONG v = toULongLong( ok, base );
+    if ( v > ULONG_MAX ) {
+	if ( ok )
+	    *ok = FALSE;
+	v = 0;
+    }
+    return ulong(v);
+}
+
+/*!
+    Returns the string converted to an \c {unsigned long long} using base \a
+    base, which is 10 by default and must be between 2 and 36 or 0. If
+    \a base is 0, the base is determined automatically using the
+    following rules:
+    <ul>
+    <li>If the string begins with "0x", it is assumed to
+    be hexadecimal;
+    <li>If it begins with "0", it is assumed to be octal;
+    <li>Otherwise it is assumed to be decimal.
+    </ul>
+
+    Returns 0 if the conversion fails.
+
+    If \a ok is not 0: if a conversion error occurs, \a *ok is set to
+    FALSE; otherwise \a *ok is set to TRUE.
+
+    Leading and trailing whitespace is ignored by this function.
+
+    For information on how string-to-number functions in TQString handle
+    localized input, see toDouble().
+
+    \sa number()
+*/
+
+TQ_ULLONG TQString::toULongLong( bool *ok, int base ) const
+{
+#if defined(TQT_CHECK_RANGE)
+    if ( base != 0 && (base < 2 || base > 36) ) {
+	qWarning( "TQString::toULongLong: Invalid base %d", base );
+	base = 10;
+    }
+#endif
+
+    bool my_ok;
+    TQLocale def_locale;
+    TQ_ULLONG result = def_locale.d->stringToUnsLongLong(*this, base, &my_ok, TQLocalePrivate::FailOnGroupSeparators);
+    if (my_ok) {
+    	if (ok != 0)
+	    *ok = TRUE;
+	return result;
+    }
+
+    // If the default was not "C", try the "C" locale
+    if (def_locale.language() == TQLocale::C) {
+    	if (ok != 0)
+	    *ok = FALSE;
+	return 0;
+    }
+
+    TQLocale c_locale(TQLocale::C);
+    return c_locale.d->stringToUnsLongLong(*this, base, ok, TQLocalePrivate::FailOnGroupSeparators);
+}
+
+/*!
+    Returns the string converted to a \c short using base \a
+    base, which is 10 by default and must be between 2 and 36 or 0. If
+    \a base is 0, the base is determined automatically using the
+    following rules:
+    <ul>
+    <li>If the string begins with "0x", it is assumed to
+    be hexadecimal;
+    <li>If it begins with "0", it is assumed to be octal;
+    <li>Otherwise it is assumed to be decimal.
+    </ul>
+
+
+    Returns 0 if the conversion fails.
+
+    If \a ok is not 0: if a conversion error occurs, \a *ok is set to
+    FALSE; otherwise \a *ok is set to TRUE.
+
+    Leading and trailing whitespace is ignored by this function.
+
+    For information on how string-to-number functions in TQString handle
+    localized input, see toDouble().
+
+    \sa number()
+*/
+
+
+short TQString::toShort( bool *ok, int base ) const
+{
+    TQ_LLONG v = toLongLong( ok, base );
+    if ( v < SHRT_MIN || v > SHRT_MAX ) {
+	if ( ok )
+	    *ok = FALSE;
+	v = 0;
+    }
+    return (short)v;
+}
+
+/*!
+    Returns the string converted to an \c {unsigned short} using base \a
+    base, which is 10 by default and must be between 2 and 36 or 0. If
+    \a base is 0, the base is determined automatically using the
+    following rules:
+    <ul>
+    <li>If the string begins with "0x", it is assumed to
+    be hexadecimal;
+    <li>If it begins with "0", it is assumed to be octal;
+    <li>Otherwise it is assumed to be decimal.
+    </ul>
+
+
+    Returns 0 if the conversion fails.
+
+    If \a ok is not 0: if a conversion error occurs, \a *ok is set to
+    FALSE; otherwise \a *ok is set to TRUE.
+
+    Leading and trailing whitespace is ignored by this function.
+
+    For information on how string-to-number functions in TQString handle
+    localized input, see toDouble().
+
+    \sa number()
+*/
+
+ushort TQString::toUShort( bool *ok, int base ) const
+{
+    TQ_ULLONG v = toULongLong( ok, base );
+    if ( v > USHRT_MAX ) {
+	if ( ok )
+	    *ok = FALSE;
+	v = 0;
+    }
+    return (ushort)v;
+}
+
+
+/*!
+    Returns the string converted to an \c int using base \a
+    base, which is 10 by default and must be between 2 and 36 or 0. If
+    \a base is 0, the base is determined automatically using the
+    following rules:
+    <ul>
+    <li>If the string begins with "0x", it is assumed to
+    be hexadecimal;
+    <li>If it begins with "0", it is assumed to be octal;
+    <li>Otherwise it is assumed to be decimal.
+    </ul>
+
+
+    Returns 0 if the conversion fails.
+
+    If \a ok is not 0: if a conversion error occurs, \a *ok is set to
+    FALSE; otherwise \a *ok is set to TRUE.
+
+    \code
+	TQString str( "FF" );
+	bool ok;
+	int hex = str.toInt( &ok, 16 );     // hex == 255, ok == TRUE
+	int dec = str.toInt( &ok, 10 );     // dec == 0, ok == FALSE
+    \endcode
+
+    Leading and trailing whitespace is ignored by this function.
+
+    For information on how string-to-number functions in TQString handle
+    localized input, see toDouble().
+
+    \sa number()
+*/
+
+int TQString::toInt( bool *ok, int base ) const
+{
+    TQ_LLONG v = toLongLong( ok, base );
+    if ( v < INT_MIN || v > INT_MAX ) {
+	if ( ok )
+	    *ok = FALSE;
+	v = 0;
+    }
+    return (int)v;
+}
+
+/*!
+    Returns the string converted to an \c {unsigned int} using base \a
+    base, which is 10 by default and must be between 2 and 36 or 0. If
+    \a base is 0, the base is determined automatically using the
+    following rules:
+    <ul>
+    <li>If the string begins with "0x", it is assumed to
+    be hexadecimal;
+    <li>If it begins with "0", it is assumed to be octal;
+    <li>Otherwise it is assumed to be decimal.
+    </ul>
+
+    Returns 0 if the conversion fails.
+
+    If \a ok is not 0: if a conversion error occurs, \a *ok is set to
+    FALSE; otherwise \a *ok is set to TRUE.
+
+    Leading and trailing whitespace is ignored by this function.
+
+    For information on how string-to-number functions in TQString handle
+    localized input, see toDouble().
+
+    \sa number()
+*/
+
+uint TQString::toUInt( bool *ok, int base ) const
+{
+    TQ_ULLONG v = toULongLong( ok, base );
+    if ( v > UINT_MAX ) {
+	if ( ok )
+	    *ok = FALSE;
+	v = 0;
+    }
+    return (uint)v;
+}
+
+/*!
+    Returns the string converted to a \c double value.
+
+    If \a ok is not 0: if a conversion error occurs, \a *ok is set to
+    FALSE; otherwise \a *ok is set to TRUE.
+
+    \code
+	TQString string( "1234.56" );
+	double a = string.toDouble();   // a == 1234.56
+    \endcode
+
+    The string-to-number functions:
+    \list
+    \i toShort()
+    \i toUShort()
+    \i toInt()
+    \i toUInt()
+    \i toLong()
+    \i toULong()
+    \i toLongLong()
+    \i toULongLong()
+    \i toFloat()
+    \i toDouble()
+    \endlist
+    can handle numbers
+    represented in various locales. These representations may use different
+    characters for the decimal point, thousands group sepearator
+    and even individual digits. TQString's functions try to interpret
+    the string according to the current locale. The current locale is
+    determined from the system at application startup and can be changed
+    by calling TQLocale::setDefault(). If the string cannot be interpreted
+    according to the current locale, this function falls back
+    on the "C" locale.
+
+    \code
+	bool ok;
+	double d;
+
+        TQLocale::setDefault(TQLocale::C);
+	d = TQString( "1234,56" ).toDouble(&ok); // ok == false
+	d = TQString( "1234.56" ).toDouble(&ok); // ok == true, d == 1234.56
+
+	TQLocale::setDefault(TQLocale::German);
+	d = TQString( "1234,56" ).toDouble(&ok); // ok == true, d == 1234.56
+	d = TQString( "1234.56" ).toDouble(&ok); // ok == true, d == 1234.56
+    \endcode
+
+    Due to the ambiguity between the decimal point and thousands group
+    separator in various locales, these functions do not handle
+    thousands group separators. If you need to convert such numbers,
+    use the corresponding function in TQLocale.
+
+    \code
+	bool ok;
+        TQLocale::setDefault(TQLocale::C);
+	double d = TQString( "1,234,567.89" ).toDouble(&ok); // ok == false
+    \endcode
+
+    \warning If the string tqcontains trailing whitespace this function
+    will fail, and set \a *ok to false if \a ok is not 0. Leading
+    whitespace is ignored.
+
+    \sa number() TQLocale::setDefault() TQLocale::toDouble() stripWhiteSpace()
+*/
+
+double TQString::toDouble( bool *ok ) const
+{
+    // If there is trailing whitespace, set ok to false but return the correct
+    // result anyway to preserve behavour of pervious versions of TQt
+    if (length() > 0 && tqunicode()[length() - 1].isSpace()) {
+        TQString tmp = stripWhiteSpace();
+    	if (ok != 0)
+	    *ok = FALSE;
+    	return tmp.toDouble();
+    }
+
+    // Try the default locale
+    bool my_ok;
+    TQLocale def_locale;
+    double result = def_locale.d->stringToDouble(*this, &my_ok, TQLocalePrivate::FailOnGroupSeparators);
+    if (my_ok) {
+    	if (ok != 0)
+	    *ok = TRUE;
+	return result;
+    }
+
+    // If the default was not "C", try the "C" locale
+    if (def_locale.language() == TQLocale::C) {
+    	if (ok != 0)
+	    *ok = FALSE;
+	return 0.0;
+    }
+
+    TQLocale c_locale(TQLocale::C);
+    return c_locale.d->stringToDouble(*this, ok, TQLocalePrivate::FailOnGroupSeparators);
+}
+
+/*!
+    Returns the string converted to a \c float value.
+
+    Returns 0.0 if the conversion fails.
+
+    If \a ok is not 0: if a conversion error occurs, \a *ok is set to
+    FALSE; otherwise \a *ok is set to TRUE.
+
+    For information on how string-to-number functions in TQString handle
+    localized input, see toDouble().
+
+    \warning If the string tqcontains trailing whitespace this function
+    will fail, settings \a *ok to false if \a ok is not 0.
+    Leading whitespace is ignored.
+
+    \sa number()
+*/
+
+#define TQT_MAX_FLOAT 3.4028234663852886e+38
+
+float TQString::toFloat( bool *ok ) const
+{
+    bool myOk;
+    double d = toDouble(&myOk);
+    if (!myOk || d > TQT_MAX_FLOAT || d < -TQT_MAX_FLOAT) {
+        if (ok != 0)
+            *ok = FALSE;
+        return 0.0;
+    }
+    if (ok != 0)
+        *ok = TRUE;
+    return (float) d;
+}
+
+/*!
+    Sets the string to the printed value of \a n in base \a base and
+    returns a reference to the string. The returned string is in "C" locale.
+
+    The base is 10 by default and must be between 2 and 36.
+
+    \code
+	TQString string;
+	string = string.setNum( 1234 );     // string == "1234"
+    \endcode
+*/
+
+TQString &TQString::setNum( TQ_LLONG n, int base )
+{
+#if defined(TQT_CHECK_RANGE)
+    if ( base < 2 || base > 36 ) {
+	qWarning( "TQString::setNum: Invalid base %d", base );
+	base = 10;
+    }
+#endif
+    TQLocale locale(TQLocale::C);
+    *this = locale.d->longLongToString(n, -1, base);
+    return *this;
+}
+
+/*!
+    \overload
+
+    Sets the string to the printed value of \a n in base \a base and
+    returns a reference to the string.
+
+    The base is 10 by default and must be between 2 and 36.
+*/
+
+TQString &TQString::setNum( TQ_ULLONG n, int base )
+{
+#if defined(TQT_CHECK_RANGE)
+    if ( base < 2 || base > 36 ) {
+	qWarning( "TQString::setNum: Invalid base %d", base );
+	base = 10;
+    }
+#endif
+    TQLocale locale(TQLocale::C);
+    *this = locale.d->unsLongLongToString(n, -1, base);
+    return *this;
+}
+
+/*!
+    \fn TQString &TQString::setNum( long n, int base )
+
+    \overload
+*/
+// ### 4.0: inline
+TQString &TQString::setNum( long n, int base )
+{
+    return setNum( (TQ_LLONG)n, base );
+}
+
+/*!
+    \fn TQString &TQString::setNum( ulong n, int base )
+
+    \overload
+*/
+// ### 4.0: inline
+TQString &TQString::setNum( ulong n, int base )
+{
+    return setNum( (TQ_ULLONG)n, base );
+}
+
+/*!
+    \fn TQString &TQString::setNum( int n, int base )
+
+    \overload
+
+    Sets the string to the printed value of \a n in base \a base and
+    returns a reference to the string.
+
+    The base is 10 by default and must be between 2 and 36.
+*/
+
+/*!
+    \fn TQString &TQString::setNum( uint n, int base )
+
+    \overload
+
+    Sets the string to the printed value of \a n in base \a base and
+    returns a reference to the string.
+
+    The base is 10 by default and must be between 2 and 36.
+*/
+
+/*!
+    \fn TQString &TQString::setNum( short n, int base )
+
+    \overload
+
+    Sets the string to the printed value of \a n in base \a base and
+    returns a reference to the string.
+
+    The base is 10 by default and must be between 2 and 36.
+*/
+
+/*!
+    \fn TQString &TQString::setNum( ushort n, int base )
+
+    \overload
+
+    Sets the string to the printed value of \a n in base \a base and
+    returns a reference to the string.
+
+    The base is 10 by default and must be between 2 and 36.
+*/
+
+/*!
+    \overload
+
+    Sets the string to the printed value of \a n, formatted in format
+    \a f with precision \a prec, and returns a reference to the
+    string.
+
+    The format \a f can be 'f', 'F', 'e', 'E', 'g' or 'G'. See \link
+    #arg-formats arg \endlink() for an explanation of the formats.
+*/
+
+TQString &TQString::setNum( double n, char f, int prec )
+{
+    TQLocalePrivate::DoubleForm form = TQLocalePrivate::DFDecimal;
+    uint flags = 0;
+
+    if (qIsUpper(f))
+    	flags = TQLocalePrivate::CapitalEorX;
+    f = qToLower(f);
+
+    switch (f) {
+	case 'f':
+	    form = TQLocalePrivate::DFDecimal;
+	    break;
+	case 'e':
+	    form = TQLocalePrivate::DFExponent;
+	    break;
+	case 'g':
+	    form = TQLocalePrivate::DFSignificantDigits;
+	    break;
+	default:
+#if defined(TQT_CHECK_RANGE)
+	    qWarning( "TQString::setNum: Invalid format char '%c'", f );
+#endif
+	    break;
+    }
+
+    TQLocale locale(TQLocale::C);
+    *this = locale.d->doubleToString(n, prec, form, -1, flags);
+    return *this;
+}
+
+/*!
+    \fn TQString &TQString::setNum( float n, char f, int prec )
+
+    \overload
+
+    Sets the string to the printed value of \a n, formatted in format
+    \a f with precision \a prec, and returns a reference to the
+    string.
+
+    The format \a f can be 'f', 'F', 'e', 'E', 'g' or 'G'. See \link
+    #arg-formats arg \endlink() for an explanation of the formats.
+*/
+
+
+/*!
+    A convenience function that returns a string equivalent of the
+    number \a n to base \a base, which is 10 by default and must be
+    between 2 and 36. The returned string is in "C" locale.
+
+    \code
+	long a = 63;
+	TQString str = TQString::number( a, 16 );             // str == "3f"
+	TQString str = TQString::number( a, 16 ).upper();     // str == "3F"
+    \endcode
+
+    \sa setNum()
+*/
+TQString TQString::number( long n, int base )
+{
+    TQString s;
+    s.setNum( n, base );
+    return s;
+}
+
+/*!
+    \overload
+
+    \sa setNum()
+*/
+TQString TQString::number( ulong n, int base )
+{
+    TQString s;
+    s.setNum( n, base );
+    return s;
+}
+
+/*!
+    \overload
+
+    \sa setNum()
+*/
+TQString TQString::number( TQ_LLONG n, int base )
+{
+    TQString s;
+    s.setNum( n, base );
+    return s;
+}
+
+/*!
+    \overload
+
+    \sa setNum()
+*/
+TQString TQString::number( TQ_ULLONG n, int base )
+{
+    TQString s;
+    s.setNum( n, base );
+    return s;
+}
+
+/*!
+    \overload
+
+    \sa setNum()
+*/
+TQString TQString::number( int n, int base )
+{
+    TQString s;
+    s.setNum( n, base );
+    return s;
+}
+
+/*!
+    \overload
+
+    A convenience factory function that returns a string
+    representation of the number \a n to the base \a base, which is 10
+    by default and must be between 2 and 36.
+
+    \sa setNum()
+*/
+TQString TQString::number( uint n, int base )
+{
+    TQString s;
+    s.setNum( n, base );
+    return s;
+}
+
+/*!
+    \overload
+
+    Argument \a n is formatted according to the \a f format specified,
+    which is \c g by default, and can be any of the following:
+
+    \table
+    \header \i Format \i Meaning
+    \row \i \c e \i format as [-]9.9e[+|-]999
+    \row \i \c E \i format as [-]9.9E[+|-]999
+    \row \i \c f \i format as [-]9.9
+    \row \i \c g \i use \c e or \c f format, whichever is the most concise
+    \row \i \c G \i use \c E or \c f format, whichever is the most concise
+    \endtable
+
+    With 'e', 'E', and 'f', \a prec is the number of digits after the
+    decimal point. With 'g' and 'G', \a prec is the maximum number of
+    significant digits (trailing zeroes are omitted).
+
+    \code
+    double d = 12.34;
+    TQString ds = TQString( "'E' format, precision 3, gives %1" )
+		    .arg( d, 0, 'E', 3 );
+    // ds == "1.234E+001"
+    \endcode
+
+    \sa setNum()
+    */
+TQString TQString::number( double n, char f, int prec )
+{
+    TQString s;
+    s.setNum( n, f, prec );
+    return s;
+}
+
+
+/*! \obsolete
+
+  Sets the character at position \a index to \a c and expands the
+  string if necessary, filling with spaces.
+
+  This method is redundant in TQt 3.x, because operator[] will expand
+  the string as necessary.
+*/
+
+void TQString::setExpand( uint index, TQChar c )
+{
+    int spaces = index - d->len;
+    at(index) = c;
+    while (spaces-->0)
+	d->tqunicode[--index]=' ';
+}
+
+
+/*!
+  \fn const char* TQString::data() const
+
+  \obsolete
+
+  Returns a pointer to a '\0'-terminated classic C string.
+
+  In TQt 1.x, this returned a char* allowing direct manipulation of the
+  string as a sequence of bytes. In TQt 2.x where TQString is a Unicode
+  string, char* conversion constructs a temporary string, and hence
+  direct character operations are meaningless.
+*/
+
+/*!
+    \fn bool TQString::operator!() const
+
+    Returns TRUE if this is a null string; otherwise returns FALSE.
+
+    \code
+	TQString name = getName();
+	if ( !name )
+	    name = "Rodney";
+    \endcode
+
+    Note that if you say
+
+    \code
+	TQString name = getName();
+	if ( name )
+	    doSomethingWith(name);
+    \endcode
+
+    It will call "operator const char*()", which is inefficent; you
+    may wish to define the macro \c TQT_NO_ASCII_CAST when writing code
+    which you wish to remain Unicode-clean.
+
+    When you want the above semantics, use:
+
+    \code
+	TQString name = getName();
+	if ( !name.isNull() )
+	    doSomethingWith(name);
+    \endcode
+
+    \sa isEmpty()
+*/
+
+
+/*!
+    \fn TQString& TQString::append( const TQString& str )
+
+    Appends \a str to the string and returns a reference to the
+    result.
+
+    \code
+	string = "Test";
+	string.append( "ing" );        // string == "Testing"
+    \endcode
+
+    Equivalent to operator+=().
+*/
+
+/*!
+    \fn TQString& TQString::append( char ch )
+
+    \overload
+
+    Appends character \a ch to the string and returns a reference to
+    the result.
+
+    Equivalent to operator+=().
+*/
+
+/*!
+    \fn TQString& TQString::append( TQChar ch )
+
+    \overload
+
+    Appends character \a ch to the string and returns a reference to
+    the result.
+
+    Equivalent to operator+=().
+*/
+
+/*! \fn TQString& TQString::append( const TQByteArray &str )
+  \overload
+
+  Appends \a str to the string and returns a reference to the result.
+
+  Equivalent to operator+=().
+*/
+
+/*! \fn TQString& TQString::append( const std::string &str )
+  \overload
+
+  Appends \a str to the string and returns a reference to the result.
+
+  Equivalent to operator+=().
+*/
+
+/*! \fn TQString& TQString::append( const char *str )
+  \overload
+
+  Appends \a str to the string and returns a reference to the result.
+
+  Equivalent to operator+=().
+*/
+
+/*!
+    Appends \a str to the string and returns a reference to the string.
+*/
+TQString& TQString::operator+=( const TQString &str )
+{
+    uint len1 = length();
+    uint len2 = str.length();
+    if ( len2 ) {
+	if ( isEmpty() ) {
+	    operator=( str );
+	} else {
+	    grow( len1+len2 );
+	    memcpy( d->tqunicode+len1, str.tqunicode(), sizeof(TQChar)*len2 );
+	}
+    } else if ( isNull() && !str.isNull() ) {   // ## just for 1.x compat:
+	*this = tqfromLatin1( "" );
+    }
+    return *this;
+}
+
+#ifndef TQT_NO_CAST_ASCII
+TQString &TQString::operatorPlusEqHelper( const char *s, uint len2 )
+{
+    if ( s ) {
+#ifndef TQT_NO_TEXTCODEC
+	if ( TQTextCodec::codecForCStrings() )
+	    return operator+=( fromAscii( s, len2 ) );
+#endif
+
+	uint len1 = length();
+	if ( len2 == UINT_MAX )
+	    len2 = int(strlen( s ));
+	if ( len2 ) {
+	    grow( len1 + len2 );
+	    TQChar* uc = d->tqunicode + len1;
+	    while ( len2-- )
+		*uc++ = *s++;
+	} else if ( isNull() ) {   // ## just for 1.x compat:
+	    *this = tqfromLatin1( "" );
+	}
+    }
+    return *this;
+}
+#endif
+
+/*!
+    \overload
+
+  Appends \a str to the string and returns a reference to the string.
+*/
+#ifndef TQT_NO_CAST_ASCII
+TQString& TQString::operator+=( const char *str )
+{
+    // ### TQt 4: make this function inline
+    return operatorPlusEqHelper( str );
+}
+#endif
+
+/*! \overload
+
+  Appends \a c to the string and returns a reference to the string.
+*/
+
+TQString &TQString::operator+=( TQChar c )
+{
+    grow( length()+1 );
+    d->tqunicode[length()-1] = c;
+    return *this;
+}
+
+/*!
+    \overload
+
+    Appends \a c to the string and returns a reference to the string.
+*/
+
+TQString &TQString::operator+=( char c )
+{
+#ifndef TQT_NO_TEXTCODEC
+    if ( TQTextCodec::codecForCStrings() )
+	return operator+=( fromAscii( &c, 1 ) );
+#endif
+    grow( length()+1 );
+    d->tqunicode[length()-1] = c;
+    return *this;
+}
+
+/*!
+  \fn TQString &TQString::operator+=( const TQByteArray &str )
+  \overload
+
+  Appends \a str to the string and returns a reference to the string.
+*/
+
+/*!
+  \fn TQString &TQString::operator+=( const std::string &str )
+  \overload
+
+  Appends \a str to the string and returns a reference to the string.
+*/
+
+/*!
+    \fn char TQChar::latin1() const
+
+    Returns the Latin-1 value of this character, or 0 if it
+    cannot be represented in Latin-1.
+*/
+
+
+/*!
+    Returns a Latin-1 representation of the string. The
+    returned value is undefined if the string tqcontains non-Latin-1
+    characters. If you want to convert strings into formats other than
+    Unicode, see the TQTextCodec classes.
+
+    This function is mainly useful for boot-strapping legacy code to
+    use Unicode.
+
+    The result remains valid so long as one unmodified copy of the
+    source string exists.
+
+    \sa tqfromLatin1(), ascii(), utf8(), local8Bit()
+*/
+const char* TQString::latin1() const
+{
+    if ( !d->ascii  || !d->islatin1 ) {
+	delete [] d->ascii;
+	d->ascii = tqunicodeToLatin1( d->tqunicode, d->len );
+	d->islatin1 = TRUE;
+    }
+    return d->ascii;
+}
+
+/*!
+    Returns an 8-bit ASCII representation of the string.
+
+    If a codec has been set using TQTextCodec::codecForCStrings(),
+    it is used to convert Unicode to 8-bit char. Otherwise, this function
+    does the same as latin1().
+
+    \sa fromAscii(), latin1(), utf8(), local8Bit()
+*/
+const char* TQString::ascii() const
+{
+#ifndef TQT_NO_TEXTCODEC
+    if ( TQTextCodec::codecForCStrings() ) {
+	if ( !d->ascii || d->islatin1 ) {
+	    delete [] d->ascii;
+	    if (d->tqunicode) {
+		TQCString s = TQTextCodec::codecForCStrings()->fromUnicode( *this );
+                d->ascii = new char[s.length() + 1];
+                memcpy(d->ascii, s.data(), s.length() + 1);
+	    } else {
+		d->ascii = 0;
+	    }
+	    d->islatin1 = FALSE;
+	}
+	return d->ascii;
+    }
+#endif // TQT_NO_TEXTCODEC
+    return latin1();
+}
+
+/*!
+    Returns the string encoded in UTF-8 format.
+
+    See TQTextCodec for more diverse coding/decoding of Unicode strings.
+
+    \sa fromUtf8(), ascii(), latin1(), local8Bit()
+*/
+TQCString TQString::utf8() const
+{
+    int l = length();
+    int rlen = l*3+1;
+    TQCString rstr(rlen);
+    uchar* cursor = (uchar*)rstr.data();
+    const TQChar *ch = d->tqunicode;
+    for (int i=0; i < l; i++) {
+	uint u = ch->tqunicode();
+ 	if ( u < 0x80 ) {
+ 	    *cursor++ = (uchar)u;
+ 	} else {
+ 	    if ( u < 0x0800 ) {
+		*cursor++ = 0xc0 | ((uchar) (u >> 6));
+ 	    } else {
+		if (u >= 0xd800 && u < 0xdc00 && i < l-1) {
+		    unsigned short low = ch[1].tqunicode();
+		    if (low >= 0xdc00 && low < 0xe000) {
+			++ch;
+			++i;
+			u = (u - 0xd800)*0x400 + (low - 0xdc00) + 0x10000;
+		    }
+		}
+		if (u > 0xffff) {
+		    // if people are working in utf8, but strings are encoded in eg. latin1, the resulting
+		    // name might be invalid utf8. This and the corresponding code in fromUtf8 takes care
+		    // we can handle this without loosing information. This can happen with latin filenames
+		    // and a utf8 locale under Unix.
+		    if (u > 0x10fe00 && u < 0x10ff00) {
+			*cursor++ = (u - 0x10fe00);
+			++ch;
+			continue;
+		    } else {
+			*cursor++ = 0xf0 | ((uchar) (u >> 18));
+			*cursor++ = 0x80 | ( ((uchar) (u >> 12)) & 0x3f);
+		    }
+		} else {
+		    *cursor++ = 0xe0 | ((uchar) (u >> 12));
+		}
+ 		*cursor++ = 0x80 | ( ((uchar) (u >> 6)) & 0x3f);
+ 	    }
+ 	    *cursor++ = 0x80 | ((uchar) (u&0x3f));
+ 	}
+ 	++ch;
+    }
+    rstr.truncate( cursor - (uchar*)rstr.data() );
+    return rstr;
+}
+
+static TQChar *addOne(TQChar *qch, TQString &str)
+{
+    long sidx = qch - str.tqunicode();
+    str.setLength(str.length()+1);
+    return (TQChar *)str.tqunicode() + sidx;
+}
+
+/*!
+    Returns the Unicode string decoded from the first \a len
+    bytes of \a utf8, ignoring the rest of \a utf8. If \a len is
+    -1 then the length of \a utf8 is used. If \a len is bigger than
+    the length of \a utf8 then it will use the length of \a utf8.
+
+    \code
+	TQString str = TQString::fromUtf8( "123456789", 5 );
+	// str == "12345"
+    \endcode
+
+    See TQTextCodec for more diverse coding/decoding of Unicode strings.
+*/
+TQString TQString::fromUtf8( const char* utf8, int len )
+{
+    if ( !utf8 )
+	return TQString::null;
+
+    int slen = 0;
+    if (len >= 0) {
+	while (slen < len && utf8[slen])
+		slen++;
+    } else {
+        slen = int(strlen(utf8));
+    }
+    len = len < 0 ? slen : TQMIN(slen, len);
+    TQString result;
+    result.setLength( len ); // worst case
+    TQChar *qch = (TQChar *)result.tqunicode();
+    uint uc = 0;
+    uint min_uc = 0;
+    int need = 0;
+    int error = -1;
+    uchar ch;
+    for (int i=0; i<len; i++) {
+	ch = utf8[i];
+	if (need) {
+	    if ( (ch&0xc0) == 0x80 ) {
+		uc = (uc << 6) | (ch & 0x3f);
+		need--;
+		if ( !need ) {
+		    if (uc > 0xffff) {
+			// surrogate pair
+			uc -= 0x10000;
+			unsigned short high = uc/0x400 + 0xd800;
+			unsigned short low = uc%0x400 + 0xdc00;
+			*qch++ = TQChar(high);
+			*qch++ = TQChar(low);
+		    } else if (uc < min_uc || (uc >= 0xd800 && uc <= 0xdfff) || (uc >= 0xfffe)) {
+			// overlong seqence, UTF16 surrogate or BOM
+                        i = error;
+                        qch = addOne(qch, result);
+                        *qch++ = TQChar(0xdbff);
+                        *qch++ = TQChar(0xde00+((uchar)utf8[i]));
+                    } else {
+			*qch++ = uc;
+		    }
+		}
+	    } else {
+		// See TQString::utf8() for explanation.
+		//
+		// The surrogate below corresponds to a Unicode value of (0x10fe00+ch) which
+		// is in one of the private use areas of Unicode.
+		i = error;
+                qch = addOne(qch, result);
+		*qch++ = TQChar(0xdbff);
+		*qch++ = TQChar(0xde00+((uchar)utf8[i]));
+		need = 0;
+	    }
+	} else {
+	    if ( ch < 128 ) {
+		*qch++ = ch;
+	    } else if ((ch & 0xe0) == 0xc0) {
+		uc = ch & 0x1f;
+		need = 1;
+		error = i;
+		min_uc = 0x80;
+	    } else if ((ch & 0xf0) == 0xe0) {
+		uc = ch & 0x0f;
+		need = 2;
+		error = i;
+		min_uc = 0x800;
+	    } else if ((ch&0xf8) == 0xf0) {
+		uc = ch & 0x07;
+		need = 3;
+		error = i;
+		min_uc = 0x10000;
+	    } else {
+	        // Error
+                qch = addOne(qch, result);
+	        *qch++ = TQChar(0xdbff);
+		*qch++ = TQChar(0xde00+((uchar)utf8[i]));
+	    }
+	}
+    }
+    if (need) {
+	// we have some invalid characters remaining we need to add to the string
+	for (int i = error; i < len; ++i) {
+            qch = addOne(qch, result);
+	    *qch++ = TQChar(0xdbff);
+	    *qch++ = TQChar(0xde00+((uchar)utf8[i]));
+	}
+    }
+
+    result.truncate( qch - result.tqunicode() );
+    return result;
+}
+
+/*!
+    Returns the Unicode string decoded from the first \a len
+    bytes of \a ascii, ignoring the rest of \a ascii. If \a len
+    is -1 then the length of \a ascii is used. If \a len is bigger
+    than the length of \a ascii then it will use the length of \a
+    ascii.
+
+    If a codec has been set using TQTextCodec::codecForCStrings(),
+    it is used to convert the string from 8-bit characters to Unicode.
+    Otherwise, this function does the same as tqfromLatin1().
+
+    This is the same as the TQString(const char*) constructor, but you
+    can make that constructor invisible if you compile with the define
+    \c TQT_NO_CAST_ASCII, in which case you can explicitly create a
+    TQString from 8-bit ASCII text using this function.
+
+    \code
+        TQString str = TQString::fromAscii( "123456789", 5 );
+        // str == "12345"
+    \endcode
+ */
+TQString TQString::fromAscii( const char* ascii, int len )
+{
+#ifndef TQT_NO_TEXTCODEC
+    if ( TQTextCodec::codecForCStrings() ) {
+	if ( !ascii )
+	    return TQString::null;
+	if ( len < 0 )
+	    len = (int)strlen( ascii );
+	if ( len == 0 || *ascii == '\0' )
+	    return TQString::tqfromLatin1( "" );
+	return TQTextCodec::codecForCStrings()->toUnicode( ascii, len );
+    }
+#endif
+    return tqfromLatin1( ascii, len );
+}
+
+
+/*!
+    Returns the Unicode string decoded from the first \a len
+    bytes of \a chars, ignoring the rest of \a chars. If \a len
+    is -1 then the length of \a chars is used. If \a len is bigger
+    than the length of \a chars then it will use the length of \a
+    chars.
+
+    \sa fromAscii()
+*/
+TQString TQString::tqfromLatin1( const char* chars, int len )
+{
+    uint l;
+    TQChar *uc;
+    if ( len < 0 )
+	 len = -1;
+    uc = internalLatin1ToUnicode( chars, &l, len );
+    return TQString( new TQStringData(uc, l, l), TRUE );
+}
+
+/*!
+    \fn const TQChar* TQString::tqunicode() const
+
+    Returns the Unicode representation of the string. The result
+    remains valid until the string is modified.
+*/
+
+/*!
+    Returns the string encoded in a locale-specific format. On X11,
+    this is the TQTextCodec::codecForLocale(). On Windows, it is a
+    system-defined encoding. On Mac OS X, this always uses UTF-8 as
+    the encoding.
+
+    See TQTextCodec for more diverse coding/decoding of Unicode
+    strings.
+
+    \sa fromLocal8Bit(), ascii(), latin1(), utf8()
+*/
+
+TQCString TQString::local8Bit() const
+{
+#ifdef TQT_NO_TEXTCODEC
+    return latin1();
+#else
+#ifdef TQ_WS_X11
+    TQTextCodec* codec = TQTextCodec::codecForLocale();
+    return codec
+	    ? codec->fromUnicode(*this)
+	    : TQCString(latin1());
+#endif
+#if defined( TQ_WS_MACX )
+    return utf8();
+#endif
+#if defined( TQ_WS_MAC9 )
+    return TQCString(latin1()); //I'm evil..
+#endif
+#ifdef TQ_WS_WIN
+    return isNull() ? TQCString("") : qt_winTQString2MB( *this );
+#endif
+#ifdef TQ_WS_TQWS
+    return utf8(); // ### if there is any 8 bit format supported?
+#endif
+#endif
+}
+
+/*!
+    Returns the Unicode string decoded from the first \a len
+    bytes of \a local8Bit, ignoring the rest of \a local8Bit. If
+    \a len is -1 then the length of \a local8Bit is used. If \a len is
+    bigger than the length of \a local8Bit then it will use the length
+    of \a local8Bit.
+
+    \code
+	TQString str = TQString::fromLocal8Bit( "123456789", 5 );
+	// str == "12345"
+    \endcode
+
+    \a local8Bit is assumed to be encoded in a locale-specific format.
+
+    See TQTextCodec for more diverse coding/decoding of Unicode strings.
+*/
+TQString TQString::fromLocal8Bit( const char* local8Bit, int len )
+{
+#ifdef TQT_NO_TEXTCODEC
+    return tqfromLatin1( local8Bit, len );
+#else
+
+    if ( !local8Bit )
+	return TQString::null;
+#ifdef TQ_WS_X11
+    TQTextCodec* codec = TQTextCodec::codecForLocale();
+    if ( len < 0 )
+	len = strlen( local8Bit );
+    return codec
+	    ? codec->toUnicode( local8Bit, len )
+	    : tqfromLatin1( local8Bit, len );
+#endif
+#if defined( TQ_WS_MAC )
+    return fromUtf8(local8Bit,len);
+#endif
+// Should this be OS_WIN32?
+#ifdef TQ_WS_WIN
+    if ( len >= 0 ) {
+	TQCString s(local8Bit,len+1);
+	return qt_winMB2TQString(s);
+    }
+    return qt_winMB2TQString( local8Bit );
+#endif
+#ifdef TQ_WS_TQWS
+    return fromUtf8(local8Bit,len);
+#endif
+#endif // TQT_NO_TEXTCODEC
+}
+
+/*!
+    \fn TQString::operator const char *() const
+
+    Returns ascii(). Be sure to see the warnings documented in the
+    ascii() function. Note that for new code which you wish to be
+    strictly Unicode-clean, you can define the macro \c
+    TQT_NO_ASCII_CAST when compiling your code to hide this function so
+    that automatic casts are not done. This has the added advantage
+    that you catch the programming error described in operator!().
+*/
+
+/*!
+    \fn TQString::operator std::string() const
+
+    Returns ascii() as a std::string.
+
+    \warning The function may cause an application to crash if a static C run-time is in use.
+    This can happen in Microsoft Visual C++ if TQt is configured as single-threaded. A safe
+    alternative is to call ascii() directly and construct a std::string manually.
+*/
+
+/*!
+    Returns the TQString as a zero terminated array of unsigned shorts
+    if the string is not null; otherwise returns zero.
+
+    The result remains valid so long as one unmodified
+    copy of the source string exists.
+*/
+const unsigned short *TQString::ucs2() const
+{
+    if ( ! d->tqunicode )
+	return 0;
+    unsigned int len = d->len;
+    if ( d->maxl < len + 1 ) {
+	// detach, grow or shrink
+	uint newMax = computeNewMax( len + 1 );
+	TQChar* nd = TQT_ALLOC_TQCHAR_VEC( newMax );
+	if ( nd ) {
+	    if ( d->tqunicode )
+		memcpy( nd, d->tqunicode, sizeof(TQChar)*len );
+	    ((TQString *)this)->deref();
+	    ((TQString *)this)->d = new TQStringData( nd, len, newMax );
+	}
+    }
+    d->tqunicode[len] = 0;
+    return (unsigned short *) d->tqunicode;
+}
+
+/*!
+  Constructs a string that is a deep copy of \a str, interpreted as a
+  UCS2 encoded, zero terminated, Unicode string.
+
+  If \a str is 0, then a null string is created.
+
+  \sa isNull()
+*/
+TQString TQString::fromUcs2( const unsigned short *str )
+{
+    if ( !str ) {
+	return TQString::null;
+    } else {
+	int length = 0;
+	while ( str[length] != 0 )
+	    length++;
+	TQChar* uc = TQT_ALLOC_TQCHAR_VEC( length );
+	memcpy( uc, str, length*sizeof(TQChar) );
+	return TQString( new TQStringData( uc, length, length ), TRUE );
+    }
+}
+
+/*!
+  \fn TQChar TQString::at( uint ) const
+
+    Returns the character at index \a i, or 0 if \a i is beyond the
+    length of the string.
+
+    \code
+	const TQString string( "abcdefgh" );
+	TQChar ch = string.at( 4 );
+	// ch == 'e'
+    \endcode
+
+    If the TQString is not const (i.e. const TQString) or const& (i.e.
+    const TQString &), then the non-const overload of at() will be used
+    instead.
+*/
+
+/*!
+    \fn TQChar TQString::constref(uint i) const
+
+    Returns the TQChar at index \a i by value.
+
+    Equivalent to at(\a i).
+
+    \sa ref()
+*/
+
+/*!
+    \fn TQChar& TQString::ref(uint i)
+
+    Returns the TQChar at index \a i by reference, expanding the string
+    with TQChar::null if necessary. The resulting reference can be
+    assigned to, or otherwise used immediately, but becomes invalid
+    once furher modifications are made to the string.
+
+    \code
+	TQString string("ABCDEF");
+	TQChar ch = string.ref( 3 );         // ch == 'D'
+    \endcode
+
+    \sa constref()
+*/
+
+/*!
+    \fn TQChar TQString::operator[]( int ) const
+
+    Returns the character at index \a i, or TQChar::null if \a i is
+    beyond the length of the string.
+
+    If the TQString is not const (i.e., const TQString) or const\&
+    (i.e., const TQString\&), then the non-const overload of operator[]
+    will be used instead.
+*/
+
+/*!
+    \fn TQCharRef TQString::operator[]( int )
+
+    \overload
+
+    The function returns a reference to the character at index \a i.
+    The resulting reference can then be assigned to, or used
+    immediately, but it will become invalid once further modifications
+    are made to the original string.
+
+    If \a i is beyond the length of the string then the string is
+    expanded with TQChar::nulls, so that the TQCharRef references a
+    valid (null) character in the string.
+
+    The TQCharRef internal class can be used much like a constant
+    TQChar, but if you assign to it, you change the original string
+    (which will detach itself because of TQString's copy-on-write
+    semantics). You will get compilation errors if you try to use the
+    result as anything but a TQChar.
+*/
+
+/*!
+    \fn TQCharRef TQString::at( uint i )
+
+    \overload
+
+    The function returns a reference to the character at index \a i.
+    The resulting reference can then be assigned to, or used
+    immediately, but it will become invalid once further modifications
+    are made to the original string.
+
+    If \a i is beyond the length of the string then the string is
+    expanded with TQChar::null.
+*/
+
+/*
+  Internal chunk of code to handle the
+  uncommon cases of at() above.
+*/
+void TQString::subat( uint i )
+{
+    uint olen = d->len;
+    if ( i >= olen ) {
+	setLength( i+1 );               // i is index; i+1 is needed length
+	for ( uint j=olen; j<=i; j++ )
+	    d->tqunicode[j] = TQChar::null;
+    } else {
+	// Just be sure to detach
+	real_detach();
+    }
+}
+
+
+/*!
+    Resizes the string to \a len characters and copies \a tqunicode into
+    the string. If \a tqunicode is 0, nothing is copied, but the
+    string is still resized to \a len. If \a len is zero, then the
+    string becomes a \link isNull() null\endlink string.
+
+    \sa setLatin1(), isNull()
+*/
+
+TQString& TQString::setUnicode( const TQChar *tqunicode, uint len )
+{
+    if ( len == 0 ) {                           // set to null string
+	if ( d != shared_null ) {               // beware of nullstring being set to nullstring
+	    deref();
+	    d = shared_null ? shared_null : makeSharedNull();
+	    d->ref();
+	}
+    } else if ( d->count != 1 || len > d->maxl ||
+		( len * 4 < d->maxl && d->maxl > 4 ) ) {
+	// detach, grown or shrink
+	uint newMax = computeNewMax( len );
+	TQChar* nd = TQT_ALLOC_TQCHAR_VEC( newMax );
+	if ( tqunicode )
+	    memcpy( nd, tqunicode, sizeof(TQChar)*len );
+	deref();
+	d = new TQStringData( nd, len, newMax );
+    } else {
+	d->len = len;
+	d->setDirty();
+	if ( tqunicode )
+	    memcpy( d->tqunicode, tqunicode, sizeof(TQChar)*len );
+    }
+    return *this;
+}
+
+/*!
+    Resizes the string to \a len characters and copies \a
+    tqunicode_as_ushorts into the string (on some X11 client platforms
+    this will involve a byte-swapping pass).
+
+    If \a tqunicode_as_ushorts is 0, nothing is copied, but the string
+    is still resized to \a len. If \a len is zero, the string becomes
+    a \link isNull() null\endlink string.
+
+    \sa setLatin1(), isNull()
+*/
+TQString& TQString::setUnicodeCodes( const ushort* tqunicode_as_ushorts, uint len )
+{
+     return setUnicode((const TQChar*)tqunicode_as_ushorts, len);
+}
+
+
+/*!
+    Sets this string to \a str, interpreted as a classic 8-bit ASCII C
+    string. If \a len is -1 (the default), then it is set to
+    strlen(str).
+
+    If \a str is 0 a null string is created. If \a str is "", an empty
+    string is created.
+
+    \sa isNull(), isEmpty()
+*/
+
+TQString &TQString::setAscii( const char *str, int len )
+{
+#ifndef TQT_NO_TEXTCODEC
+    if ( TQTextCodec::codecForCStrings() ) {
+	*this = TQString::fromAscii( str, len );
+	return *this;
+    }
+#endif // TQT_NO_TEXTCODEC
+    return setLatin1( str, len );
+}
+
+/*!
+    Sets this string to \a str, interpreted as a classic Latin-1 C
+    string. If \a len is -1 (the default), then it is set to
+    strlen(str).
+
+    If \a str is 0 a null string is created. If \a str is "", an empty
+    string is created.
+
+    \sa isNull(), isEmpty()
+*/
+
+TQString &TQString::setLatin1( const char *str, int len )
+{
+    if ( str == 0 )
+	return setUnicode(0,0);
+    if ( len < 0 )
+	len = int(strlen( str ));
+    if ( len == 0 ) {                           // won't make a null string
+	*this = TQString::tqfromLatin1( "" );
+    } else {
+	setUnicode( 0, len );                   // resize but not copy
+	TQChar *p = d->tqunicode;
+	while ( len-- )
+	    *p++ = *str++;
+    }
+    return *this;
+}
+
+/*! \internal
+ */
+void TQString::checkSimpleText() const
+{
+    TQChar *p = d->tqunicode;
+    TQChar *end = p + d->len;
+    while ( p < end ) {
+	ushort uc = p->tqunicode();
+	// sort out regions of complex text formatting
+	if ( uc > 0x058f && ( uc < 0x1100 || uc > 0xfb0f ) ) {
+	    d->issimpletext = FALSE;
+	    return;
+	}
+	p++;
+    }
+    d->issimpletext = TRUE;
+}
+
+/*! \fn bool TQString::simpleText() const
+  \internal
+*/
+
+/*! \internal
+ */
+bool TQString::isRightToLeft() const
+{
+    int len = length();
+    TQChar *p = d->tqunicode;
+    while ( len-- ) {
+	switch( ::direction( *p ) )
+	{
+	case TQChar::DirL:
+	case TQChar::DirLRO:
+	case TQChar::DirLRE:
+	    return FALSE;
+	case TQChar::DirR:
+	case TQChar::DirAL:
+	case TQChar::DirRLO:
+	case TQChar::DirRLE:
+	    return TRUE;
+	default:
+	    break;
+	}
+	++p;
+    }
+    return FALSE;
+}
+
+
+/*!
+    \fn int TQString::compare( const TQString & s1, const TQString & s2 )
+
+    Lexically compares \a s1 with \a s2 and returns an integer less
+    than, equal to, or greater than zero if \a s1 is less than, equal
+    to, or greater than \a s2.
+
+    The comparison is based exclusively on the numeric Unicode values
+    of the characters and is very fast, but is not what a human would
+    expect. Consider sorting user-interface strings with
+    TQString::localeAwareCompare().
+
+    \code
+	int a = TQString::compare( "def", "abc" );   // a > 0
+	int b = TQString::compare( "abc", "def" );   // b < 0
+	int c = TQString::compare( "abc", "abc" );   // c == 0
+    \endcode
+*/
+
+/*!
+    \overload
+
+   Lexically compares this string with \a s and returns an integer
+   less than, equal to, or greater than zero if it is less than, equal
+   to, or greater than \a s.
+*/
+int TQString::compare( const TQString& s ) const
+{
+    return ucstrcmp( *this, s );
+}
+
+/*!
+    \fn int TQString::localeAwareCompare( const TQString & s1, const TQString & s2 )
+
+    Compares \a s1 with \a s2 and returns an integer less than, equal
+    to, or greater than zero if \a s1 is less than, equal to, or
+    greater than \a s2.
+
+    The comparison is performed in a locale- and also
+    platform-dependent manner. Use this function to present sorted
+    lists of strings to the user.
+
+    \sa TQString::compare() TQTextCodec::locale()
+*/
+
+/*!
+    \overload
+
+    Compares this string with \a s.
+*/
+
+#if !defined(CSTR_LESS_THAN)
+#define CSTR_LESS_THAN    1
+#define CSTR_ETQUAL        2
+#define CSTR_GREATER_THAN 3
+#endif
+
+int TQString::localeAwareCompare( const TQString& s ) const
+{
+    // do the right thing for null and empty
+    if ( isEmpty() || s.isEmpty() )
+	return compare( s );
+
+#if defined(TQ_WS_WIN)
+    int res;
+    TQT_WA( {
+	const TCHAR* s1 = (TCHAR*)ucs2();
+	const TCHAR* s2 = (TCHAR*)s.ucs2();
+	res = CompareStringW( LOCALE_USER_DEFAULT, 0, s1, length(), s2, s.length() );
+    } , {
+	TQCString s1 = local8Bit();
+	TQCString s2 = s.local8Bit();
+	res = CompareStringA( LOCALE_USER_DEFAULT, 0, s1.data(), s1.length(), s2.data(), s2.length() );
+    } );
+
+    switch ( res ) {
+    case CSTR_LESS_THAN:
+	return -1;
+    case CSTR_GREATER_THAN:
+	return 1;
+    default:
+	return 0;
+    }
+#elif defined(TQ_WS_MACX)
+    int delta = 0;
+#if !defined(TQT_NO_TEXTCODEC)
+    TQTextCodec *codec = TQTextCodec::codecForLocale();
+    if (codec)
+        delta = strcoll(codec->fromUnicode(*this), codec->fromUnicode(s));
+    if (delta == 0)
+#endif
+	delta = ucstrcmp(*this, s);
+    return delta;
+#elif defined(TQ_WS_X11)
+    // declared in <string.h>
+    int delta = strcoll( local8Bit(), s.local8Bit() );
+    if ( delta == 0 )
+	delta = ucstrcmp( *this, s );
+    return delta;
+#else
+    return ucstrcmp( *this, s );
+#endif
+}
+
+bool operator==( const TQString &s1, const TQString &s2 )
+{
+    if ( s1.tqunicode() == s2.tqunicode() )
+	return TRUE;
+    return (s1.length() == s2.length()) && s1.isNull() == s2.isNull() &&
+	 (memcmp((char*)s1.tqunicode(),(char*)s2.tqunicode(),
+		 s1.length()*sizeof(TQChar)) == 0 );
+}
+
+bool operator!=( const TQString &s1, const TQString &s2 )
+{ return !(s1==s2); }
+
+bool operator<( const TQString &s1, const TQString &s2 )
+{ return ucstrcmp(s1,s2) < 0; }
+
+bool operator<=( const TQString &s1, const TQString &s2 )
+{ return ucstrcmp(s1,s2) <= 0; }
+
+bool operator>( const TQString &s1, const TQString &s2 )
+{ return ucstrcmp(s1,s2) > 0; }
+
+bool operator>=( const TQString &s1, const TQString &s2 )
+{ return ucstrcmp(s1,s2) >= 0; }
+
+
+bool operator==( const TQString &s1, const char *s2 )
+{
+    if ( !s2 )
+	return s1.isNull();
+
+    int len = s1.length();
+    const TQChar *uc = s1.tqunicode();
+    while ( len ) {
+	if ( !(*s2) || uc->tqunicode() != (uchar) *s2 )
+	    return FALSE;
+	++uc;
+	++s2;
+	--len;
+    }
+    return !*s2;
+}
+
+bool operator==( const char *s1, const TQString &s2 )
+{ return (s2 == s1); }
+
+bool operator!=( const TQString &s1, const char *s2 )
+{ return !(s1==s2); }
+
+bool operator!=( const char *s1, const TQString &s2 )
+{ return !(s1==s2); }
+
+bool operator<( const TQString &s1, const char *s2 )
+{ return ucstrcmp(s1,s2) < 0; }
+
+bool operator<( const char *s1, const TQString &s2 )
+{ return ucstrcmp(s1,s2) < 0; }
+
+bool operator<=( const TQString &s1, const char *s2 )
+{ return ucstrcmp(s1,s2) <= 0; }
+
+bool operator<=( const char *s1, const TQString &s2 )
+{ return ucstrcmp(s1,s2) <= 0; }
+
+bool operator>( const TQString &s1, const char *s2 )
+{ return ucstrcmp(s1,s2) > 0; }
+
+bool operator>( const char *s1, const TQString &s2 )
+{ return ucstrcmp(s1,s2) > 0; }
+
+bool operator>=( const TQString &s1, const char *s2 )
+{ return ucstrcmp(s1,s2) >= 0; }
+
+bool operator>=( const char *s1, const TQString &s2 )
+{ return ucstrcmp(s1,s2) >= 0; }
+
+
+/*****************************************************************************
+  Documentation for TQString related functions
+ *****************************************************************************/
+
+/*!
+    \fn bool operator==( const TQString &s1, const TQString &s2 )
+
+    \relates TQString
+
+    Returns TRUE if \a s1 is equal to \a s2; otherwise returns FALSE.
+    Note that a null string is not equal to a not-null empty string.
+
+    Equivalent to compare(\a s1, \a s2) == 0.
+
+    \sa isNull(), isEmpty()
+*/
+
+/*!
+    \fn bool operator==( const TQString &s1, const char *s2 )
+
+    \overload
+    \relates TQString
+
+    Returns TRUE if \a s1 is equal to \a s2; otherwise returns FALSE.
+    Note that a null string is not equal to a not-null empty string.
+
+    Equivalent to compare(\a s1, \a s2) == 0.
+
+    \sa isNull(), isEmpty()
+*/
+
+/*!
+    \fn bool operator==( const char *s1, const TQString &s2 )
+
+    \overload
+    \relates TQString
+
+    Returns TRUE if \a s1 is equal to \a s2; otherwise returns FALSE.
+    Note that a null string is not equal to a not-null empty string.
+
+    Equivalent to compare(\a s1, \a s2) == 0.
+
+    \sa isNull(), isEmpty()
+*/
+
+/*!
+    \fn bool operator!=( const TQString &s1, const TQString &s2 )
+
+    \relates TQString
+
+    Returns TRUE if \a s1 is not equal to \a s2; otherwise returns FALSE.
+    Note that a null string is not equal to a not-null empty string.
+
+    Equivalent to compare(\a s1, \a s2) != 0.
+
+    \sa isNull(), isEmpty()
+*/
+
+/*!
+    \fn bool operator!=( const TQString &s1, const char *s2 )
+
+    \overload
+    \relates TQString
+
+    Returns TRUE if \a s1 is not equal to \a s2; otherwise returns FALSE.
+    Note that a null string is not equal to a not-null empty string.
+
+    Equivalent to compare(\a s1, \a s2) != 0.
+
+    \sa isNull(), isEmpty()
+*/
+
+/*!
+    \fn bool operator!=( const char *s1, const TQString &s2 )
+
+    \overload
+    \relates TQString
+
+    Returns TRUE if \a s1 is not equal to \a s2; otherwise returns FALSE.
+    Note that a null string is not equal to a not-null empty string.
+
+    Equivalent to compare(\a s1, \a s2) != 0.
+
+    \sa isNull(), isEmpty()
+*/
+
+/*!
+    \fn bool operator<( const TQString &s1, const char *s2 )
+
+    \relates TQString
+
+    Returns TRUE if \a s1 is lexically less than \a s2; otherwise returns FALSE.
+    The comparison is case sensitive.
+
+    Equivalent to compare(\a s1, \a s2) \< 0.
+*/
+
+/*!
+    \fn bool operator<( const char *s1, const TQString &s2 )
+
+    \overload
+    \relates TQString
+
+    Returns TRUE if \a s1 is lexically less than \a s2; otherwise returns FALSE.
+    The comparison is case sensitive.
+
+    Equivalent to compare(\a s1, \a s2) \< 0.
+*/
+
+/*!
+    \fn bool operator<=( const TQString &s1, const char *s2 )
+
+    \relates TQString
+
+    Returns TRUE if \a s1 is lexically less than or equal to \a s2;
+    otherwise returns FALSE.
+    The comparison is case sensitive.
+    Note that a null string is not equal to a not-null empty string.
+
+    Equivalent to compare(\a s1,\a s2) \<= 0.
+
+    \sa isNull(), isEmpty()
+*/
+
+/*!
+    \fn bool operator<=( const char *s1, const TQString &s2 )
+
+    \overload
+    \relates TQString
+
+    Returns TRUE if \a s1 is lexically less than or equal to \a s2;
+    otherwise returns FALSE.
+    The comparison is case sensitive.
+    Note that a null string is not equal to a not-null empty string.
+
+    Equivalent to compare(\a s1, \a s2) \<= 0.
+
+    \sa isNull(), isEmpty()
+*/
+
+/*!
+    \fn bool operator>( const TQString &s1, const char *s2 )
+
+    \relates TQString
+
+    Returns TRUE if \a s1 is lexically greater than \a s2; otherwise
+    returns FALSE.
+    The comparison is case sensitive.
+
+    Equivalent to compare(\a s1, \a s2) \> 0.
+*/
+
+/*!
+    \fn bool operator>( const char *s1, const TQString &s2 )
+
+    \overload
+    \relates TQString
+
+    Returns TRUE if \a s1 is lexically greater than \a s2; otherwise
+    returns FALSE.
+    The comparison is case sensitive.
+
+    Equivalent to compare(\a s1, \a s2) \> 0.
+*/
+
+/*!
+    \fn bool operator>=( const TQString &s1, const char *s2 )
+
+    \relates TQString
+
+    Returns TRUE if \a s1 is lexically greater than or equal to \a s2;
+    otherwise returns FALSE.
+    The comparison is case sensitive.
+    Note that a null string is not equal to a not-null empty string.
+
+    Equivalent to compare(\a s1, \a s2) \>= 0.
+
+    \sa isNull(), isEmpty()
+*/
+
+/*!
+    \fn bool operator>=( const char *s1, const TQString &s2 )
+
+    \overload
+    \relates TQString
+
+    Returns TRUE if \a s1 is lexically greater than or equal to \a s2;
+    otherwise returns FALSE.
+    The comparison is case sensitive.
+    Note that a null string is not equal to a not-null empty string.
+
+    Equivalent to compare(\a s1, \a s2) \>= 0.
+
+    \sa isNull(), isEmpty()
+*/
+
+/*!
+    \fn const TQString operator+( const TQString &s1, const TQString &s2 )
+
+    \relates TQString
+
+    Returns a string which is the result of concatenating the string
+    \a s1 and the string \a s2.
+
+    Equivalent to \a {s1}.append(\a s2).
+*/
+
+/*!
+    \fn const TQString operator+( const TQString &s1, const char *s2 )
+
+    \overload
+    \relates TQString
+
+    Returns a string which is the result of concatenating the string
+    \a s1 and character \a s2.
+
+    Equivalent to \a {s1}.append(\a s2).
+*/
+
+/*!
+    \fn const TQString operator+( const char *s1, const TQString &s2 )
+
+    \overload
+    \relates TQString
+
+    Returns a string which is the result of concatenating the
+    character \a s1 and string \a s2.
+*/
+
+/*!
+    \fn const TQString operator+( const TQString &s, char c )
+
+    \overload
+    \relates TQString
+
+    Returns a string which is the result of concatenating the string
+    \a s and character \a c.
+
+    Equivalent to \a {s}.append(\a c).
+*/
+
+/*!
+    \fn const TQString operator+( char c, const TQString &s )
+
+    \overload
+    \relates TQString
+
+    Returns a string which is the result of concatenating the
+    character \a c and string \a s.
+
+    Equivalent to \a {s}.prepend(\a c).
+*/
+
+
+/*****************************************************************************
+  TQString stream functions
+ *****************************************************************************/
+#ifndef TQT_NO_DATASTREAM
+/*!
+    \relates TQString
+
+    Writes the string \a str to the stream \a s.
+
+    See also \link datastreamformat.html Format of the TQDataStream operators \endlink
+*/
+
+TQDataStream &operator<<( TQDataStream &s, const TQString &str )
+{
+    if ( s.version() == 1 ) {
+	TQCString l( str.latin1() );
+	s << l;
+    }
+    else {
+	int byteOrder = s.byteOrder();
+	const TQChar* ub = str.tqunicode();
+	if ( ub || s.version() < 3 ) {
+	    static const uint auto_size = 1024;
+	    char t[auto_size];
+	    char *b;
+	    if ( str.length()*sizeof(TQChar) > auto_size ) {
+		b = new char[str.length()*sizeof(TQChar)];
+	    } else {
+		b = t;
+	    }
+	    int l = str.length();
+	    char *c=b;
+	    while ( l-- ) {
+		if ( byteOrder == TQDataStream::BigEndian ) {
+		    *c++ = (char)ub->row();
+		    *c++ = (char)ub->cell();
+		} else {
+		    *c++ = (char)ub->cell();
+		    *c++ = (char)ub->row();
+		}
+		ub++;
+	    }
+	    s.writeBytes( b, sizeof(TQChar)*str.length() );
+	    if ( str.length()*sizeof(TQChar) > auto_size )
+		delete [] b;
+	} else {
+	    // write null marker
+	    s << (TQ_UINT32)0xffffffff;
+	}
+    }
+    return s;
+}
+
+/*!
+    \relates TQString
+
+    Reads a string from the stream \a s into string \a str.
+
+    See also \link datastreamformat.html Format of the TQDataStream operators \endlink
+*/
+
+TQDataStream &operator>>( TQDataStream &s, TQString &str )
+{
+#ifdef TQT_TQSTRING_UCS_4
+#if defined(TQ_CC_GNU)
+#warning "operator>> not working properly"
+#endif
+#endif
+    if ( s.version() == 1 ) {
+	TQCString l;
+	s >> l;
+	str = TQString( l );
+    }
+    else {
+	TQ_UINT32 bytes = 0;
+	s >> bytes;                                     // read size of string
+	if ( bytes == 0xffffffff ) {                    // null string
+	    str = TQString::null;
+	} else if ( bytes > 0 ) {                       // not empty
+	    int byteOrder = s.byteOrder();
+	    str.setLength( bytes/2 );
+	    TQChar* ch = str.d->tqunicode;
+	    static const uint auto_size = 1024;
+	    char t[auto_size];
+	    char *b;
+	    if ( bytes > auto_size ) {
+		b = new char[bytes];
+	    } else {
+		b = t;
+	    }
+	    s.readRawBytes( b, bytes );
+	    int bt = bytes/2;
+	    char *oldb = b;
+	    while ( bt-- ) {
+		if ( byteOrder == TQDataStream::BigEndian )
+		    *ch++ = (ushort) (((ushort)b[0])<<8) | (uchar)b[1];
+		else
+		    *ch++ = (ushort) (((ushort)b[1])<<8) | (uchar)b[0];
+		b += 2;
+	    }
+	    if ( bytes > auto_size )
+		delete [] oldb;
+	} else {
+	    str = "";
+	}
+    }
+    return s;
+}
+#endif // TQT_NO_DATASTREAM
+
+/*****************************************************************************
+  TQConstString member functions
+ *****************************************************************************/
+
+/*!
+  \class TQConstString tqstring.h
+  \reentrant
+  \ingroup text
+  \brief The TQConstString class provides string objects using constant Unicode data.
+
+    In order to minimize copying, highly optimized applications can
+    use TQConstString to provide a TQString-compatible object from
+    existing Unicode data. It is then the programmer's responsibility
+    to ensure that the Unicode data exists for the entire lifetime of
+    the TQConstString object.
+
+    A TQConstString is created with the TQConstString constructor. The
+    string held by the object can be obtained by calling string().
+*/
+
+/*!
+    Constructs a TQConstString that uses the first \a length Unicode
+    characters in the array \a tqunicode. Any attempt to modify copies
+    of the string will cause it to create a copy of the data, thus it
+    remains forever unmodified.
+
+    The data in \a tqunicode is not copied. The caller must be able to
+    guarantee that \a tqunicode will not be deleted or modified.
+*/
+TQConstString::TQConstString( const TQChar* tqunicode, uint length ) :
+    TQString( new TQStringData( (TQChar*)tqunicode, length, length ), TRUE )
+{
+}
+
+/*!
+    Destroys the TQConstString, creating a copy of the data if other
+    strings are still using it.
+*/
+TQConstString::~TQConstString()
+{
+    if ( d->count > 1 ) {
+	TQChar* cp = TQT_ALLOC_TQCHAR_VEC( d->len );
+	memcpy( cp, d->tqunicode, d->len*sizeof(TQChar) );
+	d->tqunicode = cp;
+    } else {
+	d->tqunicode = 0;
+    }
+
+    // The original d->tqunicode is now unlinked.
+}
+
+/*!
+    \fn const TQString& TQConstString::string() const
+
+    Returns a constant string referencing the data passed during
+    construction.
+*/
+
+/*!
+    Returns TRUE if the string starts with \a s; otherwise returns
+    FALSE.
+
+    If \a cs is TRUE (the default), the search is case sensitive;
+    otherwise the search is case insensitive.
+
+    \code
+	TQString str( "Bananas" );
+	str.startsWith( "Ban" );     // returns TRUE
+	str.startsWith( "Car" );     // returns FALSE
+    \endcode
+
+    \sa endsWith()
+*/
+bool TQString::startsWith( const TQString& s, bool cs ) const
+{
+    if ( isNull() )
+	return s.isNull();
+    if ( s.length() > length() )
+	return FALSE;
+    if ( cs ) {
+        return memcmp((char*)d->tqunicode, (char*)s.d->tqunicode, s.length()*sizeof(TQChar)) == 0;
+    } else {
+	for ( int i = 0; i < (int) s.length(); i++ ) {
+	    if ( ::lower(d->tqunicode[i]) != ::lower(s.d->tqunicode[i]) )
+		return FALSE;
+	}
+    }
+    return TRUE;
+}
+
+bool TQString::startsWith( const TQString& s ) const
+{
+    return startsWith( s, TRUE );
+}
+
+/*!
+    Returns TRUE if the string ends with \a s; otherwise returns
+    FALSE.
+
+    If \a cs is TRUE (the default), the search is case sensitive;
+    otherwise the search is case insensitive.
+
+    \code
+	TQString str( "Bananas" );
+	str.endsWith( "anas" );         // returns TRUE
+	str.endsWith( "pple" );         // returns FALSE
+    \endcode
+
+    \sa startsWith()
+*/
+bool TQString::endsWith( const TQString& s, bool cs ) const
+{
+    if ( isNull() )
+	return s.isNull();
+    int pos = length() - s.length();
+    if ( pos < 0 )
+	return FALSE;
+    if ( cs ) {
+        return memcmp((char*)&d->tqunicode[pos], (char*)s.d->tqunicode, s.length()*sizeof(TQChar)) == 0;
+    } else {
+	for ( int i = 0; i < (int) s.length(); i++ ) {
+	    if ( ::lower(d->tqunicode[pos + i]) != ::lower(s.d->tqunicode[i]) )
+		return FALSE;
+	}
+    }
+    return TRUE;
+}
+
+bool TQString::endsWith( const TQString& s ) const
+{
+    return endsWith( s, TRUE );
+}
+
+/*! \fn void TQString::detach()
+  If the string does not share its data with another TQString instance,
+  nothing happens; otherwise the function creates a new, unique copy of
+  this string. This function is called whenever the string is modified. The
+  implicit sharing mechanism is implemented this way.
+*/
+
+#if defined(TQ_OS_WIN32)
+
+#include <windows.h>
+
+/*!
+  \obsolete
+
+  Returns a static Windows TCHAR* from a TQString, adding NUL if \a
+  addnul is TRUE.
+
+  The lifetime of the return value is until the next call to this function,
+  or until the last copy of str is deleted, whatever comes first.
+
+  Use ucs2() instead.
+*/
+const void* qt_winTchar(const TQString& str, bool)
+{
+    // So that the return value lives long enough.
+    static TQString str_cache;
+    str_cache = str;
+#ifdef UNICODE
+    return str_cache.ucs2();
+#else
+    return str_cache.latin1();
+#endif
+}
+
+/*!
+    Makes a new '\0'-terminated Windows TCHAR* from a TQString.
+*/
+void* qt_winTchar_new(const TQString& str)
+{
+    if ( str.isNull() )
+	return 0;
+    int l = str.length()+1;
+    TCHAR *tc = new TCHAR[ l ];
+#ifdef UNICODE
+    memcpy( tc, str.ucs2(), sizeof(TCHAR)*l );
+#else
+    memcpy( tc, str.latin1(), sizeof(TCHAR)*l );
+#endif
+    return tc;
+}
+
+/*!
+    Makes a TQString from a Windows TCHAR*.
+*/
+TQString qt_winTQString(void* tc)
+{
+#ifdef UNICODE
+    return TQString::fromUcs2( (ushort*)tc );
+#else
+    return TQString::tqfromLatin1( (TCHAR *)tc );
+#endif
+}
+
+TQCString qt_winTQString2MB( const TQString& s, int uclen )
+{
+    if ( uclen < 0 )
+	uclen = s.length();
+    if ( s.isNull() )
+	return TQCString();
+    if ( uclen == 0 )
+	return TQCString("");
+    BOOL used_def;
+    TQCString mb(4096);
+    int len;
+    while ( !(len=WideCharToMultiByte(CP_ACP, 0, (const WCHAR*)s.tqunicode(), uclen,
+		mb.data(), mb.size()-1, 0, &used_def)) )
+    {
+	int r = GetLastError();
+	if ( r == ERROR_INSUFFICIENT_BUFFER ) {
+	    mb.resize(1+WideCharToMultiByte( CP_ACP, 0,
+				(const WCHAR*)s.tqunicode(), uclen,
+				0, 0, 0, &used_def));
+		// and try again...
+	} else {
+#ifndef TQT_NO_DEBUG
+	    // Fail.
+	    qWarning("WideCharToMultiByte cannot convert multibyte text (error %d): %s (UTF8)",
+		r, s.utf8().data());
+#endif
+	    break;
+	}
+    }
+    mb[len]='\0';
+    return mb;
+}
+
+// WATCH OUT: mblen must include the NUL (or just use -1)
+TQString qt_winMB2TQString( const char* mb, int mblen )
+{
+    if ( !mb || !mblen )
+	return TQString::null;
+    const int wclen_auto = 4096;
+    WCHAR wc_auto[wclen_auto];
+    int wclen = wclen_auto;
+    WCHAR *wc = wc_auto;
+    int len;
+    while ( !(len=MultiByteToWideChar( CP_ACP, MB_PRECOMPOSED,
+		mb, mblen, wc, wclen )) )
+    {
+	int r = GetLastError();
+	if ( r == ERROR_INSUFFICIENT_BUFFER ) {
+	    if ( wc != wc_auto ) {
+		qWarning("Size changed in MultiByteToWideChar");
+		break;
+	    } else {
+		wclen = MultiByteToWideChar( CP_ACP, MB_PRECOMPOSED,
+				    mb, mblen, 0, 0 );
+		wc = new WCHAR[wclen];
+		// and try again...
+	    }
+	} else {
+	    // Fail.
+	    qWarning("MultiByteToWideChar cannot convert multibyte text");
+	    break;
+	}
+    }
+    if ( len <= 0 )
+	return TQString::null;
+    TQString s( (TQChar*)wc, len - 1 ); // len - 1: we don't want terminator
+    if ( wc != wc_auto )
+	delete [] wc;
+    return s;
+}
+
+#endif // TQ_OS_WIN32
+
+#endif // USE_QT4
diff --git a/tqtinterface/qt4/src/tools/tqstring.h b/tqtinterface/qt4/src/tools/tqstring.h
new file mode 100644
index 0000000..b4db802
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqstring.h
@@ -0,0 +1,1684 @@
+/****************************************************************************
+**
+** Definition of the TQString class, and related Unicode functions.
+**
+** Created : 920609
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQSTRING_H
+#define TQSTRING_H
+
+#include "tqtglobaldefines.h"
+
+#ifndef TQT_H
+#include "tqcstring.h"
+#endif // TQT_H
+
+#ifdef USE_QT4
+
+#include <Qt/qstring.h>
+#include <Qt/qmetatype.h>
+
+#endif // USE_QT4
+
+#ifndef TQT_NO_CAST_ASCII
+#include <limits.h>
+#include <string>
+#endif
+
+#ifndef TQT_NO_STL
+#if defined ( TQ_CC_MSVC_NET ) && _MSC_VER < 1310 // Avoids nasty warning for xlocale, line 450
+#  pragma warning ( push )
+#  pragma warning ( disable : 4189 )
+#  include <string>
+#  pragma warning ( pop )
+#else
+#  include <string>
+#endif
+#if defined(TQ_WRONG_SB_CTYPE_MACROS) && defined(_SB_CTYPE_MACROS)
+#undef _SB_CTYPE_MACROS
+#endif
+#endif
+
+#ifdef USE_QT4
+
+class TQCharRef;
+
+class TQ_EXPORT TQChar : public QChar
+{
+public:
+	enum SpecialCharacter {
+		Null = Null,
+		Nbsp = Nbsp,
+		ReplacementCharacter = ReplacementCharacter,
+		ObjectReplacementCharacter = ObjectReplacementCharacter,
+		ByteOrderMark = ByteOrderMark,
+		ByteOrderSwapped = ByteOrderSwapped,
+
+// 		null = Null,
+// 		tqreplacement = ReplacementCharacter,
+// 		byteOrderMark = ByteOrderMark,
+// 		byteOrderSwapped = ByteOrderSwapped,
+// 		nbsp = Nbsp,
+
+		ParagraphSeparator = ParagraphSeparator,
+		LineSeparator = LineSeparator
+	};
+
+	TQT_STATIC_CONST TQChar null;
+	TQT_STATIC_CONST TQChar tqreplacement;
+	TQT_STATIC_CONST TQChar byteOrderMark;
+	TQT_STATIC_CONST TQChar byteOrderSwapped;
+	TQT_STATIC_CONST TQChar nbsp;
+
+	TQChar() : QChar() {}
+	TQChar( char c ) : QChar( c ) {}
+	TQChar( uchar c ) : QChar( c ) {}
+	TQChar( uchar c, uchar r ) : QChar( c, r ) {}
+	TQChar( const QChar& c ) : QChar( c ) {}
+	TQChar( ushort rc ) : QChar( rc ) {}
+	TQChar( short rc ) : QChar( rc ) {}
+	TQChar( uint rc ) : QChar( rc ) {}
+	TQChar( int rc ) : QChar( rc ) {}
+	TQChar(TQChar::SpecialCharacter sc) : QChar( (QChar::SpecialCharacter)sc ) {}
+
+	inline TQChar lower() const { return toLower(); }
+	inline TQChar upper() const { return toUpper(); }
+
+#ifdef Q_COMPILER_MANGLES_RETURN_TYPE
+	inline const char latin1() const { return toLatin1(); }
+	inline const char ascii() const { return toAscii(); }
+#else
+	inline char latin1() const { return toLatin1(); }
+	inline char ascii() const { return toAscii(); }
+#endif
+
+#ifndef TQT_NO_CAST_ASCII
+	inline operator char() const { return latin1(); }
+#endif
+
+	static inline bool networkOrdered() {
+		return QSysInfo::ByteOrder == QSysInfo::BigEndian;
+	}
+
+	inline TQChar &operator=( char ch ) { this->QChar::operator=(ch); return *this; }
+
+	inline ushort tqunicode() const { return unicode(); }
+	inline bool mirrored() const { return hasMirrored(); }
+
+	using QChar::operator=;
+};
+
+Q_DECLARE_METATYPE(TQChar)
+
+inline bool operator==( char ch, QChar c ) { return (TQChar(ch) == c); }
+inline bool operator==( QChar c, char ch ) { return (TQChar(ch) == c); }
+inline bool operator!=( char ch, QChar c ) { return (TQChar(ch) != c); }
+inline bool operator!=( QChar c, char ch ) { return (TQChar(ch) != c); }
+
+inline bool operator==( int ch, QChar c ) { return (TQChar(ch) == c); }
+inline bool operator==( QChar c, int ch ) { return (TQChar(ch) == c); }
+inline bool operator!=( int ch, QChar c ) { return (TQChar(ch) == c); }
+inline bool operator!=( QChar c, int ch ) { return (TQChar(ch) == c); }
+
+class TQ_EXPORT TQString : public QString
+{
+public:
+	TQString() : QString() {}
+	TQString( QChar tc ) : QString( tc ) {}
+	TQString( const QString &ts ) : QString( ts ) {}
+	TQString( const QByteArray &ba ) : QString( ba ) { int slen = int(strlen(ba)); if (length() > slen) truncate(slen); }
+	TQString( const QChar* tqunicode, uint length ) : QString( tqunicode, length ) {}
+#ifndef TQT_NO_CAST_ASCII
+	TQString( const char *str ) : QString( str ) {}
+#endif
+#ifndef TQT_NO_STL
+	TQString( const std::string &str ) : QString(str.c_str()) {}
+#endif
+
+	int tqfind( QChar c, int index=0, bool cs=TRUE ) const { return indexOf(c, index, (Qt::CaseSensitivity)cs); }
+	int tqfind( char c, int index=0, bool cs=TRUE ) const { return indexOf(c, index, (Qt::CaseSensitivity)cs); }
+	int tqfind( const QString &str, int index=0, bool cs=TRUE ) const { return indexOf(str, index, (Qt::CaseSensitivity)cs); }
+#ifndef TQT_NO_REGEXP
+	int tqfind( const QRegExp &qr, int index=0 ) const { return indexOf(qr, index); }
+#endif
+#ifndef TQT_NO_CAST_ASCII
+	int tqfind( const char* str, int index=0 ) const { return indexOf(str, index); }
+#endif
+	int tqfindRev( QChar c, int index=-1, bool cs=TRUE) const { return lastIndexOf(c, index, (Qt::CaseSensitivity)cs); }
+	int tqfindRev( char c, int index=-1, bool cs=TRUE) const { return lastIndexOf(c, index, (Qt::CaseSensitivity)cs); }
+	int tqfindRev( const QString &str, int index=-1, bool cs=TRUE) const { return lastIndexOf(str, index, (Qt::CaseSensitivity)cs); }
+#ifndef TQT_NO_REGEXP
+	int tqfindRev( const QRegExp &qr, int index=-1 ) const { return lastIndexOf(qr, index); }
+#endif
+#ifndef TQT_NO_CAST_ASCII
+	int tqfindRev( const char* str, int index=-1 ) const { return lastIndexOf(str, index); }
+#endif
+
+	const char* latin1() const { return latin1_helper(); }
+	const char* ascii() const { return ascii_helper(); }
+
+	bool simpleText() const;
+	void checkSimpleText() const;
+
+	TQString copy() const;
+
+	inline TQString lower() const { return toLower(); }
+	inline TQString upper() const { return toUpper(); }
+	inline TQString stripWhiteSpace() const { return trimmed(); }
+	inline TQString simplifyWhiteSpace() const { return simplified(); }
+
+	inline TQString fill( TQChar c, int len = -1 ) { return QString::fill(c, len); }
+
+	// QString::Null compatibility
+	struct Null { };
+	static const Null null;
+	inline TQString(const Null &) : QString() {}
+	inline TQString &operator=(const Null &) { *this = TQString(); return *this; }
+
+	int tqcontains( QChar c, bool cs=TRUE ) const { return count(c, (Qt::CaseSensitivity)cs); }
+	int tqcontains( char c, bool cs=TRUE ) const { return tqcontains(TQChar(c), cs); }
+#ifndef TQT_NO_CAST_ASCII
+	int  tqcontains( const char* str, bool cs=TRUE ) const { return count(str, (Qt::CaseSensitivity)cs); }
+#endif
+	int tqcontains( const QString &str, bool cs=TRUE ) const { return count(str, (Qt::CaseSensitivity)cs); }
+#ifndef TQT_NO_REGEXP
+	int tqcontains( const QRegExp &re ) const { return count(re); }
+#endif
+
+#ifndef QT_NO_CAST_TO_ASCII
+	inline operator const char *() const { return ascii_helper(); }
+#endif
+
+	inline bool tqstartsWith( const TQString& str ) const { return startsWith(str); }
+	inline bool tqstartsWith( const TQString& str, bool cs ) const { return startsWith(str, (cs)?Qt::CaseSensitive:Qt::CaseInsensitive); }
+	inline bool tqendsWith( const TQString& str ) const { return endsWith(str); }
+	inline bool tqendsWith( const TQString& str, bool cs ) const { return endsWith(str, (cs)?Qt::CaseSensitive:Qt::CaseInsensitive); }
+
+	TQCString utf8() const;
+	inline TQChar constref(uint i) const { return tqat(i); }
+	inline TQString leftJustify(int width, QChar aFill = QLatin1Char(' '), bool trunc=false) const { return leftJustified(width, aFill, trunc); }
+	inline TQString rightJustify(int width, QChar aFill = QLatin1Char(' '), bool trunc=false) const { return rightJustified(width, aFill, trunc); }
+
+	inline const TQChar* tqunicode() const { if (length() > 0) return static_cast<const TQChar*>(unicode()); else return static_cast<const TQChar*>(QString().unicode()); }
+	TQCString local8Bit() const;
+
+	inline TQString tqreplace(int i, int len, QChar after) { return tqreplace( i, len, &after, 1 ); }
+	inline TQString tqreplace(int i, int len, const QChar *s, int slen) {
+		// Mimic the old (undocumented) behavior
+		int newindex = i;
+		if (newindex > length()) newindex = length();
+		return replace( newindex, len, s, slen );
+	}
+	inline TQString tqreplace(int i, int len, const QString &after) { return tqreplace( i, len, TQString(after).tqunicode(), after.length() ); }
+	inline TQString tqreplace(QChar before, QChar after, Qt::CaseSensitivity cs = Qt::CaseSensitive) { return replace( before, after, cs  ); }
+	inline TQString tqreplace(const QChar *before, int blen, const QChar *after, int alen, Qt::CaseSensitivity cs = Qt::CaseSensitive) { return replace( before, blen, after, alen, cs ); }
+	inline TQString tqreplace(const QLatin1String &before, const QLatin1String &after, Qt::CaseSensitivity cs = Qt::CaseSensitive) { return replace( before, after, cs ); }
+	inline TQString tqreplace(const QLatin1String &before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive) { return replace( before, after, cs ); }
+	inline TQString tqreplace(const QString &before, const QLatin1String &after, Qt::CaseSensitivity cs = Qt::CaseSensitive) { return replace( before, after, cs ); }
+	inline TQString tqreplace(const QString &before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive) { return replace( before, after, cs ); }
+	inline TQString tqreplace(QChar c, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive) { return replace( c, after, cs ); }
+	inline TQString tqreplace(QChar c, const QLatin1String &after, Qt::CaseSensitivity cs = Qt::CaseSensitive) { return replace( c, after, cs ); }
+#ifndef QT_NO_REGEXP
+	inline TQString tqreplace(const QRegExp &rx, const QString &after) { return replace( rx, after ); }
+#endif
+	inline TQString tqreplace(const QString &before, const QString &after, bool cs) { return tqreplace(before, after, cs?Qt::CaseSensitive:Qt::CaseInsensitive); }
+
+	inline TQString tqsetNum( short a, int base=10 ) { return setNum(a, base); }
+	inline TQString tqsetNum( ushort a, int base=10 ) { return setNum(a, base); }
+	inline TQString tqsetNum( int a, int base=10 ) { return setNum(a, base); }
+	inline TQString tqsetNum( uint a, int base=10 ) { return setNum(a, base); }
+	inline TQString tqsetNum( long a, int base=10 ) { return setNum(a, base); }
+	inline TQString tqsetNum( ulong a, int base=10 ) { return setNum(a, base); }
+	inline TQString tqsetNum( TQ_LLONG a, int base=10 ) { return setNum(a, base); }
+	inline TQString tqsetNum( TQ_ULLONG a, int base=10 ) { return setNum(a, base); }
+	inline TQString tqsetNum( float a, char f='g', int prec=6 ) { return setNum(a, f, prec); }
+	inline TQString tqsetNum( double a, char f='g', int prec=6 ) { return setNum(a, f, prec); }
+
+	inline TQString remove( uint index, uint len ) { if (index<=((uint)length())) return QString::remove(index, len); return *this; }
+	inline TQString remove( const QString &qs ) { return QString::remove(qs); }
+	inline TQString remove( const QString &qs, bool cs ) { return QString::remove(qs, cs?Qt::CaseSensitive:Qt::CaseInsensitive); }
+	inline TQString remove( QChar c ) { return QString::remove(c); }
+	inline TQString remove( char c ) { return remove( QChar(c) ); }
+#ifndef TQT_NO_CAST_ASCII
+	inline TQString remove( const char *ch ) { return QString::remove(ch); }
+#endif
+#ifndef TQT_NO_REGEXP
+	inline TQString remove( const QRegExp &re ) { return QString::remove(re); }
+#endif
+
+	inline TQString section( TQChar sep, int start, int end = 0xffffffff, int flags = SectionDefault ) const { return QString::section(sep, start, end, (QString::SectionFlags)flags); }
+	inline TQString section( char sep, int start, int end = 0xffffffff, int flags = SectionDefault ) const { return QString::section(sep, start, end, (QString::SectionFlags)flags); }
+#ifndef TQT_NO_CAST_ASCII
+	inline TQString section( const char *in_sep, int start, int end = 0xffffffff, int flags = SectionDefault ) const { return QString::section(in_sep, start, end, (QString::SectionFlags)flags); }
+#endif
+	inline TQString section( const QString in_sep, int start, int end = 0xffffffff, int flags = SectionDefault ) const { return QString::section(in_sep, start, end, (QString::SectionFlags)flags); }
+#ifndef TQT_NO_REGEXP
+	inline TQString section( const QRegExp reg, int start, int end = 0xffffffff, int flags = SectionDefault ) const { return QString::section(reg, start, end, (QString::SectionFlags)flags); }
+#endif
+
+	inline static TQString fromUcs2(const ushort *unicode, int size = -1) { return fromUtf16(unicode, size); }
+	inline const unsigned short *ucs2() const { return utf16(); }
+
+	inline TQString left( uint len ) const { return TQString(QString::left(len)); }
+	inline TQString right( uint len ) const { return TQString(QString::right(len)); }
+	inline TQString mid( uint index, uint len=0xffffffff) const { return TQString(QString::mid(index, len)); }
+
+	inline static TQString number( long n, int base=10 ) { return TQString(QString::number(n, base)); }
+	inline static TQString number( ulong n, int base=10) { return TQString(QString::number(n, base)); }
+	inline static TQString number( TQ_LLONG n, int base=10 ) { return TQString(QString::number(n, base)); }
+	inline static TQString number( TQ_ULLONG n, int base=10) { return TQString(QString::number(n, base)); }
+	inline static TQString number( int n, int base=10 ) { return TQString(QString::number(n, base)); }
+	inline static TQString number( uint n, int base=10) { return TQString(QString::number(n, base)); }
+	inline static TQString number( double n, char f='g', int prec=6 ) { return TQString(QString::number(n, f, prec)); }
+
+	TQString &setAscii( const char*, int len=-1 );
+	TQString &setLatin1( const char *ch, int len=-1 );
+
+// 	inline TQString tqarg( long a, int fieldWidth = 0, int base = 10 ) const { return TQString(this->arg(a, fieldWidth, base)); }
+// 	inline TQString tqarg( ulong a, int fieldWidth = 0, int base = 10 ) const { return TQString(this->arg(a, fieldWidth, base)); }
+// 	inline TQString tqarg( TQ_LLONG a, int fieldwidth=0, int base=10 ) const { return TQString(this->arg(a, fieldwidth, base)); }
+// 	inline TQString tqarg( TQ_ULLONG a, int fieldwidth=0, int base=10 ) const { return TQString(this->arg(a, fieldwidth, base)); }
+// 	inline TQString tqarg( int a, int fieldWidth = 0, int base = 10 ) const { return TQString(this->arg(a, fieldWidth, base)); }
+// 	inline TQString tqarg( uint a, int fieldWidth = 0, int base = 10 ) const { return TQString(this->arg(a, fieldWidth, base)); }
+// 	inline TQString tqarg( short a, int fieldWidth = 0, int base = 10 ) const { return TQString(this->arg(a, fieldWidth, base)); }
+// 	inline TQString tqarg( ushort a, int fieldWidth = 0, int base = 10 ) const { return TQString(this->arg(a, fieldWidth, base)); }
+// 	inline TQString tqarg( double a, int fieldWidth = 0, char fmt = 'g', int prec = -1 ) const { return TQString(this->arg(a, fieldWidth, fmt, prec)); }
+// 	inline TQString tqarg( char a, int fieldWidth = 0 ) const { return TQString(this->arg(a, fieldWidth)); }
+// 	inline TQString tqarg( TQChar a, int fieldWidth = 0 ) const { return TQString(this->arg(a, fieldWidth)); }
+// 	inline TQString tqarg( const TQString& a, int fieldWidth = 0 ) const { return TQString(this->arg(a, fieldWidth)); }
+// 	inline TQString tqarg( const TQString& a1, const TQString& a2 ) const { return TQString(this->arg(a1, a2)); }
+// 	inline TQString tqarg( const TQString& a1, const TQString& a2, const TQString& a3 ) const { return TQString(this->arg(a1, a2, a3)); }
+// 	inline TQString tqarg( const TQString& a1, const TQString& a2, const TQString& a3, const TQString& a4 ) const { return TQString(this->arg(a1, a2, a3, a4)); }
+
+	TQString tqarg( long a, int fieldWidth = 0, int base = 10 ) const;
+	TQString tqarg( ulong a, int fieldWidth = 0, int base = 10 ) const;
+	TQString tqarg( TQ_LLONG a, int fieldwidth=0, int base=10 ) const;
+	TQString tqarg( TQ_ULLONG a, int fieldwidth=0, int base=10 ) const;
+	TQString tqarg( int a, int fieldWidth = 0, int base = 10 ) const;
+	TQString tqarg( uint a, int fieldWidth = 0, int base = 10 ) const;
+	TQString tqarg( short a, int fieldWidth = 0, int base = 10 ) const;
+	TQString tqarg( ushort a, int fieldWidth = 0, int base = 10 ) const;
+	TQString tqarg( double a, int fieldWidth = 0, char fmt = 'g', int prec = -1 ) const;
+	TQString tqarg( char a, int fieldWidth = 0 ) const;
+	TQString tqarg( TQChar a, int fieldWidth = 0 ) const;
+	TQString tqarg( const TQString& a, int fieldWidth = 0 ) const;
+	TQString tqarg( const TQString& a1, const TQString& a2 ) const;
+	TQString tqarg( const TQString& a1, const TQString& a2, const TQString& a3 ) const;
+	TQString tqarg( const TQString& a1, const TQString& a2, const TQString& a3, const TQString& a4 ) const;
+
+	TQString setUnicodeCodes( const ushort* tqunicode_as_ushorts, uint len );
+
+	inline void setLength(int nl) { resize(nl); }
+	TQCharRef tqat( uint i );
+	TQCharRef operator[]( int i );
+
+	static TQString fromLatin1(const char *ch, int len=-1);
+	static inline TQString tqfromLatin1(const char *ch, int len=-1) { return fromLatin1(ch, len); }
+
+	static TQString fromUtf8(const char*, int len=-1);
+
+	// FIXME
+	inline void compose() { /*printf("[FIXME] void TQString::compose() unimplemented\n\r");*/ }
+
+	TQChar tqat( uint i ) const { return i < (uint)length() ? unicode()[i] : TQChar::null; }
+	TQChar operator[]( int i ) const { if ((i<0) || (i>=length())) return TQChar::null; else return tqat((uint)i); }
+	
+// 	TQChar constref(uint i) const { return tqat(i); }
+	QChar& ref(uint i);
+
+// 	inline QChar ref(uint i) { return (*this)[i]; }
+
+	TQString &operator+=( const TQString &str );
+#ifndef TQT_NO_CAST_ASCII
+	TQString &operator+=( const TQByteArray &str );
+	TQString &operator+=( const char *str );
+#endif
+#ifndef TQT_NO_CAST_ASCII
+	TQString &operator+=( const std::string& );
+#endif
+	TQString &operator+=( TQChar c );
+	TQString &operator+=( char c );
+
+	TQString &operator+=( const QStringRef &s);
+	TQString &operator+=( const QLatin1String &s);
+	TQString &operator+=( QChar c );
+
+	using QString::operator=;
+
+	friend class TQObject;
+	friend class TQWidget;
+	friend class TQStyle;
+
+protected:
+	const char *ascii_helper() const;
+	const char *latin1_helper() const;
+
+public:
+	static char* tqunicodeToLatin1( const TQChar*, uint len );
+
+private:
+	mutable QByteArray tqstring_ascii_ba;
+	mutable QByteArray tqstring_latin1_ba;
+	mutable bool tqstring_issimpletext;
+
+private:
+#ifndef TQT_NO_CAST_ASCII
+// 	TQString &insertHelper( uint index, const char *s, uint len=UINT_MAX );
+	TQString &operatorPlusEqHelper( const char *s, uint len2=UINT_MAX );
+#endif
+
+private:
+	void subat( uint );
+	TQString tqmultiArg( int numArgs, const TQString& a1, const TQString& a2, const TQString& a3 = TQString(), const TQString& a4 = TQString() ) const;
+
+public:
+	// Interoperability
+	static const TQString& convertFromQString( QString& qstr );
+};
+
+Q_DECLARE_METATYPE(TQString)
+
+// Interoperability
+inline static const TQString& convertFromQString( const QString& qstr ) {
+	return (*static_cast<const TQString*>(&qstr));
+}
+
+inline TQString TQString::tqarg( int a, int fieldWidth, int base ) const { return tqarg( (TQ_LLONG)a, fieldWidth, base ); }
+inline TQString TQString::tqarg( uint a, int fieldWidth, int base ) const { return tqarg( (TQ_ULLONG)a, fieldWidth, base ); }
+inline TQString TQString::tqarg( short a, int fieldWidth, int base ) const { return tqarg( (TQ_LLONG)a, fieldWidth, base ); }
+inline TQString TQString::tqarg( ushort a, int fieldWidth, int base ) const { return tqarg( (TQ_ULLONG)a, fieldWidth, base ); }
+inline TQString TQString::tqarg( const TQString& a1, const TQString& a2 ) const { return tqmultiArg( 2, a1, a2 ); }
+inline TQString TQString::tqarg( const TQString& a1, const TQString& a2, const TQString& a3 ) const { return tqmultiArg( 3, a1, a2, a3 ); }
+inline TQString TQString::tqarg( const TQString& a1, const TQString& a2, const TQString& a3, const TQString& a4 ) const { return tqmultiArg( 4, a1, a2, a3, a4 ); }
+
+inline TQString TQString::copy() const { return TQString( *this ); }
+
+inline bool operator==(TQString::Null, TQString::Null) { return true; }
+inline bool operator==(TQString::Null, const TQString &s) { return s.isNull(); }
+inline bool operator==(const TQString &s, TQString::Null) { return s.isNull(); }
+inline bool operator!=(TQString::Null, TQString::Null) { return false; }
+inline bool operator!=(TQString::Null, const TQString &s) { return !s.isNull(); }
+inline bool operator!=(const TQString &s, TQString::Null) { return !s.isNull(); }
+
+#ifndef TQT_NO_CAST_ASCII
+inline TQString &TQString::operator+=( const TQByteArray &s )
+{
+    int pos = s.tqfind( 0 );
+    return operatorPlusEqHelper( s, pos==-1 ? s.size() : pos );
+}
+#endif
+
+#ifndef TQT_NO_CAST_ASCII
+inline TQString &TQString::operator+=( const std::string& s )
+{ return operator+=(s.c_str()); }
+#endif
+
+// [FIXME] The following operator+ functions spew a ridiculous number of (harmless) warnings
+// due to the very similar QString operator+ functions.  Can this be fixed???
+
+TQ_EXPORT inline const TQString operator+( const TQString &s1, const TQString &s2 )
+{
+    TQString tmp( s1 );
+    tmp += s2;
+    return tmp;
+}
+
+#ifndef TQT_NO_CAST_ASCII
+TQ_EXPORT inline const TQString operator+( const TQString &s1, const char *s2 )
+{
+    TQString tmp( s1 );
+    tmp += TQString::fromAscii(s2);
+    return tmp;
+}
+
+TQ_EXPORT inline const TQString operator+( const char *s1, const TQString &s2 )
+{
+    TQString tmp = TQString::fromAscii( s1 );
+    tmp += s2;
+    return tmp;
+}
+#endif
+
+TQ_EXPORT inline const TQString operator+( const TQString &s1, TQChar c2 )
+{
+    TQString tmp( s1 );
+    tmp += c2;
+    return tmp;
+}
+
+TQ_EXPORT inline const TQString operator+( const TQString &s1, char c2 )
+{
+    TQString tmp( s1 );
+    tmp += c2;
+    return tmp;
+}
+
+TQ_EXPORT inline const TQString operator+( TQChar c1, const TQString &s2 )
+{
+    TQString tmp;
+    tmp += c1;
+    tmp += s2;
+    return tmp;
+}
+
+TQ_EXPORT inline const TQString operator+( char c1, const TQString &s2 )
+{
+    TQString tmp;
+    tmp += c1;
+    tmp += s2;
+    return tmp;
+}
+
+#ifndef TQT_NO_STL
+TQ_EXPORT inline const TQString operator+(const TQString& s1, const std::string& s2)
+{
+    return s1 + TQString(s2);
+}
+
+TQ_EXPORT inline const TQString operator+(const std::string& s1, const TQString& s2)
+{
+    TQString tmp(s2);
+    return TQString(tmp.prepend(s1.c_str()));
+}
+#endif
+
+class TQConstString : public TQString
+{
+public:
+    inline TQConstString(const QChar *aUnicode, int aSize) : TQString(aUnicode, aSize) {} // cannot use fromRawData() due to changed semantics
+    inline const TQString &string() const { return *this; }
+};
+
+class TQ_EXPORT TQCharRef {
+    friend class TQString;
+    TQString& s;
+    uint p;
+    TQCharRef(TQString* str, uint pos) : s(*str), p(pos) { }
+
+public:
+    // most TQChar operations repeated here
+
+    // all this is not documented: We just say "like TQChar" and let it be.
+#ifndef TQ_TQDOC
+    ushort unicode() const { return s.constref(p).tqunicode(); }
+    ushort tqunicode() const { return s.constref(p).tqunicode(); }
+    char latin1() const { return s.constref(p).latin1(); }
+
+    // An operator= for each TQChar cast constructors
+    TQCharRef operator=(char c ) { s.ref(p)=c; return *this; }
+    TQCharRef operator=(uchar c ) { s.ref(p)=c; return *this; }
+    TQCharRef operator=(TQChar c ) { s.ref(p)=c; return *this; }
+    TQCharRef operator=(const TQCharRef& c ) { s.ref(p)=c.tqunicode(); return *this; }
+    TQCharRef operator=(ushort rc ) { s.ref(p)=rc; return *this; }
+    TQCharRef operator=(short rc ) { s.ref(p)=rc; return *this; }
+    TQCharRef operator=(uint rc ) { s.ref(p)=rc; return *this; }
+    TQCharRef operator=(int rc ) { s.ref(p)=rc; return *this; }
+
+    operator TQChar () const { return s.constref(p); }
+
+    // each function...
+    bool isNull() const { return tqunicode()==0; }
+    bool isPrint() const { return s.constref(p).isPrint(); }
+    bool isPunct() const { return s.constref(p).isPunct(); }
+    bool isSpace() const { return s.constref(p).isSpace(); }
+    bool isMark() const { return s.constref(p).isMark(); }
+    bool isLetter() const { return s.constref(p).isLetter(); }
+    bool isNumber() const { return s.constref(p).isNumber(); }
+    bool isLetterOrNumber() { return s.constref(p).isLetterOrNumber(); }
+    bool isDigit() const { return s.constref(p).isDigit(); }
+
+    int digitValue() const { return s.constref(p).digitValue(); }
+    TQChar lower() const { return s.constref(p).lower(); }
+    TQChar upper() const { return s.constref(p).upper(); }
+
+    TQChar::Category category() const { return s.constref(p).category(); }
+    TQChar::Direction direction() const { return s.constref(p).direction(); }
+    TQChar::Joining joining() const { return s.constref(p).joining(); }
+    bool mirrored() const { return s.constref(p).mirrored(); }
+    TQChar mirroredChar() const { return s.constref(p).mirroredChar(); }
+//    const TQString &decomposition() const { return s.constref(p).decomposition(); }
+    TQChar::Decomposition decompositionTag() const { return s.constref(p).decompositionTag(); }
+    unsigned char combiningClass() const { return s.constref(p).combiningClass(); }
+
+    // Not the non-const ones of these.
+    uchar cell() const { return s.constref(p).cell(); }
+    uchar row() const { return s.constref(p).row(); }
+#endif
+};
+
+// inline TQChar& TQString::ref(uint i)
+inline QChar& TQString::ref(uint i)
+{ // Optimized for easy-inlining by simple compilers.
+	if ( count() != 1 || i >= (uint)length() )
+	subat( i );
+// 		d->setDirty();
+// 		return tqunicode()[i];
+
+// 	const QCharRef& ref = QString::operator[](i);
+// 	return *const_cast<TQChar*>(static_cast<const TQChar*>(&reinterpret_cast<const QChar&>(ref)));		// [FIXME] Will this work the same as data->unicode did in Qt3?  Will it work at all???
+
+	QChar *tdata = data();
+	return tdata[i];		// [FIXME] Will this work the same as data->unicode did in Qt3?  Will it work at all???
+}
+
+inline TQCharRef TQString::tqat( uint i ) { return TQCharRef(this,i); }
+inline TQCharRef TQString::operator[]( int i ) { return tqat((uint)i); }
+
+/*****************************************************************************
+  TQString stream functions
+ *****************************************************************************/
+#ifndef TQT_NO_DATASTREAM
+TQ_EXPORT TQDataStream &operator<<( TQDataStream &, const TQString & );
+TQ_EXPORT TQDataStream &operator>>( TQDataStream &, TQString & );
+#endif
+
+/*****************************************************************************
+  TQString non-member operators
+ *****************************************************************************/
+
+inline TQ_EXPORT bool operator!=( const TQString &s1, const TQString &s2 ) {
+	if (s1.isNull() != s2.isNull()) return true;
+	return (static_cast<const QString&>(s1) != static_cast<const QString&>(s2));
+}
+inline TQ_EXPORT bool operator==( const TQString &s1, const TQString &s2 ) {
+	if (s1.isNull() != s2.isNull()) return false;
+	return (static_cast<const QString&>(s1) == static_cast<const QString&>(s2));
+}
+
+#else // USE_QT4
+
+/*****************************************************************************
+  TQString class
+ *****************************************************************************/
+
+class TQRegExp;
+class TQString;
+class TQCharRef;
+template <class T> class TQDeepCopy;
+
+class TQ_EXPORT TQChar {
+public:
+    TQChar();
+    TQChar( char c );
+    TQChar( uchar c );
+    TQChar( uchar c, uchar r );
+    TQChar( const TQChar& c ); // ### remove in 4.0 to allow compiler optimization
+    TQChar( ushort rc );
+    TQChar( short rc );
+    TQChar( uint rc );
+    TQChar( int rc );
+
+    TQT_STATIC_CONST TQChar null;            // 0000
+    TQT_STATIC_CONST TQChar tqreplacement;     // FFFD
+    TQT_STATIC_CONST TQChar byteOrderMark;     // FEFF
+    TQT_STATIC_CONST TQChar byteOrderSwapped;     // FFFE
+    TQT_STATIC_CONST TQChar nbsp;            // 00A0
+
+    // Unicode information
+
+    enum Category
+    {
+        NoCategory,
+
+        Mark_NonSpacing,          //   Mn
+        Mark_SpacingCombining,    //   Mc
+        Mark_Enclosing,           //   Me
+
+        Number_DecimalDigit,      //   Nd
+        Number_Letter,            //   Nl
+        Number_Other,             //   No
+
+        Separator_Space,          //   Zs
+        Separator_Line,           //   Zl
+        Separator_Paragraph,      //   Zp
+
+        Other_Control,            //   Cc
+        Other_Format,             //   Cf
+        Other_Surrogate,          //   Cs
+        Other_PrivateUse,         //   Co
+        Other_NotAssigned,        //   Cn
+
+        Letter_Uppercase,         //   Lu
+        Letter_Lowercase,         //   Ll
+        Letter_Titlecase,         //   Lt
+        Letter_Modifier,          //   Lm
+        Letter_Other,             //   Lo
+
+        Punctuation_Connector,    //   Pc
+        Punctuation_Dash,         //   Pd
+        Punctuation_Dask = Punctuation_Dash, // oops
+        Punctuation_Open,         //   Ps
+        Punctuation_Close,        //   Pe
+        Punctuation_InitialQuote, //   Pi
+        Punctuation_FinalQuote,   //   Pf
+        Punctuation_Other,        //   Po
+
+        Symbol_Math,              //   Sm
+        Symbol_Currency,          //   Sc
+        Symbol_Modifier,          //   Sk
+        Symbol_Other              //   So
+    };
+
+    enum Direction
+    {
+        DirL, DirR, DirEN, DirES, DirET, DirAN, DirCS, DirB, DirS, DirWS, DirON,
+        DirLRE, DirLRO, DirAL, DirRLE, DirRLO, DirPDF, DirNSM, DirBN
+    };
+
+    enum Decomposition
+    {
+        Single, Canonical, Font, NoBreak, Initial, Medial,
+        Final, Isolated, Circle, Super, Sub, Vertical,
+        Wide, Narrow, Small, Square, Compat, Fraction
+    };
+
+    enum Joining
+    {
+        OtherJoining, Dual, Right, Center
+    };
+
+    enum CombiningClass
+    {
+        Combining_BelowLeftAttached       = 200,
+        Combining_BelowAttached           = 202,
+        Combining_BelowRightAttached      = 204,
+        Combining_LeftAttached            = 208,
+        Combining_RightAttached           = 210,
+        Combining_AboveLeftAttached       = 212,
+        Combining_AboveAttached           = 214,
+        Combining_AboveRightAttached      = 216,
+
+        Combining_BelowLeft               = 218,
+        Combining_Below                   = 220,
+        Combining_BelowRight              = 222,
+        Combining_Left                    = 224,
+        Combining_Right                   = 226,
+        Combining_AboveLeft               = 228,
+        Combining_Above                   = 230,
+        Combining_AboveRight              = 232,
+
+        Combining_DoubleBelow             = 233,
+        Combining_DoubleAbove             = 234,
+        Combining_IotaSubscript           = 240
+    };
+
+    // ****** WHEN ADDING FUNCTIONS, CONSIDER ADDING TO TQCharRef TOO
+
+    int digitValue() const;
+    TQChar lower() const;
+    TQChar upper() const;
+
+    Category category() const;
+    Direction direction() const;
+    Joining joining() const;
+    bool mirrored() const;
+    TQChar mirroredChar() const;
+    const TQString &decomposition() const; // ### return just TQString in 4.0
+    Decomposition decompositionTag() const;
+    unsigned char combiningClass() const;
+
+    char latin1() const { return ucs > 0xff ? 0 : (char) ucs; }
+    ushort tqunicode() const { return ucs; }
+#ifdef TQ_NO_PACKED_REFERENCE
+    ushort &tqunicode() { return *(&ucs); }
+#else
+    ushort &tqunicode() { return ucs; }
+#endif
+#ifndef TQT_NO_CAST_ASCII
+    // like all ifdef'd code this is undocumented
+    operator char() const { return latin1(); }
+#endif
+
+    bool isNull() const { return tqunicode()==0; }
+    bool isPrint() const;
+    bool isPunct() const;
+    bool isSpace() const;
+    bool isMark() const;
+    bool isLetter() const;
+    bool isNumber() const;
+    bool isLetterOrNumber() const;
+    bool isDigit() const;
+    bool isSymbol() const;
+
+    uchar cell() const { return ((uchar) ucs & 0xff); }
+    uchar row() const { return ((uchar) (ucs>>8)&0xff); }
+    void setCell( uchar cell ) { ucs = (ucs & 0xff00) + cell; }
+    void setRow( uchar row ) { ucs = (((ushort) row)<<8) + (ucs&0xff); }
+
+    static bool networkOrdered() {
+	int wordSize;
+	bool bigEndian = FALSE;
+	qSysInfo( &wordSize, &bigEndian );
+	return bigEndian;
+    }
+
+    friend inline bool operator==( char ch, TQChar c );
+    friend inline bool operator==( TQChar c, char ch );
+    friend inline bool operator==( TQChar c1, TQChar c2 );
+    friend inline bool operator!=( TQChar c1, TQChar c2 );
+    friend inline bool operator!=( char ch, TQChar c );
+    friend inline bool operator!=( TQChar c, char ch );
+    friend inline bool operator<=( TQChar c, char ch );
+    friend inline bool operator<=( char ch, TQChar c );
+    friend inline bool operator<=( TQChar c1, TQChar c2 );
+
+private:
+    ushort ucs;
+#if defined(TQT_TQSTRING_UCS_4)
+    ushort grp;
+#endif
+} TQ_PACKED;
+
+inline TQChar::TQChar() : ucs( 0 )
+#ifdef TQT_TQSTRING_UCS_4
+    , grp( 0 )
+#endif
+{
+}
+inline TQChar::TQChar( char c ) : ucs( (uchar)c )
+#ifdef TQT_TQSTRING_UCS_4
+    , grp( 0 )
+#endif
+{
+}
+inline TQChar::TQChar( uchar c ) : ucs( c )
+#ifdef TQT_TQSTRING_UCS_4
+    , grp( 0 )
+#endif
+{
+}
+inline TQChar::TQChar( uchar c, uchar r ) : ucs( (r << 8) | c )
+#ifdef TQT_TQSTRING_UCS_4
+    , grp( 0 )
+#endif
+{
+}
+inline TQChar::TQChar( const TQChar& c ) : ucs( c.ucs )
+#ifdef TQT_TQSTRING_UCS_4
+   , grp( c.grp )
+#endif
+{
+}
+
+inline TQChar::TQChar( ushort rc ) : ucs( rc )
+#ifdef TQT_TQSTRING_UCS_4
+    , grp( 0 )
+#endif
+{
+}
+inline TQChar::TQChar( short rc ) : ucs( (ushort) rc )
+#ifdef TQT_TQSTRING_UCS_4
+    , grp( 0 )
+#endif
+{
+}
+inline TQChar::TQChar( uint rc ) : ucs(  (ushort ) (rc & 0xffff) )
+#ifdef TQT_TQSTRING_UCS_4
+    , grp( (ushort) ((rc >> 16) & 0xffff) )
+#endif
+{
+}
+inline TQChar::TQChar( int rc ) : ucs( (ushort) (rc & 0xffff) )
+#ifdef TQT_TQSTRING_UCS_4
+    , grp( (ushort) ((rc >> 16) & 0xffff) )
+#endif
+{
+}
+
+inline bool operator==( char ch, TQChar c )
+{
+    return ((uchar) ch) == c.ucs;
+}
+
+inline bool operator==( TQChar c, char ch )
+{
+    return ((uchar) ch) == c.ucs;
+}
+
+inline bool operator==( TQChar c1, TQChar c2 )
+{
+    return c1.ucs == c2.ucs;
+}
+
+inline bool operator!=( TQChar c1, TQChar c2 )
+{
+    return c1.ucs != c2.ucs;
+}
+
+inline bool operator!=( char ch, TQChar c )
+{
+    return ((uchar)ch) != c.ucs;
+}
+
+inline bool operator!=( TQChar c, char ch )
+{
+    return ((uchar) ch) != c.ucs;
+}
+
+inline bool operator<=( TQChar c, char ch )
+{
+    return c.ucs <= ((uchar) ch);
+}
+
+inline bool operator<=( char ch, TQChar c )
+{
+    return ((uchar) ch) <= c.ucs;
+}
+
+inline bool operator<=( TQChar c1, TQChar c2 )
+{
+    return c1.ucs <= c2.ucs;
+}
+
+inline bool operator>=( TQChar c, char ch ) { return ch <= c; }
+inline bool operator>=( char ch, TQChar c ) { return c <= ch; }
+inline bool operator>=( TQChar c1, TQChar c2 ) { return c2 <= c1; }
+inline bool operator<( TQChar c, char ch ) { return !(ch<=c); }
+inline bool operator<( char ch, TQChar c ) { return !(c<=ch); }
+inline bool operator<( TQChar c1, TQChar c2 ) { return !(c2<=c1); }
+inline bool operator>( TQChar c, char ch ) { return !(ch>=c); }
+inline bool operator>( char ch, TQChar c ) { return !(c>=ch); }
+inline bool operator>( TQChar c1, TQChar c2 ) { return !(c2>=c1); }
+
+// internal
+struct TQ_EXPORT TQStringData : public TQShared {
+    TQStringData() :
+        TQShared(), tqunicode(0), ascii(0), len(0), issimpletext(TRUE), maxl(0), islatin1(FALSE) { ref(); }
+    TQStringData(TQChar *u, uint l, uint m) :
+        TQShared(), tqunicode(u), ascii(0), len(l), issimpletext(FALSE), maxl(m), islatin1(FALSE) { }
+    ~TQStringData() { if ( tqunicode ) delete[] ((char*)tqunicode);
+                     if ( ascii ) delete[] ascii; }
+
+    void deleteSelf();
+    TQChar *tqunicode;
+    char *ascii;
+    void setDirty() {
+	if ( ascii ) {
+	    delete [] ascii;
+	    ascii = 0;
+	}
+	issimpletext = FALSE;
+    }
+#ifdef TQ_OS_MAC9
+    uint len;
+#else
+    uint len : 30;
+#endif
+    uint issimpletext : 1;
+#ifdef TQ_OS_MAC9
+    uint maxl;
+#else
+    uint maxl : 30;
+#endif
+    uint islatin1 : 1;
+
+private:
+#if defined(TQ_DISABLE_COPY)
+    TQStringData( const TQStringData& );
+    TQStringData& operator=( const TQStringData& );
+#endif
+};
+
+
+class TQ_EXPORT TQString
+{
+public:
+    TQString();                                  // make null string
+    TQString( TQChar );                           // one-char string
+    TQString( const TQString & );                 // impl-shared copy
+    TQString( const TQByteArray& );               // deep copy
+    TQString( const TQChar* tqunicode, uint length ); // deep copy
+#ifndef TQT_NO_CAST_ASCII
+    TQString( const char *str );                 // deep copy
+#endif
+#ifndef TQT_NO_STL
+    TQString( const std::string& );                   // deep copy
+#endif
+    ~TQString();
+
+#ifdef USE_QT4
+    // Interoperability
+    TQString( const QString &qs );
+    operator QString() const;
+    TQString &operator=( const QString &qs );
+#endif // USE_QT4
+
+    TQString    &operator=( const TQString & );   // impl-shared copy
+    TQString    &operator=( const char * );      // deep copy
+#ifndef TQT_NO_STL
+    TQString    &operator=( const std::string& );     // deep copy
+#endif
+    TQString    &operator=( const TQCString& );   // deep copy
+    TQString    &operator=( TQChar c );
+    TQString    &operator=( char c );
+
+    TQT_STATIC_CONST TQString null;
+
+    bool        isNull()        const;
+    bool        isEmpty()       const;
+    uint        length()        const;
+    void        truncate( uint pos );
+
+    TQString &   fill( TQChar c, int len = -1 );
+
+    TQString     copy()  const;
+
+    TQString arg( long a, int fieldWidth = 0, int base = 10 ) const;
+    TQString arg( ulong a, int fieldWidth = 0, int base = 10 ) const;
+    TQString arg( TQ_LLONG a, int fieldwidth=0, int base=10 ) const;
+    TQString arg( TQ_ULLONG a, int fieldwidth=0, int base=10 ) const;
+    TQString arg( int a, int fieldWidth = 0, int base = 10 ) const;
+    TQString arg( uint a, int fieldWidth = 0, int base = 10 ) const;
+    TQString arg( short a, int fieldWidth = 0, int base = 10 ) const;
+    TQString arg( ushort a, int fieldWidth = 0, int base = 10 ) const;
+    TQString arg( double a, int fieldWidth = 0, char fmt = 'g',
+		 int prec = -1 ) const;
+    TQString arg( char a, int fieldWidth = 0 ) const;
+    TQString arg( TQChar a, int fieldWidth = 0 ) const;
+    TQString arg( const TQString& a, int fieldWidth = 0 ) const;
+    TQString arg( const TQString& a1, const TQString& a2 ) const;
+    TQString arg( const TQString& a1, const TQString& a2,
+		 const TQString& a3 ) const;
+    TQString arg( const TQString& a1, const TQString& a2, const TQString& a3,
+		 const TQString& a4 ) const;
+
+#ifndef TQT_NO_SPRINTF
+    TQString    &sprintf( const char* format, ... )
+#if defined(TQ_CC_GNU) && !defined(__INSURE__)
+        __attribute__ ((format (printf, 2, 3)))
+#endif
+        ;
+#endif
+
+    int         tqfind( TQChar c, int index=0, bool cs=TRUE ) const;
+    int         tqfind( char c, int index=0, bool cs=TRUE ) const;
+    int         tqfind( const TQString &str, int index=0, bool cs=TRUE ) const;
+#ifndef TQT_NO_REGEXP
+    int         tqfind( const TQRegExp &, int index=0 ) const;
+#endif
+#ifndef TQT_NO_CAST_ASCII
+    int         tqfind( const char* str, int index=0 ) const;
+#endif
+    int         tqfindRev( TQChar c, int index=-1, bool cs=TRUE) const;
+    int         tqfindRev( char c, int index=-1, bool cs=TRUE) const;
+    int         tqfindRev( const TQString &str, int index=-1, bool cs=TRUE) const;
+#ifndef TQT_NO_REGEXP
+    int         tqfindRev( const TQRegExp &, int index=-1 ) const;
+#endif
+#ifndef TQT_NO_CAST_ASCII
+    int         tqfindRev( const char* str, int index=-1 ) const;
+#endif
+    int         tqcontains( TQChar c, bool cs=TRUE ) const;
+    int         tqcontains( char c, bool cs=TRUE ) const
+                    { return tqcontains(TQChar(c), cs); }
+#ifndef TQT_NO_CAST_ASCII
+    int         tqcontains( const char* str, bool cs=TRUE ) const;
+#endif
+    int         tqcontains( const TQString &str, bool cs=TRUE ) const;
+#ifndef TQT_NO_REGEXP
+    int         tqcontains( const TQRegExp & ) const;
+#endif
+
+    enum SectionFlags {
+	SectionDefault             = 0x00,
+	SectionSkipEmpty           = 0x01,
+	SectionIncludeLeadingSep   = 0x02,
+	SectionIncludeTrailingSep  = 0x04,
+	SectionCaseInsensitiveSeps = 0x08
+    };
+    TQString     section( TQChar sep, int start, int end = 0xffffffff, int flags = SectionDefault ) const;
+    TQString     section( char sep, int start, int end = 0xffffffff, int flags = SectionDefault ) const;
+#ifndef TQT_NO_CAST_ASCII
+    TQString      section( const char *in_sep, int start, int end = 0xffffffff, int flags = SectionDefault ) const;
+#endif
+    TQString     section( const TQString &in_sep, int start, int end = 0xffffffff, int flags = SectionDefault ) const;
+#ifndef TQT_NO_REGEXP
+    TQString     section( const TQRegExp &reg, int start, int end = 0xffffffff, int flags = SectionDefault ) const;
+#endif
+
+    TQString     left( uint len )  const;
+    TQString     right( uint len ) const;
+    TQString     mid( uint index, uint len=0xffffffff) const;
+
+    TQString     leftJustify( uint width, TQChar fill=' ', bool trunc=FALSE)const;
+    TQString     rightJustify( uint width, TQChar fill=' ',bool trunc=FALSE)const;
+
+    TQString     lower() const;
+    TQString     upper() const;
+
+    TQString     stripWhiteSpace()       const;
+    TQString     simplifyWhiteSpace()    const;
+
+    TQString    &insert( uint index, const TQString & );
+#ifndef TQT_NO_CAST_ASCII
+    TQString    &insert( uint index, const TQByteArray & );
+    TQString    &insert( uint index, const char * );
+#endif
+    TQString    &insert( uint index, const TQChar*, uint len );
+    TQString    &insert( uint index, TQChar );
+    TQString    &insert( uint index, char c ) { return insert(index,TQChar(c)); }
+    TQString    &append( char );
+    TQString    &append( TQChar );
+    TQString    &append( const TQString & );
+#ifndef TQT_NO_CAST_ASCII
+    TQString    &append( const TQByteArray & );
+    TQString    &append( const char * );
+#endif
+#if !defined(TQT_NO_STL) && !defined(TQT_NO_CAST_ASCII)
+    TQString    &append( const std::string& );
+#endif
+    TQString    &prepend( char );
+    TQString    &prepend( TQChar );
+    TQString    &prepend( const TQString & );
+#ifndef TQT_NO_CAST_ASCII
+    TQString    &prepend( const TQByteArray & );
+    TQString    &prepend( const char * );
+#endif
+#if !defined(TQT_NO_STL) && !defined(TQT_NO_CAST_ASCII)
+    TQString    &prepend( const std::string& );
+#endif
+    TQString    &remove( uint index, uint len );
+#if defined(TQ_TQDOC)
+    TQString    &remove( const TQString & str, bool cs = TRUE );
+#else
+    // ### TQt 4.0: merge these two into one, and remove TQ_TQDOC hack
+    TQString    &remove( const TQString & );
+    TQString    &remove( const TQString &, bool cs );
+#endif
+    TQString    &remove( TQChar c );
+    TQString    &remove( char c )
+    { return remove( TQChar(c) ); }
+#ifndef TQT_NO_CAST_ASCII
+    TQString    &remove( const char * );
+#endif
+#ifndef TQT_NO_REGEXP
+    TQString    &remove( const TQRegExp & );
+#endif
+    TQString    &tqreplace( uint index, uint len, const TQString & );
+    TQString    &tqreplace( uint index, uint len, const TQChar*, uint clen );
+    TQString    &tqreplace( uint index, uint len, TQChar );
+    TQString    &tqreplace( uint index, uint len, char c )
+    { return tqreplace( index, len, TQChar(c) ); }
+#if defined(TQ_TQDOC)
+    TQString    &tqreplace( TQChar c, const TQString & after, bool cs = TRUE );
+    TQString    &tqreplace( char c, const TQString & after, bool cs = TRUE );
+    TQString    &tqreplace( const TQString & before, const TQString & after,
+			 bool cs = TRUE );
+#else
+    // ### TQt 4.0: merge these two into one, and remove TQ_TQDOC hack
+    TQString    &tqreplace( TQChar c, const TQString & );
+    TQString    &tqreplace( TQChar c, const TQString &, bool );
+
+    // ### TQt 4.0: merge these two into one, and remove TQ_TQDOC hack
+    TQString    &tqreplace( char c, const TQString & after )
+    { return tqreplace( TQChar(c), after, TRUE ); }
+    TQString    &tqreplace( char c, const TQString & after, bool cs )
+    { return tqreplace( TQChar(c), after, cs ); }
+
+    // ### TQt 4.0: merge these two into one, and remove TQ_TQDOC hack
+    TQString    &tqreplace( const TQString &, const TQString & );
+    TQString    &tqreplace( const TQString &, const TQString &, bool );
+#endif
+#ifndef TQT_NO_REGEXP_CAPTURE
+    TQString    &tqreplace( const TQRegExp &, const TQString & );
+#endif
+    TQString    &tqreplace( TQChar, TQChar );
+
+    short       toShort( bool *ok=0, int base=10 )      const;
+    ushort      toUShort( bool *ok=0, int base=10 )     const;
+    int         toInt( bool *ok=0, int base=10 )        const;
+    uint        toUInt( bool *ok=0, int base=10 )       const;
+    long        toLong( bool *ok=0, int base=10 )       const;
+    ulong       toULong( bool *ok=0, int base=10 )      const;
+    TQ_LLONG     toLongLong( bool *ok=0, int base=10 )   const;
+    TQ_ULLONG    toULongLong( bool *ok=0, int base=10 )  const;
+    float       toFloat( bool *ok=0 )   const;
+    double      toDouble( bool *ok=0 )  const;
+
+    TQString    &setNum( short, int base=10 );
+    TQString    &setNum( ushort, int base=10 );
+    TQString    &setNum( int, int base=10 );
+    TQString    &setNum( uint, int base=10 );
+    TQString    &setNum( long, int base=10 );
+    TQString    &setNum( ulong, int base=10 );
+    TQString    &setNum( TQ_LLONG, int base=10 );
+    TQString    &setNum( TQ_ULLONG, int base=10 );
+    TQString    &setNum( float, char f='g', int prec=6 );
+    TQString    &setNum( double, char f='g', int prec=6 );
+
+    static TQString number( long, int base=10 );
+    static TQString number( ulong, int base=10);
+    static TQString number( TQ_LLONG, int base=10 );
+    static TQString number( TQ_ULLONG, int base=10);
+    static TQString number( int, int base=10 );
+    static TQString number( uint, int base=10);
+    static TQString number( double, char f='g', int prec=6 );
+
+    void        setExpand( uint index, TQChar c );
+
+    TQString    &operator+=( const TQString &str );
+#ifndef TQT_NO_CAST_ASCII
+    TQString    &operator+=( const TQByteArray &str );
+    TQString    &operator+=( const char *str );
+#endif
+#if !defined(TQT_NO_STL) && !defined(TQT_NO_CAST_ASCII)
+    TQString    &operator+=( const std::string& );
+#endif
+    TQString    &operator+=( TQChar c );
+    TQString    &operator+=( char c );
+
+    TQChar at( uint i ) const
+        { return i < d->len ? d->tqunicode[i] : TQChar::null; }
+    TQChar operator[]( int i ) const { if ((i<0) || (i>=length())) return TQChar::null; else return at((uint)i); }
+    TQCharRef at( uint i );
+    TQCharRef operator[]( int i );
+
+    TQChar constref(uint i) const
+        { return at(i); }
+    TQChar& ref(uint i)
+        { // Optimized for easy-inlining by simple compilers.
+            if ( d->count != 1 || i >= d->len )
+                subat( i );
+            d->setDirty();
+            return d->tqunicode[i];
+        }
+
+    const TQChar* tqunicode() const { return d->tqunicode; }
+    const char* ascii() const;
+    static TQString fromAscii(const char*, int len=-1);
+    const char* latin1() const;
+    static TQString tqfromLatin1(const char*, int len=-1);
+    TQCString utf8() const;
+    static TQString fromUtf8(const char*, int len=-1);
+    TQCString local8Bit() const;
+    static TQString fromLocal8Bit(const char*, int len=-1);
+    bool operator!() const;
+#ifndef TQT_NO_ASCII_CAST
+    operator const char *() const { return ascii(); }
+#endif
+#ifndef TQT_NO_STL
+    operator std::string() const { return ascii() ? ascii() : ""; }
+#endif
+
+    static TQString fromUcs2( const unsigned short *ucs2 );
+    const unsigned short *ucs2() const;
+
+    TQString &setUnicode( const TQChar* tqunicode, uint len );
+    TQString &setUnicodeCodes( const ushort* tqunicode_as_ushorts, uint len );
+    TQString &setAscii( const char*, int len=-1 );
+    TQString &setLatin1( const char*, int len=-1 );
+
+    int compare( const TQString& s ) const;
+    static int compare( const TQString& s1, const TQString& s2 )
+    { return s1.compare( s2 ); }
+
+    int localeAwareCompare( const TQString& s ) const;
+    static int localeAwareCompare( const TQString& s1, const TQString& s2 )
+    { return s1.localeAwareCompare( s2 ); }
+
+#ifndef TQT_NO_DATASTREAM
+    friend TQ_EXPORT TQDataStream &operator>>( TQDataStream &, TQString & );
+#endif
+
+    void compose();
+
+#ifndef TQT_NO_COMPAT
+    const char* data() const { return ascii(); }
+#endif
+
+#if defined(TQ_TQDOC)
+    bool startsWith( const TQString& str, bool cs = TRUE ) const;
+    bool endsWith( const TQString& str, bool cs = TRUE ) const;
+#else
+    // ### TQt 4.0: merge these two into one, and remove TQ_TQDOC hack
+    bool startsWith( const TQString& str ) const;
+    bool startsWith( const TQString& str, bool cs ) const;
+
+    // ### TQt 4.0: merge these two into one, and remove TQ_TQDOC hack
+    bool endsWith( const TQString& str ) const;
+    bool endsWith( const TQString& str, bool cs ) const;
+#endif
+
+    void setLength( uint newLength );
+
+    uint capacity() const;
+    void reserve( uint minCapacity );
+    void squeeze();
+
+    bool simpleText() const { if ( !d->issimpletext ) checkSimpleText(); return (bool)d->issimpletext; }
+    bool isRightToLeft() const;
+
+
+private:
+    TQString( int size, bool /* dummy */ );	// allocate size incl. \0
+
+    void deref();
+    void real_detach();
+    void subat( uint );
+    TQString multiArg( int numArgs, const TQString& a1, const TQString& a2,
+		      const TQString& a3 = TQString::null,
+		      const TQString& a4 = TQString::null ) const;
+
+    void checkSimpleText() const;
+    void grow( uint newLength );
+#ifndef TQT_NO_CAST_ASCII
+    TQString &insertHelper( uint index, const char *s, uint len=UINT_MAX );
+    TQString &operatorPlusEqHelper( const char *s, uint len2=UINT_MAX );
+#endif
+
+    static TQChar* latin1ToUnicode( const char*, uint * len, uint maxlen=(uint)-1 );
+    static TQChar* latin1ToUnicode( const TQByteArray&, uint * len );
+    static char* tqunicodeToLatin1( const TQChar*, uint len );
+
+    TQStringData *d;
+    static TQStringData* shared_null;
+    static TQStringData* makeSharedNull();
+
+    friend class TQConstString;
+    friend class TQTextStream;
+    TQString( TQStringData* dd, bool /* dummy */ ) : d(dd) { }
+
+    // needed for TQDeepCopy
+    void detach();
+    friend class TQDeepCopy<TQString>;
+};
+
+class TQ_EXPORT TQCharRef {
+    friend class TQString;
+    TQString& s;
+    uint p;
+    TQCharRef(TQString* str, uint pos) : s(*str), p(pos) { }
+
+public:
+    // most TQChar operations repeated here
+
+    // all this is not documented: We just say "like TQChar" and let it be.
+#ifndef TQ_TQDOC
+    ushort tqunicode() const { return s.constref(p).tqunicode(); }
+    char latin1() const { return s.constref(p).latin1(); }
+
+    // An operator= for each TQChar cast constructors
+    TQCharRef operator=(char c ) { s.ref(p)=c; return *this; }
+    TQCharRef operator=(uchar c ) { s.ref(p)=c; return *this; }
+    TQCharRef operator=(TQChar c ) { s.ref(p)=c; return *this; }
+    TQCharRef operator=(const TQCharRef& c ) { s.ref(p)=c.tqunicode(); return *this; }
+    TQCharRef operator=(ushort rc ) { s.ref(p)=rc; return *this; }
+    TQCharRef operator=(short rc ) { s.ref(p)=rc; return *this; }
+    TQCharRef operator=(uint rc ) { s.ref(p)=rc; return *this; }
+    TQCharRef operator=(int rc ) { s.ref(p)=rc; return *this; }
+
+    operator TQChar () const { return s.constref(p); }
+
+    // each function...
+    bool isNull() const { return tqunicode()==0; }
+    bool isPrint() const { return s.constref(p).isPrint(); }
+    bool isPunct() const { return s.constref(p).isPunct(); }
+    bool isSpace() const { return s.constref(p).isSpace(); }
+    bool isMark() const { return s.constref(p).isMark(); }
+    bool isLetter() const { return s.constref(p).isLetter(); }
+    bool isNumber() const { return s.constref(p).isNumber(); }
+    bool isLetterOrNumber() { return s.constref(p).isLetterOrNumber(); }
+    bool isDigit() const { return s.constref(p).isDigit(); }
+
+    int digitValue() const { return s.constref(p).digitValue(); }
+    TQChar lower() const { return s.constref(p).lower(); }
+    TQChar upper() const { return s.constref(p).upper(); }
+
+    TQChar::Category category() const { return s.constref(p).category(); }
+    TQChar::Direction direction() const { return s.constref(p).direction(); }
+    TQChar::Joining joining() const { return s.constref(p).joining(); }
+    bool mirrored() const { return s.constref(p).mirrored(); }
+    TQChar mirroredChar() const { return s.constref(p).mirroredChar(); }
+    const TQString &decomposition() const { return s.constref(p).decomposition(); }
+    TQChar::Decomposition decompositionTag() const { return s.constref(p).decompositionTag(); }
+    unsigned char combiningClass() const { return s.constref(p).combiningClass(); }
+
+    // Not the non-const ones of these.
+    uchar cell() const { return s.constref(p).cell(); }
+    uchar row() const { return s.constref(p).row(); }
+#endif
+};
+
+inline TQCharRef TQString::at( uint i ) { return TQCharRef(this,i); }
+inline TQCharRef TQString::operator[]( int i ) { return tqat((uint)i); }
+
+
+class TQ_EXPORT TQConstString : private TQString {
+public:
+    TQConstString( const TQChar* tqunicode, uint length );
+    ~TQConstString();
+    const TQString& string() const { return *this; }
+};
+
+
+/*****************************************************************************
+  TQString stream functions
+ *****************************************************************************/
+#ifndef TQT_NO_DATASTREAM
+TQ_EXPORT TQDataStream &operator<<( TQDataStream &, const TQString & );
+TQ_EXPORT TQDataStream &operator>>( TQDataStream &, TQString & );
+#endif
+
+/*****************************************************************************
+  TQString inline functions
+ *****************************************************************************/
+
+// These two move code into makeSharedNull() and deletesData()
+// to improve cache-coherence (and reduce code bloat), while
+// keeping the common cases fast.
+//
+// No safe way to pre-init shared_null on ALL compilers/linkers.
+inline TQString::TQString() :
+    d(shared_null ? shared_null : makeSharedNull())
+{
+    d->ref();
+}
+//
+inline TQString::~TQString()
+{
+    if ( d->deref() ) {
+        if ( d != shared_null )
+	    d->deleteSelf();
+    }
+}
+
+// needed for TQDeepCopy
+inline void TQString::detach()
+{ real_detach(); }
+
+inline TQString TQString::section( TQChar sep, int start, int end, int flags ) const
+{ return section(TQString(sep), start, end, flags); }
+
+inline TQString TQString::section( char sep, int start, int end, int flags ) const
+{ return section(TQChar(sep), start, end, flags); }
+
+#ifndef TQT_NO_CAST_ASCII
+inline TQString TQString::section( const char *in_sep, int start, int end, int flags ) const
+{ return section(TQString(in_sep), start, end, flags); }
+#endif
+
+inline TQString &TQString::operator=( TQChar c )
+{ *this = TQString(c); return *this; }
+
+inline TQString &TQString::operator=( char c )
+{ *this = TQString(TQChar(c)); return *this; }
+
+inline bool TQString::isNull() const
+{ return tqunicode() == 0; }
+
+inline bool TQString::operator!() const
+{ return isNull(); }
+
+inline uint TQString::length() const
+{ return d->len; }
+
+inline uint TQString::capacity() const
+{ return d->maxl; }
+
+inline bool TQString::isEmpty() const
+{ return length() == 0; }
+
+inline TQString TQString::copy() const
+{ return TQString( *this ); }
+
+#ifndef TQT_NO_CAST_ASCII
+inline TQString &TQString::insert( uint index, const char *s )
+{ return insertHelper( index, s ); }
+
+inline TQString &TQString::insert( uint index, const TQByteArray &s )
+{
+    int pos = s.tqfind( 0 );
+    return insertHelper( index, s, pos==-1 ? s.size() : pos );
+}
+#endif
+
+inline TQString &TQString::prepend( const TQString & s )
+{ return insert(0,s); }
+
+inline TQString &TQString::prepend( TQChar c )
+{ return insert(0,c); }
+
+inline TQString &TQString::prepend( char c )
+{ return insert(0,c); }
+
+#ifndef TQT_NO_CAST_ASCII
+inline TQString &TQString::prepend( const TQByteArray & s )
+{ return insert(0,s); }
+#endif
+
+#ifndef TQT_NO_CAST_ASCII
+inline TQString &TQString::operator+=( const TQByteArray &s )
+{
+    int pos = s.tqfind( 0 );
+    return operatorPlusEqHelper( s, pos==-1 ? s.size() : pos );
+}
+#endif
+
+inline TQString &TQString::append( const TQString & s )
+{ return operator+=(s); }
+
+#ifndef TQT_NO_CAST_ASCII
+inline TQString &TQString::append( const TQByteArray &s )
+{ return operator+=(s); }
+
+inline TQString &TQString::append( const char * s )
+{ return operator+=(s); }
+#endif
+
+inline TQString &TQString::append( TQChar c )
+{ return operator+=(c); }
+
+inline TQString &TQString::append( char c )
+{ return operator+=(c); }
+
+#ifndef TQT_NO_STL
+inline TQString &TQString::operator=( const std::string& str )
+{ return operator=(str.c_str()); }
+#ifndef TQT_NO_CAST_ASCII
+inline TQString &TQString::operator+=( const std::string& s )
+{ return operator+=(s.c_str()); }
+inline TQString &TQString::append( const std::string& s )
+{ return operator+=(s); }
+inline TQString &TQString::prepend( const std::string& s )
+{ return insert(0, s); }
+#endif
+#endif
+
+inline TQString &TQString::setNum( short n, int base )
+{ return setNum((TQ_LLONG)n, base); }
+
+inline TQString &TQString::setNum( ushort n, int base )
+{ return setNum((TQ_ULLONG)n, base); }
+
+inline TQString &TQString::setNum( int n, int base )
+{ return setNum((TQ_LLONG)n, base); }
+
+inline TQString &TQString::setNum( uint n, int base )
+{ return setNum((TQ_ULLONG)n, base); }
+
+inline TQString &TQString::setNum( float n, char f, int prec )
+{ return setNum((double)n,f,prec); }
+
+inline TQString TQString::arg( int a, int fieldWidth, int base ) const
+{ return arg( (TQ_LLONG)a, fieldWidth, base ); }
+
+inline TQString TQString::arg( uint a, int fieldWidth, int base ) const
+{ return arg( (TQ_ULLONG)a, fieldWidth, base ); }
+
+inline TQString TQString::arg( short a, int fieldWidth, int base ) const
+{ return arg( (TQ_LLONG)a, fieldWidth, base ); }
+
+inline TQString TQString::arg( ushort a, int fieldWidth, int base ) const
+{ return arg( (TQ_ULLONG)a, fieldWidth, base ); }
+
+inline TQString TQString::arg( const TQString& a1, const TQString& a2 ) const {
+    return multiArg( 2, a1, a2 );
+}
+
+inline TQString TQString::arg( const TQString& a1, const TQString& a2,
+			     const TQString& a3 ) const {
+    return multiArg( 3, a1, a2, a3 );
+}
+
+inline TQString TQString::arg( const TQString& a1, const TQString& a2,
+			     const TQString& a3, const TQString& a4 ) const {
+    return multiArg( 4, a1, a2, a3, a4 );
+}
+
+inline int TQString::tqfind( char c, int index, bool cs ) const
+{ return tqfind(TQChar(c), index, cs); }
+
+inline int TQString::tqfindRev( char c, int index, bool cs ) const
+{ return tqfindRev( TQChar(c), index, cs ); }
+
+#ifndef TQT_NO_CAST_ASCII
+inline int TQString::tqfind( const char* str, int index ) const
+{ return tqfind(TQString::fromAscii(str), index); }
+
+inline int TQString::tqfindRev( const char* str, int index ) const
+{ return tqfindRev(TQString::fromAscii(str), index); }
+#endif
+
+
+/*****************************************************************************
+  TQString non-member operators
+ *****************************************************************************/
+
+TQ_EXPORT bool operator!=( const TQString &s1, const TQString &s2 );
+TQ_EXPORT bool operator<( const TQString &s1, const TQString &s2 );
+TQ_EXPORT bool operator<=( const TQString &s1, const TQString &s2 );
+TQ_EXPORT bool operator==( const TQString &s1, const TQString &s2 );
+TQ_EXPORT bool operator>( const TQString &s1, const TQString &s2 );
+TQ_EXPORT bool operator>=( const TQString &s1, const TQString &s2 );
+#ifndef TQT_NO_CAST_ASCII
+TQ_EXPORT bool operator!=( const TQString &s1, const char *s2 );
+TQ_EXPORT bool operator<( const TQString &s1, const char *s2 );
+TQ_EXPORT bool operator<=( const TQString &s1, const char *s2 );
+TQ_EXPORT bool operator==( const TQString &s1, const char *s2 );
+TQ_EXPORT bool operator>( const TQString &s1, const char *s2 );
+TQ_EXPORT bool operator>=( const TQString &s1, const char *s2 );
+TQ_EXPORT bool operator!=( const char *s1, const TQString &s2 );
+TQ_EXPORT bool operator<( const char *s1, const TQString &s2 );
+TQ_EXPORT bool operator<=( const char *s1, const TQString &s2 );
+TQ_EXPORT bool operator==( const char *s1, const TQString &s2 );
+//TQ_EXPORT bool operator>( const char *s1, const TQString &s2 ); // MSVC++
+TQ_EXPORT bool operator>=( const char *s1, const TQString &s2 );
+#endif
+
+// Interoperability
+TQ_EXPORT bool operator==( const QString &s1, const TQString &s2 );
+
+TQ_EXPORT inline const TQString operator+( const TQString &s1, const TQString &s2 )
+{
+    TQString tmp( s1 );
+    tmp += s2;
+    return tmp;
+}
+
+#ifndef TQT_NO_CAST_ASCII
+TQ_EXPORT inline const TQString operator+( const TQString &s1, const char *s2 )
+{
+    TQString tmp( s1 );
+    tmp += TQString::fromAscii(s2);
+    return tmp;
+}
+
+TQ_EXPORT inline const TQString operator+( const char *s1, const TQString &s2 )
+{
+    TQString tmp = TQString::fromAscii( s1 );
+    tmp += s2;
+    return tmp;
+}
+#endif
+
+TQ_EXPORT inline const TQString operator+( const TQString &s1, TQChar c2 )
+{
+    TQString tmp( s1 );
+    tmp += c2;
+    return tmp;
+}
+
+TQ_EXPORT inline const TQString operator+( const TQString &s1, char c2 )
+{
+    TQString tmp( s1 );
+    tmp += c2;
+    return tmp;
+}
+
+TQ_EXPORT inline const TQString operator+( TQChar c1, const TQString &s2 )
+{
+    TQString tmp;
+    tmp += c1;
+    tmp += s2;
+    return tmp;
+}
+
+TQ_EXPORT inline const TQString operator+( char c1, const TQString &s2 )
+{
+    TQString tmp;
+    tmp += c1;
+    tmp += s2;
+    return tmp;
+}
+
+#ifndef TQT_NO_STL
+TQ_EXPORT inline const TQString operator+(const TQString& s1, const std::string& s2)
+{
+    return s1 + TQString(s2);
+}
+
+TQ_EXPORT inline const TQString operator+(const std::string& s1, const TQString& s2)
+{
+    TQString tmp(s2);
+    return TQString(tmp.prepend(s1));
+}
+#endif
+
+
+#if defined(TQ_OS_WIN32)
+extern TQ_EXPORT TQString qt_winTQString(void*);
+extern TQ_EXPORT const void* qt_winTchar(const TQString& str, bool addnul);
+extern TQ_EXPORT void* qt_winTchar_new(const TQString& str);
+extern TQ_EXPORT TQCString qt_winTQString2MB( const TQString& s, int len=-1 );
+extern TQ_EXPORT TQString qt_winMB2TQString( const char* mb, int len=-1 );
+#endif
+
+#endif // USE_QT4
+
+#define TQ_DEFINED_TQSTRING
+#include "tqwinexport.h"
+#endif // TQSTRING_H
diff --git a/tqtinterface/qt4/src/tools/tqstringlist.cpp b/tqtinterface/qt4/src/tools/tqstringlist.cpp
new file mode 100644
index 0000000..6a10959
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqstringlist.cpp
@@ -0,0 +1,534 @@
+/****************************************************************************
+**
+** Implementation of TQStringList
+**
+** Created : 990406
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "tqstringlist.h"
+
+#ifndef TQT_NO_STRINGLIST
+#include "tqregexp.h"
+#include "tqstrlist.h"
+#include "tqdatastream.h"
+#include "tqtl.h"
+
+#ifdef USE_QT4
+
+#include <Qt/qstringlist.h>
+
+#endif
+
+/*!
+    \class TQStringList tqstringlist.h
+    \reentrant
+    \brief The TQStringList class provides a list of strings.
+
+    \ingroup tools
+    \ingroup shared
+    \ingroup text
+    \mainclass
+
+    It is used to store and manipulate strings that logically belong
+    together. Essentially TQStringList is a TQValueList of TQString
+    objects. Unlike TQStrList, which stores pointers to characters,
+    TQStringList holds real TQString objects. It is the class of choice
+    whenever you work with Unicode strings. TQStringList is part of the
+    \link tqtl.html TQt Template Library\endlink.
+
+    Like TQString itself, TQStringList objects are implicitly shared, so
+    passing them around as value-parameters is both fast and safe.
+
+    Strings can be added to a list using append(), operator+=() or
+    operator<<(), e.g.
+    \code
+    TQStringList fonts;
+    fonts.append( "Times" );
+    fonts += "Courier";
+    fonts += "Courier New";
+    fonts << "Helvetica [Cronyx]" << "Helvetica [Adobe]";
+    \endcode
+
+    String lists have an iterator, TQStringList::Iterator(), e.g.
+    \code
+    for ( TQStringList::Iterator it = fonts.begin(); it != fonts.end(); ++it ) {
+	cout << *it << ":";
+    }
+    cout << endl;
+    // Output:
+    //	Times:Courier:Courier New:Helvetica [Cronyx]:Helvetica [Adobe]:
+    \endcode
+
+    Many TQt functions return string lists by value; to iterate over
+    these you should make a copy and iterate over the copy.
+
+    You can concatenate all the strings in a string list into a single
+    string (with an optional separator) using join(), e.g.
+    \code
+    TQString allFonts = fonts.join( ", " );
+    cout << allFonts << endl;
+    // Output:
+    //	Times, Courier, Courier New, Helvetica [Cronyx], Helvetica [Adobe]
+    \endcode
+
+    You can sort the list with sort(), and extract a new list which
+    tqcontains only those strings which contain a particular substring
+    (or match a particular regular expression) using the grep()
+    functions, e.g.
+    \code
+    fonts.sort();
+    cout << fonts.join( ", " ) << endl;
+    // Output:
+    //	Courier, Courier New, Helvetica [Adobe], Helvetica [Cronyx], Times
+
+    TQStringList helveticas = fonts.grep( "Helvetica" );
+    cout << helveticas.join( ", " ) << endl;
+    // Output:
+    //	Helvetica [Adobe], Helvetica [Cronyx]
+    \endcode
+
+    Existing strings can be split into string lists with character,
+    string or regular expression separators, e.g.
+    \code
+    TQString s = "Red\tGreen\tBlue";
+    TQStringList colors = TQStringList::split( "\t", s );
+    cout << colors.join( ", " ) << endl;
+    // Output:
+    //	Red, Green, Blue
+    \endcode
+*/
+
+/*!
+    \fn TQStringList::TQStringList()
+
+    Creates an empty string list.
+*/
+
+/*!
+    \fn TQStringList::TQStringList( const TQStringList& l )
+
+    Creates a copy of the list \a l. This function is very fast
+    because TQStringList is implicitly shared. In most situations this
+    acts like a deep copy, for example, if this list or the original
+    one or some other list referencing the same shared data is
+    modified, the modifying list first makes a copy, i.e.
+    copy-on-write.
+    In a threaded environment you may require a real deep copy
+    \omit see \l TQDeepCopy\endomit.
+*/
+
+/*!
+    \fn TQStringList::TQStringList (const TQString & i)
+
+    Constructs a string list consisting of the single string \a i.
+    Longer lists are easily created as follows:
+
+    \code
+    TQStringList items;
+    items << "Buy" << "Sell" << "Update" << "Value";
+    \endcode
+*/
+
+/*!
+    \fn TQStringList::TQStringList (const char* i)
+
+    Constructs a string list consisting of the single Latin-1 string \a i.
+*/
+
+/*!
+    \fn TQStringList::TQStringList( const TQValueList<TQString>& l )
+
+    Constructs a new string list that is a copy of \a l.
+*/
+
+/*!
+    Sorts the list of strings in ascending case-sensitive order.
+
+    Sorting is very fast. It uses the \link tqtl.html TQt Template
+    Library's\endlink efficient HeapSort implementation that has a
+    time complexity of O(n*log n).
+
+    If you want to sort your strings in an arbitrary order consider
+    using a TQMap. For example you could use a TQMap\<TQString,TQString\>
+    to create a case-insensitive ordering (e.g. mapping the lowercase
+    text to the text), or a TQMap\<int,TQString\> to sort the strings by
+    some integer index, etc.
+*/
+void TQStringList::sort()
+{
+    qHeapSort( *this );
+}
+
+/*!
+    \overload
+
+    This version of the function uses a TQChar as separator, rather
+    than a regular expression.
+
+    \sa join() TQString::section()
+*/
+
+TQStringList TQStringList::split( const TQChar &sep, const TQString &str,
+				bool allowEmptyEntries )
+{
+    return split( TQString(sep), str, allowEmptyEntries );
+}
+
+/*!
+    \overload
+
+    This version of the function uses a TQString as separator, rather
+    than a regular expression.
+
+    If \a sep is an empty string, the return value is a list of
+    one-character strings: split( TQString( "" ), "four" ) returns the
+    four-item list, "f", "o", "u", "r".
+
+    If \a allowEmptyEntries is TRUE, a null string is inserted in
+    the list wherever the separator matches twice without intervening
+    text.
+
+    \sa join() TQString::section()
+*/
+
+TQStringList TQStringList::split( const TQString &sep, const TQString &str,
+				bool allowEmptyEntries )
+{
+    TQStringList lst;
+
+    int j = 0;
+    int i = str.tqfind( sep, j );
+
+    while ( i != -1 ) {
+	if ( i > j && i <= (int)str.length() )
+	    lst << str.mid( j, i - j );
+	else if ( allowEmptyEntries )
+	    lst << TQString::null;
+	j = i + sep.length();
+	i = str.tqfind( sep, sep.length() > 0 ? j : j+1 );
+    }
+
+    int l = str.length() - 1;
+    if ( str.mid( j, l - j + 1 ).length() > 0 )
+	lst << str.mid( j, l - j + 1 );
+    else if ( allowEmptyEntries )
+	lst << TQString::null;
+
+    return lst;
+}
+
+#ifndef TQT_NO_REGEXP
+/*!
+    Splits the string \a str into strings wherever the regular
+    expression \a sep occurs, and returns the list of those strings.
+
+    If \a allowEmptyEntries is TRUE, a null string is inserted in
+    the list wherever the separator matches twice without intervening
+    text.
+
+    For example, if you split the string "a,,b,c" on commas, split()
+    returns the three-item list "a", "b", "c" if \a allowEmptyEntries
+    is FALSE (the default), and the four-item list "a", "", "b", "c"
+    if \a allowEmptyEntries is TRUE.
+
+    If \a sep does not match anywhere in \a str, split() returns a
+    single element list with the element containing the single string
+    \a str.
+
+    \sa join() TQString::section()
+*/
+
+TQStringList TQStringList::split( const TQRegExp &sep, const TQString &str,
+				bool allowEmptyEntries )
+{
+    TQStringList lst;
+
+    TQRegExp tep = sep;
+
+    int j = 0;
+    int i = tep.search( str, j );
+
+    while ( i != -1 ) {
+	if ( str.mid( j, i - j ).length() > 0 )
+	    lst << str.mid( j, i - j );
+	else if ( allowEmptyEntries )
+	    lst << TQString::null;
+	if ( tep.matchedLength() == 0 )
+	    j = i + 1;
+	else
+	    j = i + tep.matchedLength();
+	i = tep.search( str, j );
+    }
+
+    int l = str.length() - 1;
+    if ( str.mid( j, l - j + 1 ).length() > 0 )
+	lst << str.mid( j, l - j + 1 );
+    else if ( allowEmptyEntries )
+	lst << TQString::null;
+
+    return lst;
+}
+#endif
+
+/*!
+    Returns a list of all the strings containing the substring \a str.
+
+    If \a cs is TRUE, the grep is done case-sensitively; otherwise
+    case is ignored.
+
+    \code
+    TQStringList list;
+    list << "Bill Gates" << "John Doe" << "Bill Clinton";
+    list = list.grep( "Bill" );
+    // list == ["Bill Gates", "Bill Clinton"]
+    \endcode
+
+    \sa TQString::tqfind()
+*/
+
+TQStringList TQStringList::grep( const TQString &str, bool cs ) const
+{
+    TQStringList res;
+    for ( TQStringList::ConstIterator it = begin(); it != end(); ++it )
+	if ( (*it).tqcontains(str, cs) )
+	    res << *it;
+
+    return res;
+}
+
+#ifndef TQT_NO_REGEXP
+/*!
+    \overload
+
+    Returns a list of all the strings that match the regular
+    expression \a rx.
+
+    \sa TQString::tqfind()
+*/
+
+TQStringList TQStringList::grep( const TQRegExp &rx ) const
+{
+    TQStringList res;
+    for ( TQStringList::ConstIterator it = begin(); it != end(); ++it )
+	if ( (*it).tqfind(rx) != -1 )
+	    res << *it;
+
+    return res;
+}
+#endif
+
+/*!
+    Replaces every occurrence of the string \a before in the strings
+    that constitute the string list with the string \a after. Returns
+    a reference to the string list.
+
+    If \a cs is TRUE, the search is case sensitive; otherwise the
+    search is case insensitive.
+
+    Example:
+    \code
+    TQStringList list;
+    list << "alpha" << "beta" << "gamma" << "epsilon";
+    list.gres( "a", "o" );
+    // list == ["olpho", "beto", "gommo", "epsilon"]
+    \endcode
+
+    \sa TQString::tqreplace()
+*/
+TQStringList& TQStringList::gres( const TQString &before, const TQString &after,
+				bool cs )
+{
+    TQStringList::Iterator it = begin();
+    while ( it != end() ) {
+	(*it).tqreplace( before, after, cs );
+	++it;
+    }
+    return *this;
+}
+
+#ifndef TQT_NO_REGEXP_CAPTURE
+/*!
+    \overload
+
+    Replaces every occurrence of the regexp \a rx in the string
+    with \a after. Returns a reference to the string list.
+
+    Example:
+    \code
+    TQStringList list;
+    list << "alpha" << "beta" << "gamma" << "epsilon";
+    list.gres( TQRegExp("^a"), "o" );
+    // list == ["olpha", "beta", "gamma", "epsilon"]
+    \endcode
+
+    For regexps containing \link tqregexp.html#capturing-text
+    capturing parentheses \endlink, occurrences of <b>\\1</b>,
+    <b>\\2</b>, ..., in \a after are tqreplaced with \a{rx}.cap(1),
+    cap(2), ...
+
+    Example:
+    \code
+    TQStringList list;
+    list << "Bill Clinton" << "Gates, Bill";
+    list.gres( TQRegExp("^(.*), (.*)$"), "\\2 \\1" );
+    // list == ["Bill Clinton", "Bill Gates"]
+    \endcode
+
+    \sa TQString::tqreplace()
+*/
+TQStringList& TQStringList::gres( const TQRegExp &rx, const TQString &after )
+{
+    TQStringList::Iterator it = begin();
+    while ( it != end() ) {
+	(*it).tqreplace( rx, after );
+	++it;
+    }
+    return *this;
+}
+
+#endif
+
+/*!
+    Joins the string list into a single string with each element
+    separated by the string \a sep (which can be empty).
+
+    \sa split()
+*/
+TQString TQStringList::join( const TQString &sep ) const
+{
+    TQString res;
+    bool alredy = FALSE;
+    for ( TQStringList::ConstIterator it = begin(); it != end(); ++it ) {
+	if ( alredy )
+	    res += sep;
+	alredy = TRUE;
+	res += *it;
+    }
+
+    return res;
+}
+
+#ifndef TQT_NO_DATASTREAM
+TQ_EXPORT TQDataStream &operator>>( TQDataStream & s, TQStringList& l )
+{
+    return s >> (TQValueList<TQString>&)l;
+}
+
+TQ_EXPORT TQDataStream &operator<<( TQDataStream & s, const TQStringList& l )
+{
+    return s << (const TQValueList<TQString>&)l;
+}
+#endif
+
+/*!
+    Converts from an ASCII-TQStrList \a ascii to a TQStringList (Unicode).
+*/
+TQStringList TQStringList::fromStrList(const TQStrList& ascii)
+{
+    TQStringList res;
+    const char * s;
+    for ( TQStrListIterator it(ascii); (s=it.current()); ++it )
+	res << s;
+    return res;
+}
+
+/*! \fn void TQStringList::detach()
+    \reimp
+*/
+
+#ifdef USE_QT4
+
+// Interoperability
+// [FIXME]
+// These conversions are probably too weak
+
+#if 0
+/*!
+    QT4 INTEROPERABILITY
+*/
+TQStringList::TQStringList( const QStringList &qs )
+{
+	setAscii( TQString(qs).ascii() );
+}
+
+/*!
+    QT4 INTEROPERABILITY
+*/
+TQStringList::operator QStringList() const
+{
+	return QStringList::fromUtf8( this->utf8() );
+}
+#endif
+
+/*!
+    QT4 INTEROPERABILITY
+*/
+TQStringList::operator QStringList() const
+{
+	QStringList qn;
+	for (int i = 0; i < size(); ++i) {
+		qn.append(*at(i));
+	}
+	return qn;
+}
+
+/*!
+    QT4 INTEROPERABILITY
+*/
+// TQStringList TQStringList::operator=( const QStringList qs )
+// {
+// 	TQStringList qn;
+// 	for (int i = 0; i < qs.size(); ++i) {
+// 		qn.append(qs.at(i));
+// 	}
+// 	return qn;
+// }
+
+/*!
+    QT4 INTEROPERABILITY
+*/
+TQStringList TQStringList::convertFromQStringList( const QStringList qs )
+{
+	TQStringList qn;
+	for (int i = 0; i < qs.size(); ++i) {
+		qn.append(qs.at(i));
+	}
+	return qn;
+}
+
+#endif // USE_QT4
+
+#endif //TQT_NO_STRINGLIST
diff --git a/tqtinterface/qt4/src/tools/tqstringlist.h b/tqtinterface/qt4/src/tools/tqstringlist.h
new file mode 100644
index 0000000..6ca6802
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqstringlist.h
@@ -0,0 +1,116 @@
+/****************************************************************************
+**
+** Definition of TQStringList class
+**
+** Created : 990406
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQSTRINGLIST_H
+#define TQSTRINGLIST_H
+
+#include "tqtglobaldefines.h"
+
+#ifndef TQT_H
+#include "tqvaluelist.h"
+#include "tqstring.h"
+#include "tqstrlist.h"
+#endif // TQT_H
+
+#ifndef TQT_NO_STRINGLIST
+
+class TQRegExp;
+template <class T> class TQDeepCopy;
+
+#if defined(TQ_TEMPLATEDLL)
+// TQMOC_SKIP_BEGIN
+//TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQValueList<TQString>;
+// TQMOC_SKIP_END
+#endif
+
+class TQ_EXPORT TQStringList : public TQValueList<TQString>
+{
+public:
+    TQStringList() { }
+    TQStringList( const TQStringList& l ) : TQValueList<TQString>(l) { }
+    TQStringList( const TQValueList<TQString>& l ) : TQValueList<TQString>(l) { }
+    TQStringList( const TQString& i ) { append(i); }
+#ifndef TQT_NO_CAST_ASCII
+    TQStringList( const char* i ) { append(i); }
+#endif
+
+    static TQStringList fromStrList(const TQStrList&);
+
+    void sort();
+
+    static TQStringList split( const TQString &sep, const TQString &str, bool allowEmptyEntries = FALSE );
+    static TQStringList split( const TQChar &sep, const TQString &str, bool allowEmptyEntries = FALSE );
+#ifndef TQT_NO_REGEXP
+    static TQStringList split( const TQRegExp &sep, const TQString &str, bool allowEmptyEntries = FALSE );
+#endif
+    TQString join( const TQString &sep ) const;
+
+    TQStringList grep( const TQString &str, bool cs = TRUE ) const;
+#ifndef TQT_NO_REGEXP
+    TQStringList grep( const TQRegExp &expr ) const;
+#endif
+
+    TQStringList& gres( const TQString &before, const TQString &after,
+		       bool cs = TRUE );
+#ifndef TQT_NO_REGEXP_CAPTURE
+    TQStringList& gres( const TQRegExp &expr, const TQString &after );
+#endif
+
+#ifdef USE_QT4
+    // Interoperability
+//     TQStringList( const QStringList &qs );
+    operator QStringList() const;
+//     TQStringList operator=( const QStringList qs );
+    static TQStringList convertFromQStringList( const QStringList qs );
+#endif // USE_QT4
+
+protected:
+    void detach() { TQValueList<TQString>::detach(); }
+    friend class TQDeepCopy< TQStringList >;
+};
+
+#ifndef TQT_NO_DATASTREAM
+class TQDataStream;
+extern TQ_EXPORT TQDataStream &operator>>( TQDataStream &, TQStringList& );
+extern TQ_EXPORT TQDataStream &operator<<( TQDataStream &, const TQStringList& );
+#endif
+
+#endif // TQT_NO_STRINGLIST
+#endif // TQSTRINGLIST_H
diff --git a/tqtinterface/qt4/src/tools/tqstrlist.h b/tqtinterface/qt4/src/tools/tqstrlist.h
new file mode 100644
index 0000000..5dbc9c8
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqstrlist.h
@@ -0,0 +1,175 @@
+/****************************************************************************
+**
+** Definition of TQStrList, TQStrIList and TQStrListIterator classes
+**
+** Created : 920730
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQSTRLIST_H
+#define TQSTRLIST_H
+
+#ifndef TQT_H
+#include "tqstring.h"
+#include "tqptrlist.h"
+#include "tqdatastream.h"
+#endif // TQT_H
+
+#ifdef USE_QT4
+
+#include <Qt/qlist.h>
+
+#endif // USE_QT4
+
+#if defined(TQ_TQDOC)
+class TQStrListIterator : public TQPtrListIterator<char>
+{
+};
+#else
+typedef TQPtrListIterator<char> TQStrListIterator;
+#endif
+
+class TQ_EXPORT TQStrList : public TQPtrList<char>
+{
+public:
+    TQStrList( bool deepCopies=TRUE ) { dc = deepCopies; del_item = deepCopies; }
+    TQStrList( const TQStrList & );
+    ~TQStrList()			{ clear(); }
+    TQStrList& operator=( const TQStrList & );
+
+#ifdef USE_QT4
+    // Interoperability
+//     TQStrList( const QList<QByteArray> &ql );
+//     operator QStrList() const;
+//     TQStrList &operator=( const QList<QByteArray> &ql );
+//     TQStrList convertFromQStrList( const QList<QByteArray> &ql );
+
+#endif // USE_QT4
+
+private:
+    TQPtrCollection::Item newItem( TQPtrCollection::Item d ) { return dc ? qstrdup( (const char*)d ) : d; }
+    void deleteItem( TQPtrCollection::Item d ) { if ( del_item ) delete[] (char*)d; }
+    int compareItems( TQPtrCollection::Item s1, TQPtrCollection::Item s2 ) { return qstrcmp((const char*)s1,
+							 (const char*)s2); }
+#ifndef TQT_NO_DATASTREAM
+    TQDataStream &read( TQDataStream &s, TQPtrCollection::Item &d )
+				{ s >> (char *&)d; return s; }
+    QDataStream &write( QDataStream &s, TQPtrCollection::Item d ) const
+				{ return s << (const char *)d; }
+#endif
+    bool  dc;
+};
+
+
+class TQ_EXPORT TQStrIList : public TQStrList	// case insensitive string list
+{
+public:
+    TQStrIList( bool deepCopies=TRUE ) : TQStrList( deepCopies ) {}
+    ~TQStrIList()			{ clear(); }
+private:
+    int	  compareItems( TQPtrCollection::Item s1, TQPtrCollection::Item s2 )
+				{ return qstricmp((const char*)s1,
+						    (const char*)s2); }
+};
+
+
+inline TQStrList & TQStrList::operator=( const TQStrList &strList )
+{
+    clear();
+    dc = strList.dc;
+    del_item = dc;
+    TQPtrList<char>::operator=( strList );
+    return *this;
+}
+
+inline TQStrList::TQStrList( const TQStrList &strList )
+    : TQPtrList<char>( strList )
+{
+    dc = FALSE;
+    operator=( strList );
+}
+
+#ifdef USE_QT4
+
+// Interoperability
+// FIXME
+// These conversions are probably too weak
+
+#if 0
+/*!
+    QT4 INTEROPERABILITY
+*/
+TQStringList::TQStringList( const QList<QByteArray> &ql )
+{
+	setAscii( TQString(qs).ascii() );
+}
+
+/*!
+    QT4 INTEROPERABILITY
+*/
+TQStringList::operator QStringList() const
+{
+	return QStringList::fromUtf8( this->utf8() );
+}
+
+/*!
+    QT4 INTEROPERABILITY
+*/
+TQStringList &TQStringList::operator=( const QList<QByteArray> &ql )
+{
+	TQStringList qn;
+	for (int i = 0; i < qs.size(); ++i) {
+		qn.append(qs.at(i));
+	}
+	return qn;
+}
+
+#endif
+
+/*!
+    QT4 INTEROPERABILITY
+*/
+inline TQStrList convertFromQStrList( const QList<QByteArray> &ql )
+{
+	TQStrList qn;
+	qn.clear();
+        for (int i = 0; i < ql.size(); ++i)
+            qn.append(ql.at(i).constData());
+	return qn;
+}
+
+#endif // USE_QT4
+
+#endif // TQSTRLIST_H
diff --git a/tqtinterface/qt4/src/tools/tqstrvec.h b/tqtinterface/qt4/src/tools/tqstrvec.h
new file mode 100644
index 0000000..d3a35bf
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqstrvec.h
@@ -0,0 +1,85 @@
+/****************************************************************************
+**
+** Definition of TQStrVec and TQStrIVec classes
+**
+** Created : 931203
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQSTRVEC_H
+#define TQSTRVEC_H
+
+#ifndef TQT_H
+#include "tqstring.h"
+#include "tqptrvector.h"
+#include "tqdatastream.h"
+#endif // TQT_H
+
+class TQ_EXPORT TQStrVec : public TQPtrVector<char>
+{
+public:
+    TQStrVec()  { dc = TRUE; }
+    TQStrVec( uint size, bool deepc = TRUE ) : TQPtrVector<char>(size) {dc=deepc;}
+   ~TQStrVec()  { clear(); }
+private:
+    Item	 newItem( Item d )	{ return dc ? qstrdup( (const char*)d ) : d; }
+    void deleteItem( Item d )	{ if ( dc ) delete[] (char*)d; }
+    int	 compareItems( Item s1, Item s2 )
+				{ return qstrcmp((const char*)s1,
+						(const char*)s2); }
+#ifndef TQT_NO_DATASTREAM
+    TQDataStream &read( TQDataStream &s, Item &d )
+				{ s >> (char *&)d; return s; }
+    TQDataStream &write( TQDataStream &s, Item d ) const
+				{ return s << (const char*)d; }
+#endif
+    bool dc;
+};
+
+
+class TQ_EXPORT TQStrIVec : public TQStrVec	// case insensitive string vec
+{
+public:
+    TQStrIVec() {}
+    TQStrIVec( uint size, bool dc = TRUE ) : TQStrVec( size, dc ) {}
+   ~TQStrIVec() { clear(); }
+private:
+    int	 compareItems( Item s1, Item s2 )
+				{ return qstricmp((const char*)s1,
+						 (const char*)s2); }
+};
+
+
+#endif // TQSTRVEC_H
diff --git a/tqtinterface/qt4/src/tools/tqtextstream.cpp b/tqtinterface/qt4/src/tools/tqtextstream.cpp
new file mode 100644
index 0000000..842cb7e
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqtextstream.cpp
@@ -0,0 +1,2663 @@
+/****************************************************************************
+**
+** Implementation of TQTextStream class
+**
+** Created : 940922
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "tqtextstream.h"
+
+#ifndef TQT_NO_TEXTSTREAM
+#include "tqtextcodec.h"
+#include "tqregexp.h"
+#include "tqbuffer.h"
+#include "tqfile.h"
+#include <stdio.h>
+#include <ctype.h>
+#include <stdlib.h>
+#ifndef TQ_OS_TEMP
+#include <locale.h>
+#endif
+
+#if defined(TQ_OS_WIN32)
+#include "tqt_windows.h"
+#endif
+
+/*!
+    \class TQTextStream tqtextstream.h
+    \reentrant
+    \brief The TQTextStream class provides basic functions for reading
+    and writing text using a TQIODevice.
+
+    \ingroup io
+    \ingroup text
+    \mainclass
+
+    The text stream class has a functional interface that is very
+    similar to that of the standard C++ iostream class.
+
+    TQt provides several global functions similar to the ones in iostream:
+    \table
+    \header \i Function \i Meaning
+    \row \i bin \i sets the TQTextStream to read/write binary numbers
+    \row \i oct \i sets the TQTextStream to read/write octal numbers
+    \row \i dec \i sets the TQTextStream to read/write decimal numbers
+    \row \i hex \i sets the TQTextStream to read/write hexadecimal numbers
+    \row \i endl \i forces a line break
+    \row \i flush \i forces the TQIODevice to flush any buffered data
+    \row \i ws \i eats any available whitespace (on input)
+    \row \i reset \i resets the TQTextStream to its default mode (see reset())
+    \row \i qSetW(int) \i sets the \link width() field width \endlink
+    to the given argument
+    \row \i qSetFill(int) \i sets the \link fill() fill character
+    \endlink to the given argument
+    \row \i qSetPrecision(int) \i sets the \link precision() precision
+    \endlink to the given argument
+    \endtable
+
+    \warning By default TQTextStream will automatically detect whether
+    integers in the stream are in decimal, octal, hexadecimal or
+    binary format when reading from the stream. In particular, a
+    leading '0' signifies octal, i.e. the sequence "0100" will be
+    interpreted as 64.
+
+    The TQTextStream class reads and writes text; it is not appropriate
+    for dealing with binary data (but TQDataStream is).
+
+    By default, output of Unicode text (i.e. TQString) is done using
+    the local 8-bit encoding. This can be changed using the
+    setEncoding() method. For input, the TQTextStream will auto-detect
+    standard Unicode "byte order marked" text files; otherwise the
+    local 8-bit encoding is used.
+
+    The TQIODevice is set in the constructor, or later using
+    setDevice(). If the end of the input is reached atEnd() returns
+    TRUE. Data can be read into variables of the appropriate type
+    using the operator>>() overloads, or read in its entirety into a
+    single string using read(), or read a line at a time using
+    readLine(). Whitespace can be skipped over using skipWhiteSpace().
+    You can set flags for the stream using flags() or setf(). The
+    stream also supports width(), precision() and fill(); use reset()
+    to reset the defaults.
+
+    \sa TQDataStream
+*/
+
+/*!
+    \enum TQTextStream::Encoding
+
+    \value Locale
+    \value Latin1
+    \value Unicode
+    \value UnicodeNetworkOrder
+    \value UnicodeReverse
+    \value RawUnicode
+    \value UnicodeUTF8
+
+    See setEncoding() for an explanation of the encodings.
+*/
+
+/*
+  \class TQTSManip
+
+  \brief The TQTSManip class is an internal helper class for the
+  TQTextStream.
+
+  It is generally a very bad idea to use this class directly in
+  application programs.
+
+  \internal
+
+  This class makes it possible to give the TQTextStream function objects
+  with arguments, like this:
+  \code
+    TQTextStream cout( stdout, IO_WriteOnly );
+    cout << setprecision( 8 );		// TQTSManip used here!
+    cout << 3.14159265358979323846;
+  \endcode
+
+  The setprecision() function returns a TQTSManip object.
+  The TQTSManip object tqcontains a pointer to a member function in
+  TQTextStream and an integer argument.
+  When serializing a TQTSManip into a TQTextStream, the function
+  is executed with the argument.
+*/
+
+/*! \fn TQTSManip::TQTSManip( TQTSMFI m, int a )
+
+  Constructs a TQTSManip object which will call \a m (a member function
+  in TQTextStream which accepts a single int) with argument \a a when
+  TQTSManip::exec() is called. Used internally in e.g. endl:
+
+  \code
+    s << "some text" << endl << "more text";
+  \endcode
+*/
+
+/*! \fn void TQTSManip::exec( TQTextStream& s )
+
+  Calls the member function specified in the constructor, for object
+  \a s. Used internally in e.g. endl:
+
+  \code
+    s << "some text" << endl << "more text";
+  \endcode
+*/
+
+
+/*****************************************************************************
+  TQTextStream member functions
+ *****************************************************************************/
+
+#if defined(TQT_CHECK_STATE)
+#undef  CHECK_STREAM_PRECOND
+#define CHECK_STREAM_PRECOND  if ( !dev ) {				\
+				qWarning( "TQTextStream: No tqdevice" );	\
+				return *this; }
+#else
+#define CHECK_STREAM_PRECOND
+#endif
+
+
+#define I_SHORT		0x0010
+#define I_INT		0x0020
+#define I_LONG		0x0030
+#define I_TYPE_MASK	0x00f0
+
+#define I_BASE_2	TQTS::bin
+#define I_BASE_8	TQTS::oct
+#define I_BASE_10	TQTS::dec
+#define I_BASE_16	TQTS::hex
+#define I_BASE_MASK	(TQTS::bin | TQTS::oct | TQTS::dec | TQTS::hex)
+
+#define I_SIGNED	0x0100
+#define I_UNSIGNED	0x0200
+#define I_SIGN_MASK	0x0f00
+
+
+static const TQChar TQEOF = TQChar((ushort)0xffff); //guaranteed not to be a character.
+static const uint getline_buf_size = 256; // bufsize used by ts_getline()
+
+const int TQTextStream::basefield   = I_BASE_MASK;
+const int TQTextStream::adjustfield = ( TQTextStream::left |
+				       TQTextStream::right |
+				       TQTextStream::internal );
+const int TQTextStream::floatfield  = ( TQTextStream::scientific |
+				       TQTextStream::fixed );
+
+
+class TQTextStreamPrivate {
+public:
+#ifndef TQT_NO_TEXTCODEC
+    TQTextStreamPrivate()
+	: decoder( 0 ), encoder( 0 ), sourceType( NotSet ) { }
+    ~TQTextStreamPrivate() {
+	delete decoder;
+	delete encoder;
+    }
+    TQTextDecoder *decoder;
+    TQTextEncoder *encoder;
+#else
+    TQTextStreamPrivate() : sourceType( NotSet ) { }
+    ~TQTextStreamPrivate() { }
+#endif
+    TQString ungetcBuf;
+
+    enum SourceType { NotSet, IODevice, String, ByteArray, File };
+    SourceType sourceType;
+};
+
+
+// skips whitespace and returns the first non-whitespace character
+TQChar TQTextStream::eat_ws()
+{
+    TQChar c;
+    do { c = ts_getc(); } while ( c != TQEOF && ts_isspace(c) );
+    return c;
+}
+
+void TQTextStream::init()
+{
+    // ### ungetcBuf = TQEOF;
+    dev = 0;
+    owndev = FALSE;
+    mapper = 0;
+    d = new TQTextStreamPrivate;
+    doUnicodeHeader = TRUE; // autodetect
+    latin1 = TRUE; // should use locale?
+    internalOrder = TQChar::networkOrdered();
+    networkOrder = TRUE;
+}
+
+/*!
+    Constructs a data stream that has no IO tqdevice.
+*/
+
+TQTextStream::TQTextStream()
+{
+    init();
+    setEncoding( Locale );
+    reset();
+    d->sourceType = TQTextStreamPrivate::NotSet;
+}
+
+/*!
+    Constructs a text stream that uses the IO tqdevice \a iod.
+*/
+
+TQTextStream::TQTextStream( QIODevice *iod )
+{
+    init();
+    setEncoding( Locale );
+    dev = TQT_TQIODEVICE(iod);
+    reset();
+    d->sourceType = TQTextStreamPrivate::IODevice;
+}
+
+/*!
+    Constructs a text stream that uses the IO tqdevice \a iod.
+*/
+
+TQTextStream::TQTextStream( QFile *iod )
+{
+    init();
+    setEncoding( Locale );
+    dev = TQT_TQIODEVICE(iod);
+    reset();
+    d->sourceType = TQTextStreamPrivate::IODevice;
+}
+
+// TODO: use special-case handling of this case in TQTextStream, and
+//	 simplify this class to only deal with TQChar or TQString data.
+class TQStringBuffer : public TQIODevice {
+public:
+    TQStringBuffer( TQString* str );
+    ~TQStringBuffer();
+    bool  open( int m );
+    void  close();
+    void  flush();
+#ifdef USE_QT4
+    qint64  size() const;
+#else
+    Offset  size() const;
+#endif
+    Offset  at()   const;
+    bool  at( Offset pos );
+#ifdef USE_QT4
+    qint64 readData( char *p, qint64 len );
+    qint64 writeData( const char *p, qint64 len );
+#else
+    TQ_LONG readBlock( char *p, TQ_ULONG len );
+    TQ_LONG writeBlock( const char *p, TQ_ULONG len );
+#endif
+    int   getch();
+    int   putch( int ch );
+    int   ungetch( int ch );
+protected:
+    TQString* s;
+
+private:
+    TQStringBuffer( const TQStringBuffer & );
+    TQStringBuffer &operator=( const TQStringBuffer & );
+};
+
+
+TQStringBuffer::TQStringBuffer( TQString* str )
+{
+    s = str;
+}
+
+TQStringBuffer::~TQStringBuffer()
+{
+}
+
+
+bool TQStringBuffer::open( int m )
+{
+    if ( !s ) {
+#if defined(TQT_CHECK_STATE)
+	qWarning( "TQStringBuffer::open: No string" );
+#endif
+	return FALSE;
+    }
+    if ( isOpen() ) {
+#if defined(TQT_CHECK_STATE)
+	qWarning( "TQStringBuffer::open: Buffer already open" );
+#endif
+	return FALSE;
+    }
+    setMode( m );
+    if ( m & IO_Truncate )
+	s->truncate( 0 );
+
+    if ( m & IO_Append ) {
+	seek(s->length()*sizeof(TQChar));
+    } else {
+	seek(0);
+    }
+    setState( IO_Open );
+    resetqStatus();
+    return TRUE;
+}
+
+void TQStringBuffer::close()
+{
+    if ( isOpen() ) {
+	setFlags( IO_Direct );
+	seek(0);
+    }
+}
+
+void TQStringBuffer::flush()
+{
+}
+
+#ifdef USE_QT4
+qint64 TQStringBuffer::size() const
+#else
+TQIODevice::Offset TQStringBuffer::size() const
+#endif
+{
+    return s ? s->length()*sizeof(TQChar) : 0;
+}
+
+TQIODevice::Offset  TQStringBuffer::at()   const
+{
+    return pos();
+}
+
+bool TQStringBuffer::at( Offset pos )
+{
+#if defined(TQT_CHECK_STATE)
+    if ( !isOpen() ) {
+	qWarning( "TQStringBuffer::at: Buffer is not open" );
+	return FALSE;
+    }
+#endif
+    if ( pos >= s->length()*2 ) {
+#if defined(TQT_CHECK_RANGE)
+#if defined(TQT_ABI_QT4)
+	qWarning( "TQStringBuffer::at: Index %lld out of range", pos );
+#else
+	qWarning( "TQStringBuffer::at: Index %lu out of range", pos );
+#endif
+#endif
+	return FALSE;
+    }
+    seek(pos);
+    return TRUE;
+}
+
+#ifdef USE_QT4
+qint64 TQStringBuffer::readData( char *p, qint64 len )
+#else
+TQ_LONG TQStringBuffer::readBlock( char *p, TQ_ULONG len )
+#endif
+{
+#if defined(TQT_CHECK_STATE)
+    TQ_CHECK_PTR( p );
+    if ( !isOpen() ) {
+	qWarning( "TQStringBuffer::readBlock: Buffer not open" );
+	return -1;
+    }
+    if ( !isReadable() ) {
+	qWarning( "TQStringBuffer::readBlock: Read operation not permitted" );
+	return -1;
+    }
+#endif
+    if ( pos() + len > s->length()*sizeof(TQChar) ) {
+	// overflow
+	if ( (uint)pos() >= s->length()*sizeof(TQChar) ) {
+	    setqStatus( IO_ReadError );
+	    return -1;
+	} else {
+	    len = s->length()*2 - (uint)pos();
+	}
+    }
+    memcpy( p, ((const char*)(s->tqunicode()))+pos(), len );
+    seek(pos()+len);
+    return len;
+}
+
+#ifdef USE_QT4
+qint64 TQStringBuffer::writeData( const char *p, qint64 len )
+#else
+TQ_LONG TQStringBuffer::writeBlock( const char *p, TQ_ULONG len )
+#endif
+{
+#if defined(TQT_CHECK_NULL)
+    if ( p == 0 && len != 0 )
+	qWarning( "TQStringBuffer::writeBlock: Null pointer error" );
+#endif
+#if defined(TQT_CHECK_STATE)
+    if ( !isOpen() ) {
+	qWarning( "TQStringBuffer::writeBlock: Buffer not open" );
+	return -1;
+    }
+    if ( !isWritable() ) {
+	qWarning( "TQStringBuffer::writeBlock: Write operation not permitted" );
+	return -1;
+    }
+    if ( pos()&1 ) {
+	qWarning( "TQStringBuffer::writeBlock: non-even index - non Unicode" );
+	return -1;
+    }
+    if ( len&1 ) {
+	qWarning( "TQStringBuffer::writeBlock: non-even length - non Unicode" );
+	return -1;
+    }
+#endif
+    s->tqreplace(pos()/2, len/2, (TQChar*)p, len/2);
+    seek(pos()+len);
+    return len;
+}
+
+int TQStringBuffer::getch()
+{
+#if defined(TQT_CHECK_STATE)
+    if ( !isOpen() ) {
+	qWarning( "TQStringBuffer::getch: Buffer not open" );
+	return -1;
+    }
+    if ( !isReadable() ) {
+	qWarning( "TQStringBuffer::getch: Read operation not permitted" );
+	return -1;
+    }
+#endif
+    if ( (uint)pos() >= s->length()*2 ) {           // overflow
+	setqStatus( IO_ReadError );
+	return -1;
+    }
+    int retval = (int)((const uchar *)s->tqunicode())[pos()];
+    seek(pos()+1);
+    return retval;
+}
+
+int TQStringBuffer::putch( int ch )
+{
+    char c = ch;
+    if ( writeBlock(&c,1) < 0 )
+	return -1;
+    else
+	return ch;
+}
+
+int TQStringBuffer::ungetch( int ch )
+{
+#if defined(TQT_CHECK_STATE)
+    if ( !isOpen() ) {
+	qWarning( "TQStringBuffer::ungetch: Buffer not open" );
+	return -1;
+    }
+    if ( !isReadable() ) {
+	qWarning( "TQStringBuffer::ungetch: Read operation not permitted" );
+	return -1;
+    }
+#endif
+    if ( ch != -1 ) { // something to do with eof
+	if ( pos() )
+	    seek(pos()-1);
+	else
+	    ch = -1;
+    }
+    return ch;
+}
+
+
+/*!
+    Constructs a text stream that operates on the Unicode TQString, \a
+    str, through an internal tqdevice. The \a filemode argument is
+    passed to the tqdevice's open() function; see \l{TQIODevice::mode()}.
+
+    If you set an encoding or codec with setEncoding() or setCodec(),
+    this setting is ignored for text streams that operate on TQString.
+
+    Example:
+    \code
+    TQString str;
+    TQTextStream ts( &str, IO_WriteOnly );
+    ts << "pi = " << 3.14; // str == "pi = 3.14"
+    \endcode
+
+    Writing data to the text stream will modify the contents of the
+    string. The string will be expanded when data is written beyond
+    the end of the string. Note that the string will not be truncated:
+    \code
+    TQString str = "pi = 3.14";
+    TQTextStream ts( &str, IO_WriteOnly );
+    ts <<  "2+2 = " << 2+2; // str == "2+2 = 414"
+    \endcode
+
+    Note that because TQString is Unicode, you should not use
+    readRawBytes() or writeRawBytes() on such a stream.
+*/
+
+TQTextStream::TQTextStream( TQString* str, int filemode )
+{
+    // TODO: optimize for this case as it becomes more common
+    //        (see TQStringBuffer above)
+    init();
+    dev = new TQStringBuffer( str );
+    ((TQStringBuffer *)dev)->open( filemode );
+    owndev = TRUE;
+    setEncoding(RawUnicode);
+    reset();
+    d->sourceType = TQTextStreamPrivate::String;
+}
+
+/*! \obsolete
+
+  This constructor is equivalent to the constructor taking a TQString*
+  parameter.
+*/
+
+TQTextStream::TQTextStream( TQString& str, int filemode )
+{
+    init();
+    dev = new TQStringBuffer( &str );
+    ((TQStringBuffer *)dev)->open( filemode );
+    owndev = TRUE;
+    setEncoding(RawUnicode);
+    reset();
+    d->sourceType = TQTextStreamPrivate::String;
+}
+
+/*!
+    Constructs a text stream that operates on the byte array, \a a,
+    through an internal TQBuffer tqdevice. The \a mode argument is passed
+    to the tqdevice's open() function; see \l{TQIODevice::mode()}.
+
+    Example:
+    \code
+    TQByteArray array;
+    TQTextStream ts( array, IO_WriteOnly );
+    ts << "pi = " << 3.14 << '\0'; // array == "pi = 3.14"
+    \endcode
+
+    Writing data to the text stream will modify the contents of the
+    array. The array will be expanded when data is written beyond the
+    end of the string.
+
+    Same example, using a TQBuffer:
+    \code
+    TQByteArray array;
+    TQBuffer buf( array );
+    buf.open( IO_WriteOnly );
+    TQTextStream ts( &buf );
+    ts << "pi = " << 3.14 << '\0'; // array == "pi = 3.14"
+    buf.close();
+    \endcode
+*/
+
+TQTextStream::TQTextStream( TQByteArray a, int mode )
+{
+    init();
+    dev = TQT_TQIODEVICE(new TQBuffer( a ));
+    ((TQBuffer *)dev)->open( (QIODevice::OpenModeFlag)mode );
+    owndev = TRUE;
+    setEncoding( Latin1 ); //### Locale???
+    reset();
+    d->sourceType = TQTextStreamPrivate::ByteArray;
+}
+
+/*!
+    Constructs a text stream that operates on an existing file handle
+    \a fh through an internal TQFile tqdevice. The \a mode argument is
+    passed to the tqdevice's open() function; see \l{TQIODevice::mode()}.
+
+    Note that if you create a TQTextStream \c cout or another name that
+    is also used for another variable of a different type, some
+    linkers may confuse the two variables, which will often cause
+    crashes.
+*/
+
+TQTextStream::TQTextStream( FILE *fh, int mode )
+{
+    init();
+    setEncoding( Locale ); //###
+    dev = TQT_TQIODEVICE(new TQFile);
+    ((TQFile *)dev)->open( mode, fh );
+    owndev = TRUE;
+    reset();
+    d->sourceType = TQTextStreamPrivate::File;
+}
+
+/*!
+    Destroys the text stream.
+
+    The destructor does not affect the current IO tqdevice.
+*/
+
+TQTextStream::~TQTextStream()
+{
+    if ( owndev )
+	delete dev;
+    delete d;
+}
+
+/*!
+    Positions the read pointer at the first non-whitespace character.
+*/
+void TQTextStream::skipWhiteSpace()
+{
+    ts_ungetc( eat_ws() );
+}
+
+/*!
+    Internal.
+*/
+int TQTextStream::dev_getch() {
+	if (d->sourceType == TQTextStreamPrivate::String)
+		return static_cast<TQStringBuffer*>(dev)->getch();
+	else
+		return dev->getch();
+}
+
+/*!
+    Internal.
+*/
+int TQTextStream::dev_ungetch(int ch) {
+	if (d->sourceType == TQTextStreamPrivate::String)
+		return static_cast<TQStringBuffer*>(dev)->ungetch(ch);
+	else
+		return dev->ungetch(ch);
+}
+
+/*!
+    Tries to read \a len characters from the stream and stores them in
+    \a buf. Returns the number of characters really read.
+
+    \warning There will no TQEOF appended if the read reaches the end
+    of the file. EOF is reached when the return value does not equal
+    \a len.
+*/
+uint TQTextStream::ts_getbuf( TQChar* buf, uint len )
+{
+    if ( len < 1 )
+	return 0;
+
+    uint rnum = 0;   // the number of TQChars really read
+
+    if ( d && d->ungetcBuf.length() ) {
+	while ( rnum < len && rnum < d->ungetcBuf.length() ) {
+	    *buf = d->ungetcBuf.constref( rnum );
+	    buf++;
+	    rnum++;
+	}
+	d->ungetcBuf = d->ungetcBuf.mid( rnum );
+	if ( rnum >= len )
+	    return rnum;
+    }
+
+    // we use dev_ungetch() for one of the bytes of the tqunicode
+    // byte-order mark, but a local unget hack for the other byte:
+    int ungetHack = EOF;
+
+    if ( doUnicodeHeader ) {
+	doUnicodeHeader = FALSE; // only at the top
+	int c1 = dev_getch();
+	if ( c1 == EOF )
+	    return rnum;
+	int c2 = dev_getch();
+	if ( c1 == 0xfe && c2 == 0xff ) {
+	    mapper = 0;
+	    latin1 = FALSE;
+	    internalOrder = TQChar::networkOrdered();
+	    networkOrder = TRUE;
+	} else if ( c1 == 0xff && c2 == 0xfe ) {
+	    mapper = 0;
+	    latin1 = FALSE;
+	    internalOrder = !TQChar::networkOrdered();
+	    networkOrder = FALSE;
+	} else {
+	    if ( c2 != EOF ) {
+	 	dev_ungetch( c2 );
+		ungetHack = c1;
+	    } else {
+		/*
+		  A small bug might hide here. If only the first byte
+		  of a file has made it so far, and that first byte
+		  is half of the byte-order mark, then the utfness
+		  will not be detected.
+		*/
+	 	dev_ungetch( c1 );
+	    }
+	}
+    }
+
+#ifndef TQT_NO_TEXTCODEC
+    if ( mapper ) {
+	bool shortRead = FALSE;
+	if ( !d->decoder )
+	    d->decoder = mapper->makeDecoder();
+	while( rnum < len ) {
+	    TQString s;
+	    bool readBlock = !( len == 1+rnum );
+	    for (;;) {
+		// for efficiency: normally read a whole block
+		if ( readBlock ) {
+		    // guess buffersize; this may be wrong (too small or too
+		    // big). But we can handle this (either iterate reading
+		    // or use ungetcBuf).
+		    // Note that this might cause problems for codecs where
+		    // one byte can result in >1 Unicode Characters if bytes
+		    // are written to the stream in the meantime (loss of
+		    // synchronicity).
+		    uint rlen = len - rnum;
+		    char *cbuf = new char[ rlen ];
+		    if ( ungetHack != EOF ) {
+			rlen = 1+dev->readBlock( cbuf+1, rlen-1 );
+			cbuf[0] = (char)ungetHack;
+			ungetHack = EOF;
+		    } else {
+			rlen = dev->readBlock( cbuf, rlen );
+		    }
+		    s  += d->decoder->toUnicode( cbuf, rlen );
+		    delete[] cbuf;
+		    // use buffered reading only for the first time, because we
+		    // have to get the stream synchronous again (this is easier
+		    // with single character reading)
+		    readBlock = FALSE;
+		}
+		// get stream (and codec) in sync
+		int c;
+		if ( ungetHack == EOF ) {
+		    c = dev_getch();
+		} else {
+		    c = ungetHack;
+		    ungetHack = EOF;
+		}
+		if ( c == EOF ) {
+		    shortRead = TRUE;
+		    break;
+		}
+		char b = c;
+		uint lengthBefore = s.length();
+		s += d->decoder->toUnicode( &b, 1 );
+		if ( s.length() > lengthBefore )
+		    break; // it seems we are in sync now
+	    }
+	    uint i = 0;
+	    uint end = TQMIN( len-rnum, s.length() );
+	    while( i < end ) {
+		*buf = s.constref(i++);
+		buf++;
+	    }
+	    rnum += end;
+	    if ( s.length() > i ) {
+		// could be = but append is clearer
+		d->ungetcBuf.append( s.mid( i ) );
+	    }
+	    if ( shortRead )
+		return rnum;
+	}
+    } else
+#endif
+    if ( latin1 ) {
+	if ( len == 1+rnum ) {
+	    // use this method for one character because it is more efficient
+	    // (arnt doubts whether it makes a difference, but lets it stand)
+	    int c = (ungetHack == EOF) ? dev_getch() : ungetHack;
+	    if ( c != EOF ) {
+		*buf = (char)c;
+		buf++;
+		rnum++;
+	    }
+	} else {
+	    if ( ungetHack != EOF ) {
+		*buf = (char)ungetHack;
+		buf++;
+		rnum++;
+		ungetHack = EOF;
+	    }
+	    char *cbuf = new char[len - rnum];
+	    while ( !dev->atEnd() && rnum < len ) {
+		uint rlen = len - rnum;
+		rlen = dev->readBlock( cbuf, rlen );
+		char *it = cbuf;
+		char *end = cbuf + rlen;
+		while ( it < end ) {
+		    *buf = *it;
+		    buf++;
+		    it++;
+		}
+		rnum += rlen;
+	    }
+	    delete[] cbuf;
+	}
+    } else { // UCS-2 or UTF-16
+	if ( len == 1+rnum ) {
+	    int c1 = (ungetHack == EOF) ? dev_getch() : ungetHack;
+	    if ( c1 == EOF )
+		return rnum;
+	    int c2 = dev_getch();
+	    if ( c2 == EOF )
+		return rnum;
+
+	    if ( networkOrder ) {
+		*buf = TQChar( c2, c1 );
+	    } else {
+		*buf = TQChar( c1, c2 );
+	    }
+	    buf++;
+	    rnum++;
+	} else {
+	    char *cbuf = new char[ 2*( len - rnum ) ]; // for paranoids: overflow possible
+	    while ( !dev->atEnd() && rnum < len ) {
+		uint rlen = 2 * ( len-rnum );
+		if ( ungetHack != EOF ) {
+		    rlen = 1+dev->readBlock( cbuf+1, rlen-1 );
+		    cbuf[0] = (char)ungetHack;
+		    ungetHack = EOF;
+		} else {
+		    rlen = dev->readBlock( cbuf, rlen );
+		}
+		// We can't use an odd number of bytes, so put it back. But
+		// do it only if we are capable of reading more -- normally
+		// there should not be an odd number, but the file might be
+		// truncated or not in UTF-16...
+		if ( (rlen & 1) == 1 )
+		    if ( !dev->atEnd() )
+			dev_ungetch( cbuf[--rlen] );
+		uint i = 0;
+		if ( networkOrder ) {
+		    while( i < rlen ) {
+			*buf = TQChar( cbuf[i+1], cbuf[i] );
+			buf++;
+			i+=2;
+		    }
+		} else {
+		    while( i < rlen ) {
+			*buf = TQChar( cbuf[i], cbuf[i+1] );
+			buf++;
+			i+=2;
+		    }
+		}
+		rnum += i/2;
+	    }
+	    delete[] cbuf;
+	}
+    }
+    return rnum;
+}
+
+/*!
+    Tries to read one line, but at most len characters from the stream
+    and stores them in \a buf.
+
+    Returns the number of characters really read. Newlines are not
+    stripped.
+
+    There will be a TQEOF appended if the read reaches the end of file;
+    this is different to ts_getbuf().
+
+    This function works only if a newline (as byte) is also a newline
+    (as resulting character) since it uses TQIODevice::readLine(). So
+    use it only for such codecs where this is true!
+
+    This function is (almost) a no-op for UTF 16. Don't use it if
+    doUnicodeHeader is TRUE!
+*/
+uint TQTextStream::ts_getline( TQChar* buf )
+{
+    uint rnum=0;   // the number of TQChars really read
+    char cbuf[ getline_buf_size+1 ];
+
+    if ( d && d->ungetcBuf.length() ) {
+	while( rnum < getline_buf_size && rnum < d->ungetcBuf.length() ) {
+	    buf[rnum] = d->ungetcBuf.constref(rnum);
+	    rnum++;
+	}
+	d->ungetcBuf = d->ungetcBuf.mid( rnum );
+	if ( rnum >= getline_buf_size )
+	    return rnum;
+    }
+
+#ifndef TQT_NO_TEXTCODEC
+    if ( mapper ) {
+	if ( !d->decoder )
+	    d->decoder = mapper->makeDecoder();
+	TQString s;
+	bool readBlock = TRUE;
+	for (;;) {
+	    // for efficiency: try to read a line
+	    if ( readBlock ) {
+		int rlen = getline_buf_size - rnum;
+		rlen = dev->readLine( cbuf, rlen+1 );
+		if ( rlen == -1 )
+		    rlen = 0;
+		s  += d->decoder->toUnicode( cbuf, rlen );
+		readBlock = FALSE;
+	    }
+	    if ( dev->atEnd()
+		    || s.at( s.length()-1 ) == '\n'
+		    || s.at( s.length()-1 ) == '\r'
+	       ) {
+		break;
+	    } else {
+		// get stream (and codec) in sync
+		int c;
+		c = dev_getch();
+		if ( c == EOF ) {
+		    break;
+		}
+		char b = c;
+		uint lengthBefore = s.length();
+		s  += d->decoder->toUnicode( &b, 1 );
+		if ( s.length() > lengthBefore )
+		    break; // it seems we are in sync now
+	    }
+	}
+	uint i = 0;
+	while( rnum < getline_buf_size && i < s.length() )
+	    buf[rnum++] = s.constref(i++);
+	if ( s.length() > i )
+	    // could be = but append is clearer
+	    d->ungetcBuf.append( s.mid( i ) );
+	if ( rnum < getline_buf_size && dev->atEnd() )
+	    buf[rnum++] = TQEOF;
+    } else
+#endif
+    if ( latin1 ) {
+	int rlen = getline_buf_size - rnum;
+	rlen = dev->readLine( cbuf, rlen+1 );
+	if ( rlen == -1 )
+	    rlen = 0;
+	char *end = cbuf+rlen;
+	char *it = cbuf;
+	buf +=rnum;
+	while ( it != end ) {
+	    buf->setCell( *(it++) );
+	    buf->setRow( 0 );
+	    buf++;
+	}
+	rnum += rlen;
+	if ( rnum < getline_buf_size && dev->atEnd() )
+	    buf[1] = TQEOF;
+    }
+    return rnum;
+}
+
+
+/*!
+    Puts one character into the stream.
+*/
+void TQTextStream::ts_putc( TQChar c )
+{
+#ifndef TQT_NO_TEXTCODEC
+    if ( mapper ) {
+	if ( !d->encoder )
+	    d->encoder = mapper->makeEncoder();
+	int len = 1;
+	TQString s = c;
+	TQCString block = d->encoder->fromUnicode( s, len );
+	dev->writeBlock( block, len );
+    } else
+#endif
+    if ( latin1 ) {
+	if ( c.row() )
+	    dev->putch( '?' ); // unknown character
+	else
+	    dev->putch( c.cell() );
+    } else {
+	if ( doUnicodeHeader ) {
+	    doUnicodeHeader = FALSE;
+	    ts_putc( TQChar::byteOrderMark );
+	}
+	if ( internalOrder ) {
+	    // this case is needed by TQStringBuffer
+	    dev->writeBlock( (char*)&c, sizeof(TQChar) );
+	} else if ( networkOrder ) {
+	    dev->putch( c.row() );
+	    dev->putch( c.cell() );
+	} else {
+	    dev->putch( c.cell() );
+	    dev->putch( c.row() );
+	}
+    }
+}
+
+/*!
+    Puts one character into the stream.
+*/
+void TQTextStream::ts_putc( int ch )
+{
+    ts_putc( TQChar((ushort)ch) );
+}
+
+bool TQTextStream::ts_isdigit( TQChar c )
+{
+    return c.isDigit();
+}
+
+bool TQTextStream::ts_isspace( TQChar c )
+{
+    return c.isSpace();
+}
+
+void TQTextStream::ts_ungetc( TQChar c )
+{
+    if ( c.tqunicode() == 0xffff )
+	return;
+
+    d->ungetcBuf.prepend( c );
+}
+
+
+
+/*!
+    Reads \a len bytes from the stream into \a s and returns a
+    reference to the stream.
+
+    The buffer \a s must be preallocated.
+
+    Note that no encoding is done by this function.
+
+    \warning The behavior of this function is undefined unless the
+    stream's encoding is set to Unicode or Latin1.
+
+    \sa TQIODevice::readBlock()
+*/
+
+TQTextStream &TQTextStream::readRawBytes( char *s, uint len )
+{
+    dev->readBlock( s, len );
+    return *this;
+}
+
+/*!
+    Writes the \a len bytes from \a s to the stream and returns a
+    reference to the stream.
+
+    Note that no encoding is done by this function.
+
+    \sa TQIODevice::writeBlock()
+*/
+
+TQTextStream &TQTextStream::writeRawBytes( const char* s, uint len )
+{
+    dev->writeBlock( s, len );
+    return *this;
+}
+
+
+TQTextStream &TQTextStream::writeBlock( const char* p, uint len )
+{
+    if ( doUnicodeHeader ) {
+	doUnicodeHeader = FALSE;
+	if ( !mapper && !latin1 )
+	    ts_putc( TQChar::byteOrderMark );
+    }
+    // TQCString and const char * are treated as Latin-1
+    if ( !mapper && latin1 ) {
+	dev->writeBlock( p, len );
+    } else if ( !mapper && internalOrder ) {
+	TQChar *u = new TQChar[len];
+	for ( uint i = 0; i < len; i++ )
+	    u[i] = p[i];
+	dev->writeBlock( (char*)u, len * sizeof(TQChar) );
+	delete [] u;
+    }
+#ifndef TQT_NO_TEXTCODEC
+    else if (mapper) {
+        if (!d->encoder)
+            d->encoder = mapper->makeEncoder();
+        TQString s = TQString::tqfromLatin1(p, len);
+        int l = len;
+        TQCString block = d->encoder->fromUnicode(s, l);
+        dev->writeBlock(block, l);
+    }
+#endif
+    else {
+	for ( uint i = 0; i < len; i++ )
+	    ts_putc( (uchar)p[i] );
+    }
+    return *this;
+}
+
+TQTextStream &TQTextStream::writeBlock( const TQChar* p, uint len )
+{
+#ifndef TQT_NO_TEXTCODEC
+    if ( mapper ) {
+	if ( !d->encoder )
+	    d->encoder = mapper->makeEncoder();
+	TQConstString s( p, len );
+	int l = len;
+	TQCString block = d->encoder->fromUnicode( s.string(), l );
+	dev->writeBlock( block, l );
+    } else
+#endif
+    if ( latin1 ) {
+	char *str = TQString::tqunicodeToLatin1( p, len );
+	dev->writeBlock( str, len );
+	delete [] str;
+    } else if ( internalOrder ) {
+	if ( doUnicodeHeader ) {
+	    doUnicodeHeader = FALSE;
+	    ts_putc( TQChar::byteOrderMark );
+	}
+	dev->writeBlock( (char*)p, sizeof(TQChar)*len );
+    } else {
+	for (uint i=0; i<len; i++)
+	    ts_putc( p[i] );
+    }
+    return *this;
+}
+
+/*!
+    Resets the text stream.
+
+    \list
+    \i All flags are set to 0.
+    \i The field width is set to 0.
+    \i The fill character is set to ' ' (Space).
+    \i The precision is set to 6.
+    \endlist
+
+    \sa setf(), width(), fill(), precision()
+*/
+
+void TQTextStream::reset()
+{
+    fflags = 0;
+    fwidth = 0;
+    fillchar = ' ';
+    fprec = 6;
+}
+
+/*!
+    \fn TQIODevice *TQTextStream::tqdevice() const
+
+    Returns the IO tqdevice currently set.
+
+    \sa setDevice(), unsetDevice()
+*/
+
+/*!
+    Sets the IO tqdevice to \a iod.
+
+    \sa tqdevice(), unsetDevice()
+*/
+
+void TQTextStream::setDevice( TQIODevice *iod )
+{
+    if ( owndev ) {
+	delete dev;
+	owndev = FALSE;
+    }
+    dev = iod;
+    d->sourceType = TQTextStreamPrivate::IODevice;
+}
+
+/*!
+    Unsets the IO tqdevice. Equivalent to setDevice( 0 ).
+
+    \sa tqdevice(), setDevice()
+*/
+
+void TQTextStream::unsetDevice()
+{
+    setDevice( 0 );
+    d->sourceType = TQTextStreamPrivate::NotSet;
+}
+
+/*!
+    \fn bool TQTextStream::atEnd() const
+
+    Returns TRUE if the IO tqdevice has reached the end position (end of
+    the stream or file) or if there is no IO tqdevice set; otherwise
+    returns FALSE.
+
+    \sa TQIODevice::atEnd()
+*/
+
+/*!\fn bool TQTextStream::eof() const
+
+  \obsolete
+
+  This function has been renamed to atEnd().
+
+  \sa TQIODevice::atEnd()
+*/
+
+/*****************************************************************************
+  TQTextStream read functions
+ *****************************************************************************/
+
+
+/*!
+    \overload
+
+    Reads a char \a c from the stream and returns a reference to the
+    stream. Note that whitespace is skipped.
+*/
+
+TQTextStream &TQTextStream::operator>>( char &c )
+{
+    CHECK_STREAM_PRECOND
+    c = eat_ws();
+    return *this;
+}
+
+/*!
+    Reads a char \a c from the stream and returns a reference to the
+    stream. Note that whitespace is \e not skipped.
+*/
+
+TQTextStream &TQTextStream::operator>>( TQChar &c )
+{
+    CHECK_STREAM_PRECOND
+    c = ts_getc();
+    return *this;
+}
+
+
+ulong TQTextStream::input_bin()
+{
+    ulong val = 0;
+    TQChar ch = eat_ws();
+    int dv = ch.digitValue();
+    while (  dv == 0 || dv == 1 ) {
+	val = ( val << 1 ) + dv;
+	ch = ts_getc();
+	dv = ch.digitValue();
+    }
+    if ( ch != TQEOF )
+	ts_ungetc( ch );
+    return val;
+}
+
+ulong TQTextStream::input_oct()
+{
+    ulong val = 0;
+    TQChar ch = eat_ws();
+    int dv = ch.digitValue();
+    while ( dv >= 0 && dv <= 7 ) {
+	val = ( val << 3 ) + dv;
+	ch = ts_getc();
+	dv = ch.digitValue();
+    }
+    if ( dv == 8 || dv == 9 ) {
+	while ( ts_isdigit(ch) )
+	    ch = ts_getc();
+    }
+    if ( ch != TQEOF )
+	ts_ungetc( ch );
+    return val;
+}
+
+ulong TQTextStream::input_dec()
+{
+    ulong val = 0;
+    TQChar ch = eat_ws();
+    int dv = ch.digitValue();
+    while ( ts_isdigit(ch) ) {
+	val = val * 10 + dv;
+	ch = ts_getc();
+	dv = ch.digitValue();
+    }
+    if ( ch != TQEOF )
+	ts_ungetc( ch );
+    return val;
+}
+
+ulong TQTextStream::input_hex()
+{
+    ulong val = 0;
+    TQChar ch = eat_ws();
+    char c = ch;
+    while ( isxdigit((uchar) c) ) {
+	val <<= 4;
+	if ( ts_isdigit(c) )
+	    val += c - '0';
+	else
+	    val += 10 + tolower( (uchar) c ) - 'a';
+	c = ch = ts_getc();
+    }
+    if ( ch != TQEOF )
+	ts_ungetc( ch );
+    return val;
+}
+
+long TQTextStream::input_int()
+{
+    long val;
+    TQChar ch;
+    char c;
+    switch ( flags() & basefield ) {
+    case bin:
+	val = (long)input_bin();
+	break;
+    case oct:
+	val = (long)input_oct();
+	break;
+    case dec:
+	c = ch = eat_ws();
+	if ( ch == TQEOF ) {
+	    val = 0;
+	} else {
+	    if ( !(c == '-' || c == '+') )
+		ts_ungetc( ch );
+	    if ( c == '-' ) {
+		ulong v = input_dec();
+		if ( v ) {		// ensure that LONG_MIN can be read
+		    v--;
+		    val = -((long)v) - 1;
+		} else {
+		    val = 0;
+		}
+	    } else {
+		val = (long)input_dec();
+	    }
+	}
+	break;
+    case hex:
+	val = (long)input_hex();
+	break;
+    default:
+	val = 0;
+	c = ch = eat_ws();
+	if ( c == '0' ) {		// bin, oct or hex
+	    c = ch = ts_getc();
+	    if ( tolower((uchar) c) == 'x' )
+		val = (long)input_hex();
+	    else if ( tolower((uchar) c) == 'b' )
+		val = (long)input_bin();
+	    else {			// octal
+		ts_ungetc( ch );
+		if ( c >= '0' && c <= '7' ) {
+		    val = (long)input_oct();
+		} else {
+		    val = 0;
+		}
+	    }
+	} else if ( ts_isdigit(ch) ) {
+	    ts_ungetc( ch );
+	    val = (long)input_dec();
+	} else if ( c == '-' || c == '+' ) {
+	    ulong v = input_dec();
+	    if ( c == '-' ) {
+		if ( v ) {		// ensure that LONG_MIN can be read
+		    v--;
+		    val = -((long)v) - 1;
+		} else {
+		    val = 0;
+		}
+	    } else {
+		val = (long)v;
+	    }
+	}
+    }
+    return val;
+}
+
+//
+// We use a table-driven FSM to parse floating point numbers
+// strtod() cannot be used directly since we're reading from a TQIODevice
+//
+
+double TQTextStream::input_double()
+{
+    const int Init	 = 0;			// states
+    const int Sign	 = 1;
+    const int Mantissa	 = 2;
+    const int Dot	 = 3;
+    const int Abscissa	 = 4;
+    const int ExpMark	 = 5;
+    const int ExpSign	 = 6;
+    const int Exponent	 = 7;
+    const int Done	 = 8;
+
+    const int InputSign	 = 1;			// input tokens
+    const int InputDigit = 2;
+    const int InputDot	 = 3;
+    const int InputExp	 = 4;
+
+    static const uchar table[8][5] = {
+     /* None	 InputSign   InputDigit InputDot InputExp */
+	{ 0,	    Sign,     Mantissa,	 Dot,	   0,	   }, // Init
+	{ 0,	    0,	      Mantissa,	 Dot,	   0,	   }, // Sign
+	{ Done,	    Done,     Mantissa,	 Dot,	   ExpMark,}, // Mantissa
+	{ 0,	    0,	      Abscissa,	 0,	   0,	   }, // Dot
+	{ Done,	    Done,     Abscissa,	 Done,	   ExpMark,}, // Abscissa
+	{ 0,	    ExpSign,  Exponent,	 0,	   0,	   }, // ExpMark
+	{ 0,	    0,	      Exponent,	 0,	   0,	   }, // ExpSign
+	{ Done,	    Done,     Exponent,	 Done,	   Done	   }  // Exponent
+    };
+
+    int state = Init;				// parse state
+    int input;					// input token
+
+    char buf[256];
+    int i = 0;
+    TQChar c = eat_ws();
+
+    for (;;) {
+
+	switch ( c ) {
+	    case '+':
+	    case '-':
+		input = InputSign;
+		break;
+	    case '0': case '1': case '2': case '3': case '4':
+	    case '5': case '6': case '7': case '8': case '9':
+		input = InputDigit;
+		break;
+	    case '.':
+		input = InputDot;
+		break;
+	    case 'e':
+	    case 'E':
+		input = InputExp;
+		break;
+	    default:
+		input = 0;
+		break;
+	}
+
+	state = table[state][input];
+
+	if  ( state == 0 || state == Done || i > 250 ) {
+	    if ( i > 250 ) {			// ignore rest of digits
+		do { c = ts_getc(); } while ( c != TQEOF && ts_isdigit(c) );
+	    }
+	    if ( c != TQEOF )
+		ts_ungetc( c );
+	    buf[i] = '\0';
+	    char *end;
+	    return strtod( buf, &end );
+	}
+
+	buf[i++] = c;
+	c = ts_getc();
+    }
+
+#if !defined(TQ_CC_EDG)
+    return 0.0;
+#endif
+}
+
+
+/*!
+    \overload
+
+    Reads a signed \c short integer \a i from the stream and returns a
+    reference to the stream. See flags() for an explanation of the
+    expected input format.
+*/
+
+TQTextStream &TQTextStream::operator>>( signed short &i )
+{
+    CHECK_STREAM_PRECOND
+    i = (signed short)input_int();
+    return *this;
+}
+
+
+/*!
+    \overload
+
+    Reads an unsigned \c short integer \a i from the stream and
+    returns a reference to the stream. See flags() for an explanation
+    of the expected input format.
+*/
+
+TQTextStream &TQTextStream::operator>>( unsigned short &i )
+{
+    CHECK_STREAM_PRECOND
+    i = (unsigned short)input_int();
+    return *this;
+}
+
+
+/*!
+    \overload
+
+    Reads a signed \c int \a i from the stream and returns a reference
+    to the stream. See flags() for an explanation of the expected
+    input format.
+*/
+
+TQTextStream &TQTextStream::operator>>( signed int &i )
+{
+    CHECK_STREAM_PRECOND
+    i = (signed int)input_int();
+    return *this;
+}
+
+
+/*!
+    \overload
+
+    Reads an unsigned \c int \a i from the stream and returns a
+    reference to the stream. See flags() for an explanation of the
+    expected input format.
+*/
+
+TQTextStream &TQTextStream::operator>>( unsigned int &i )
+{
+    CHECK_STREAM_PRECOND
+    i = (unsigned int)input_int();
+    return *this;
+}
+
+
+/*!
+    \overload
+
+    Reads a signed \c long int \a i from the stream and returns a
+    reference to the stream. See flags() for an explanation of the
+    expected input format.
+*/
+
+TQTextStream &TQTextStream::operator>>( signed long &i )
+{
+    CHECK_STREAM_PRECOND
+    i = (signed long)input_int();
+    return *this;
+}
+
+
+/*!
+    \overload
+
+    Reads an unsigned \c long int \a i from the stream and returns a
+    reference to the stream. See flags() for an explanation of the
+    expected input format.
+*/
+
+TQTextStream &TQTextStream::operator>>( unsigned long &i )
+{
+    CHECK_STREAM_PRECOND
+    i = (unsigned long)input_int();
+    return *this;
+}
+
+
+/*!
+    \overload
+
+    Reads a \c float \a f from the stream and returns a reference to
+    the stream. See flags() for an explanation of the expected input
+    format.
+*/
+
+TQTextStream &TQTextStream::operator>>( float &f )
+{
+    CHECK_STREAM_PRECOND
+    f = (float)input_double();
+    return *this;
+}
+
+
+/*!
+    \overload
+
+    Reads a \c double \a f from the stream and returns a reference to
+    the stream. See flags() for an explanation of the expected input
+    format.
+*/
+
+TQTextStream &TQTextStream::operator>>( double &f )
+{
+    CHECK_STREAM_PRECOND
+    f = input_double();
+    return *this;
+}
+
+
+/*!
+    \overload
+
+    Reads a "word" from the stream into \a s and returns a reference
+    to the stream.
+
+    A word consists of characters for which isspace() returns FALSE.
+*/
+
+TQTextStream &TQTextStream::operator>>( char *s )
+{
+    CHECK_STREAM_PRECOND
+    int maxlen = width( 0 );
+    TQChar c = eat_ws();
+    if ( !maxlen )
+	maxlen = -1;
+    while ( c != TQEOF ) {
+	if ( ts_isspace(c) || maxlen-- == 0 ) {
+	    ts_ungetc( c );
+	    break;
+	}
+	*s++ = c;
+	c = ts_getc();
+    }
+
+    *s = '\0';
+    return *this;
+}
+
+/*!
+    \overload
+
+    Reads a "word" from the stream into \a str and returns a reference
+    to the stream.
+
+    A word consists of characters for which isspace() returns FALSE.
+*/
+
+TQTextStream &TQTextStream::operator>>( TQString &str )
+{
+    CHECK_STREAM_PRECOND
+    str=TQString::tqfromLatin1("");
+    TQChar	c = eat_ws();
+
+    while ( c != TQEOF ) {
+	if ( ts_isspace(c) ) {
+	    ts_ungetc( c );
+	    break;
+	}
+	str += c;
+	c = ts_getc();
+    }
+    return *this;
+}
+
+/*!
+    \overload
+
+    Reads a "word" from the stream into \a str and returns a reference
+    to the stream.
+
+    A word consists of characters for which isspace() returns FALSE.
+*/
+
+TQTextStream &TQTextStream::operator>>( TQCString &str )
+{
+    CHECK_STREAM_PRECOND
+    TQCString  *dynbuf = 0;
+    const int buflen = 256;
+    char      buffer[buflen];
+    char     *s = buffer;
+    int	      i = 0;
+    TQChar	      c = eat_ws();
+
+    while ( c != TQEOF ) {
+	if ( ts_isspace(c) ) {
+	    ts_ungetc( c );
+	    break;
+	}
+	if ( i >= buflen-1 ) {
+	    if ( !dynbuf )  {			// create dynamic buffer
+		dynbuf = new TQCString(buflen*2);
+		memcpy( dynbuf->data(), s, i );	// copy old data
+	    } else if ( i >= (int)dynbuf->size()-1 ) {
+		dynbuf->resize( dynbuf->size()*2 );
+	    }
+	    s = dynbuf->data();
+	}
+	s[i++] = c;
+	c = ts_getc();
+    }
+    str.resize( i+1 );
+    memcpy( str.data(), s, i );
+    delete dynbuf;
+    return *this;
+}
+
+
+/*!
+    Reads a line from the stream and returns a string containing the
+    text.
+
+    The returned string does not contain any trailing newline or
+    carriage return. Note that this is different from
+    TQIODevice::readLine(), which does not strip the newline at the end
+    of the line.
+
+    On EOF you will get a TQString that is null. On reading an empty
+    line the returned TQString is empty but not null.
+
+    \sa TQIODevice::readLine()
+*/
+
+TQString TQTextStream::readLine()
+{
+#if defined(TQT_CHECK_STATE)
+    if ( !dev ) {
+	qWarning( "TQTextStream::readLine: No tqdevice" );
+	return TQString::null;
+    }
+#endif
+    bool readCharByChar = TRUE;
+    TQString result;
+#if 0
+    if ( !doUnicodeHeader && (
+	    (latin1) ||
+	    (mapper != 0 && mapper->mibEnum() == 106 ) // UTF 8
+       ) ) {
+	readCharByChar = FALSE;
+	// use optimized read line
+	TQChar c[getline_buf_size];
+	int pos = 0;
+	bool eof = FALSE;
+
+	for (;;) {
+	    pos = ts_getline( c );
+	    if ( pos == 0 ) {
+		// something went wrong; try fallback
+		readCharByChar = TRUE;
+		//dev->resetqStatus();
+		break;
+	    }
+	    if ( c[pos-1] == TQEOF || c[pos-1] == '\n' ) {
+		if ( pos>2 && c[pos-1]==TQEOF && c[pos-2]=='\n' ) {
+		    result += TQString( c, pos-2 );
+		} else if ( pos > 1 ) {
+		    result += TQString( c, pos-1 );
+		}
+		if ( pos == 1 && c[pos-1] == TQEOF )
+		    eof = TRUE;
+		break;
+	    } else {
+		result += TQString( c, pos );
+	    }
+	}
+	if ( eof && result.isEmpty() )
+	    return TQString::null;
+    }
+#endif
+    if ( readCharByChar ) {
+	const int buf_size = 256;
+	TQChar c[buf_size];
+	int pos = 0;
+
+	c[pos] = ts_getc();
+	if ( c[pos] == TQEOF )
+	    return TQString::null;
+
+	while ( c[pos] != TQEOF && c[pos] != '\n' ) {
+	    if ( c[pos] == '\r' ) { // ( handle mac and dos )
+		TQChar nextc = ts_getc();
+		if ( nextc != '\n' )
+		    ts_ungetc( nextc );
+		break;
+	    }
+	    pos++;
+	    if ( pos >= buf_size ) {
+		result += TQString( c, pos );
+		pos = 0;
+	    }
+	    c[pos] = ts_getc();
+	}
+	result += TQString( c, pos );
+    }
+
+    return result;
+}
+
+
+/*!
+    Reads the entire stream from the current position, and returns a string
+    containing the text.
+
+    \sa TQIODevice::readLine()
+*/
+
+TQString TQTextStream::read()
+{
+#if defined(TQT_CHECK_STATE)
+    if ( !dev ) {
+	qWarning( "TQTextStream::read: No tqdevice" );
+	return TQString::null;
+    }
+#endif
+    TQString    result;
+    const uint bufsize = 512;
+    TQChar      buf[bufsize];
+    uint       i, num, start;
+    bool       skipped_cr = FALSE;
+
+    for (;;) {
+	num = ts_getbuf(buf,bufsize);
+	// convert dos (\r\n) and mac (\r) style eol to unix style (\n)
+	start = 0;
+	for ( i=0; i<num; i++ ) {
+	    if ( buf[i] == '\r' ) {
+		// Only skip single cr's preceding lf's
+		if ( skipped_cr ) {
+		    result += buf[i];
+		    start++;
+		} else {
+		    result += TQString( &buf[start], i-start );
+		    start = i+1;
+		    skipped_cr = TRUE;
+		}
+	    } else {
+		if ( skipped_cr ) {
+		    if ( buf[i] != '\n' ) {
+			// Should not have skipped it
+			result += '\n';
+		    }
+		    skipped_cr = FALSE;
+		}
+	    }
+	}
+	if ( start < num )
+	    result += TQString( &buf[start], i-start );
+	if ( num != bufsize ) // if ( EOF )
+	    break;
+    }
+    return result;
+}
+
+
+
+/*****************************************************************************
+  TQTextStream write functions
+ *****************************************************************************/
+
+/*!
+    Writes character \c char to the stream and returns a reference to
+    the stream.
+
+    The character \a c is assumed to be Latin1 encoded independent of
+    the Encoding set for the TQTextStream.
+*/
+TQTextStream &TQTextStream::operator<<( TQChar c )
+{
+    CHECK_STREAM_PRECOND
+    ts_putc( c );
+    return *this;
+}
+
+/*!
+    \overload
+
+    Writes character \a c to the stream and returns a reference to the
+    stream.
+*/
+TQTextStream &TQTextStream::operator<<( char c )
+{
+    CHECK_STREAM_PRECOND
+    unsigned char uc = (unsigned char) c;
+    ts_putc( uc );
+    return *this;
+}
+
+TQTextStream &TQTextStream::output_int( int format, ulong n, bool neg )
+{
+    static const char hexdigits_lower[] = "0123456789abcdef";
+    static const char hexdigits_upper[] = "0123456789ABCDEF";
+    CHECK_STREAM_PRECOND
+    char buf[76];
+    register char *p;
+    int	  len;
+    const char *hexdigits;
+
+    switch ( flags() & I_BASE_MASK ) {
+
+	case I_BASE_2:				// output binary number
+	    switch ( format & I_TYPE_MASK ) {
+		case I_SHORT: len=16; break;
+		case I_INT:   len=sizeof(int)*8; break;
+		case I_LONG:  len=32; break;
+		default:      len = 0;
+	    }
+	    p = &buf[74];			// go reverse order
+	    *p = '\0';
+	    while ( len-- ) {
+		*--p = (char)(n&1) + '0';
+		n >>= 1;
+		if ( !n )
+		    break;
+	    }
+	    if ( flags() & showbase ) {		// show base
+		*--p = (flags() & uppercase) ? 'B' : 'b';
+		*--p = '0';
+	    }
+	    break;
+
+	case I_BASE_8:				// output octal number
+	    p = &buf[74];
+	    *p = '\0';
+	    do {
+		*--p = (char)(n&7) + '0';
+		n >>= 3;
+	    } while ( n );
+	    if ( flags() & showbase )
+		*--p = '0';
+	    break;
+
+	case I_BASE_16:				// output hexadecimal number
+	    p = &buf[74];
+	    *p = '\0';
+	    hexdigits = (flags() & uppercase) ?
+		hexdigits_upper : hexdigits_lower;
+	    do {
+		*--p = hexdigits[(int)n&0xf];
+		n >>= 4;
+	    } while ( n );
+	    if ( flags() & showbase ) {
+		*--p = (flags() & uppercase) ? 'X' : 'x';
+		*--p = '0';
+	    }
+	    break;
+
+	default:				// decimal base is default
+	    p = &buf[74];
+	    *p = '\0';
+	    if ( neg )
+		n = (ulong)(-(long)n);
+	    do {
+		*--p = ((int)(n%10)) + '0';
+		n /= 10;
+	    } while ( n );
+	    if ( neg )
+		*--p = '-';
+	    else if ( flags() & showpos )
+		*--p = '+';
+	    if ( (flags() & internal) && fwidth && !ts_isdigit(*p) ) {
+		ts_putc( *p );			// special case for internal
+		++p;				//   padding
+		fwidth--;
+		return *this << (const char*)p;
+	    }
+    }
+    if ( fwidth ) {				// adjustment required
+	if ( !(flags() & left) ) {		// but NOT left adjustment
+	    len = tqstrlen(p);
+	    int padlen = fwidth - len;
+	    if ( padlen <= 0 ) {		// no padding required
+		writeBlock( p, len );
+	    } else if ( padlen < (int)(p-buf) ) { // speeds up padding
+		memset( p-padlen, (char)fillchar, padlen );
+		writeBlock( p-padlen, padlen+len );
+	    }
+	    else				// standard padding
+		*this << (const char*)p;
+	}
+	else
+	    *this << (const char*)p;
+	fwidth = 0;				// reset field width
+    }
+    else
+	writeBlock( p, tqstrlen(p) );
+    return *this;
+}
+
+
+/*!
+    \overload
+
+    Writes a \c short integer \a i to the stream and returns a
+    reference to the stream.
+*/
+
+TQTextStream &TQTextStream::operator<<( signed short i )
+{
+    return output_int( I_SHORT | I_SIGNED, i, i < 0 );
+}
+
+
+/*!
+    \overload
+
+    Writes an \c unsigned \c short integer \a i to the stream and
+    returns a reference to the stream.
+*/
+
+TQTextStream &TQTextStream::operator<<( unsigned short i )
+{
+    return output_int( I_SHORT | I_UNSIGNED, i, FALSE );
+}
+
+
+/*!
+    \overload
+
+    Writes an \c int \a i to the stream and returns a reference to the
+    stream.
+*/
+
+TQTextStream &TQTextStream::operator<<( signed int i )
+{
+    return output_int( I_INT | I_SIGNED, i, i < 0 );
+}
+
+
+/*!
+    \overload
+
+    Writes an \c unsigned \c int \a i to the stream and returns a
+    reference to the stream.
+*/
+
+TQTextStream &TQTextStream::operator<<( unsigned int i )
+{
+    return output_int( I_INT | I_UNSIGNED, i, FALSE );
+}
+
+
+/*!
+    \overload
+
+    Writes a \c long \c int \a i to the stream and returns a reference
+    to the stream.
+*/
+
+TQTextStream &TQTextStream::operator<<( signed long i )
+{
+    return output_int( I_LONG | I_SIGNED, i, i < 0 );
+}
+
+
+/*!
+    \overload
+
+    Writes an \c unsigned \c long \c int \a i to the stream and
+    returns a reference to the stream.
+*/
+
+TQTextStream &TQTextStream::operator<<( unsigned long i )
+{
+    return output_int( I_LONG | I_UNSIGNED, i, FALSE );
+}
+
+
+/*!
+    \overload
+
+    Writes a \c float \a f to the stream and returns a reference to
+    the stream.
+*/
+
+TQTextStream &TQTextStream::operator<<( float f )
+{
+    return *this << (double)f;
+}
+
+/*!
+    \overload
+
+    Writes a \c double \a f to the stream and returns a reference to
+    the stream.
+*/
+
+TQTextStream &TQTextStream::operator<<( double f )
+{
+    CHECK_STREAM_PRECOND
+    char f_char;
+    char format[16];
+    if ( (flags()&floatfield) == fixed )
+	f_char = 'f';
+    else if ( (flags()&floatfield) == scientific )
+	f_char = (flags() & uppercase) ? 'E' : 'e';
+    else
+	f_char = (flags() & uppercase) ? 'G' : 'g';
+    register char *fs = format;			// generate format string
+    *fs++ = '%';				//   "%.<prec>l<f_char>"
+    *fs++ = '.';
+    int prec = precision();
+    if ( prec > 99 )
+	prec = 99;
+    if ( prec >= 10 ) {
+	*fs++ = prec / 10 + '0';
+	*fs++ = prec % 10 + '0';
+    } else {
+	*fs++ = prec + '0';
+    }
+    *fs++ = 'l';
+    *fs++ = f_char;
+    *fs = '\0';
+    TQString num;
+    num.sprintf(format, f);			// convert to text
+    if ( fwidth )				// padding
+	*this << num.latin1();
+    else					// just write it
+	writeBlock(num.latin1(), num.length());
+    return *this;
+}
+
+
+/*!
+    \overload
+
+    Writes a string to the stream and returns a reference to the
+    stream.
+
+    The string \a s is assumed to be Latin1 encoded independent of the
+    Encoding set for the TQTextStream.
+*/
+
+TQTextStream &TQTextStream::operator<<( const char* s )
+{
+    CHECK_STREAM_PRECOND
+    char padbuf[48];
+    uint len = tqstrlen( s );			// don't write null terminator
+    if ( fwidth ) {				// field width set
+	int padlen = fwidth - len;
+	fwidth = 0;				// reset width
+	if ( padlen > 0 ) {
+	    char *ppad;
+	    if ( padlen > 46 ) {		// create extra big fill buffer
+		ppad = new char[padlen];
+		TQ_CHECK_PTR( ppad );
+	    } else {
+		ppad = padbuf;
+	    }
+	    memset( ppad, (char)fillchar, padlen );	// fill with fillchar
+	    if ( !(flags() & left) ) {
+		writeBlock( ppad, padlen );
+		padlen = 0;
+	    }
+	    writeBlock( s, len );
+	    if ( padlen )
+		writeBlock( ppad, padlen );
+	    if ( ppad != padbuf )		// delete extra big fill buf
+		delete[] ppad;
+	    return *this;
+	}
+    }
+    writeBlock( s, len );
+    return *this;
+}
+
+/*!
+    \overload
+
+    Writes \a s to the stream and returns a reference to the stream.
+
+    The string \a s is assumed to be Latin1 encoded independent of the
+    Encoding set for the TQTextStream.
+*/
+
+TQTextStream &TQTextStream::operator<<( const TQCString & s )
+{
+    return operator<<(s.data());
+}
+
+/*!
+    \overload
+
+    Writes \a s to the stream and returns a reference to the stream.
+*/
+
+TQTextStream &TQTextStream::operator<<( const TQString& s )
+{
+    if ( !mapper && latin1 )
+	return operator<<(s.latin1());
+    CHECK_STREAM_PRECOND
+    TQString s1 = s;
+    if ( fwidth ) {				// field width set
+	if ( !(flags() & left) ) {
+	    s1 = s.rightJustify(fwidth, (char)fillchar);
+	} else {
+	    s1 = s.leftJustify(fwidth, (char)fillchar);
+	}
+	fwidth = 0;				// reset width
+    }
+    writeBlock( s1.tqunicode(), s1.length() );
+    return *this;
+}
+
+
+/*!
+    \overload
+
+    Writes a pointer to the stream and returns a reference to the
+    stream.
+
+    The \a ptr is output as an unsigned long hexadecimal integer.
+*/
+
+TQTextStream &TQTextStream::operator<<( void *ptr )
+{
+    int f = flags();
+    setf( hex, basefield );
+    setf( showbase );
+    unsetf( uppercase );
+    output_int( I_LONG | I_UNSIGNED, (ulong)ptr, FALSE );
+    flags( f );
+    return *this;
+}
+
+
+/*!
+    \fn int TQTextStream::flags() const
+
+    Returns the current stream flags. The default value is 0.
+
+    \table
+    \header \i Flag \i Meaning
+    \row \i \c skipws \i Not currently used; whitespace always skipped
+    \row \i \c left \i Numeric fields are left-aligned
+    \row \i \c right
+	 \i Not currently used (by default, numerics are right-aligned)
+    \row \i \c internal \i Puts any padding spaces between +/- and value
+    \row \i \c bin \i Output \e and input only in binary
+    \row \i \c oct \i Output \e and input only in octal
+    \row \i \c dec \i Output \e and input only in decimal
+    \row \i \c hex \i Output \e and input only in hexadecimal
+    \row \i \c showbase
+	 \i Annotates numeric outputs with 0b, 0, or 0x if in \c bin,
+	 \c oct, or \c hex format
+    \row \i \c showpoint \i Not currently used
+    \row \i \c uppercase \i Uses 0B and 0X rather than 0b and 0x
+    \row \i \c showpos \i Shows + for positive numeric values
+    \row \i \c scientific \i Uses scientific notation for floating point values
+    \row \i \c fixed \i Uses fixed-point notation for floating point values
+    \endtable
+
+    Note that unless \c bin, \c oct, \c dec, or \c hex is set, the
+    input base is octal if the value starts with 0, hexadecimal if it
+    starts with 0x, binary if it starts with 0b, and decimal
+    otherwise.
+
+    \sa setf(), unsetf()
+*/
+
+/*!
+    \fn int TQTextStream::flags( int f )
+
+    \overload
+
+    Sets the stream flags to \a f. Returns the previous stream flags.
+
+    \sa setf(), unsetf(), flags()
+*/
+
+/*!
+    \fn int TQTextStream::setf( int bits )
+
+    Sets the stream flag bits \a bits. Returns the previous stream
+    flags.
+
+    Equivalent to \c{flags( flags() | bits )}.
+
+    \sa setf(), unsetf()
+*/
+
+/*!
+    \fn int TQTextStream::setf( int bits, int tqmask )
+
+    \overload
+
+    Sets the stream flag bits \a bits with a bit tqmask \a tqmask. Returns
+    the previous stream flags.
+
+    Equivalent to \c{flags( (flags() & ~tqmask) | (bits & tqmask) )}.
+
+    \sa setf(), unsetf()
+*/
+
+/*!
+    \fn int TQTextStream::unsetf( int bits )
+
+    Clears the stream flag bits \a bits. Returns the previous stream
+    flags.
+
+    Equivalent to \c{flags( flags() & ~tqmask )}.
+
+    \sa setf()
+*/
+
+/*!
+    \fn int TQTextStream::width() const
+
+    Returns the field width. The default value is 0.
+*/
+
+/*!
+    \fn int TQTextStream::width( int w )
+
+    \overload
+
+    Sets the field width to \a w. Returns the previous field width.
+*/
+
+/*!
+    \fn int TQTextStream::fill() const
+
+    Returns the fill character. The default value is ' ' (space).
+*/
+
+/*!
+    \overload int TQTextStream::fill( int f )
+
+    Sets the fill character to \a f. Returns the previous fill character.
+*/
+
+/*!
+    \fn int TQTextStream::precision() const
+
+    Returns the precision. The default value is 6.
+*/
+
+/*!
+    \fn int TQTextStream::precision( int p )
+
+    \overload
+
+    Sets the precision to \a p. Returns the previous precision setting.
+*/
+
+
+ /*****************************************************************************
+  TQTextStream manipulators
+ *****************************************************************************/
+
+TQTextStream &bin( TQTextStream &s )
+{
+    s.setf(TQTS::bin,TQTS::basefield);
+    return s;
+}
+
+TQTextStream &oct( TQTextStream &s )
+{
+    s.setf(TQTS::oct,TQTS::basefield);
+    return s;
+}
+
+TQTextStream &dec( TQTextStream &s )
+{
+    s.setf(TQTS::dec,TQTS::basefield);
+    return s;
+}
+
+TQTextStream &hex( TQTextStream &s )
+{
+    s.setf(TQTS::hex,TQTS::basefield);
+    return s;
+}
+
+TQTextStream &endl( TQTextStream &s )
+{
+    return s << '\n';
+}
+
+TQTextStream &flush( TQTextStream &s )
+{
+    if ( s.tqdevice() )
+	s.tqdevice()->flush();
+    return s;
+}
+
+TQTextStream &ws( TQTextStream &s )
+{
+    s.skipWhiteSpace();
+    return s;
+}
+
+TQTextStream &reset( TQTextStream &s )
+{
+    s.reset();
+    return s;
+}
+
+
+/*!
+    \class TQTextIStream tqtextstream.h
+    \reentrant
+    \brief The TQTextIStream class is a convenience class for input streams.
+
+    \ingroup io
+    \ingroup text
+
+    This class provides a shorthand for creating simple input
+    \l{TQTextStream}s without having to pass a \e mode argument to the
+    constructor.
+
+    This class makes it easy, for example, to write things like this:
+    \code
+    TQString data = "123 456";
+    int a, b;
+    TQTextIStream(&data) >> a >> b;
+    \endcode
+
+    \sa TQTextOStream
+*/
+
+/*!
+    \fn TQTextIStream::TQTextIStream( const TQString *s )
+
+    Constructs a stream to read from the string \a s.
+*/
+/*!
+    \fn TQTextIStream::TQTextIStream( TQByteArray ba )
+
+    Constructs a stream to read from the array \a ba.
+*/
+/*!
+    \fn TQTextIStream::TQTextIStream( FILE *f )
+
+    Constructs a stream to read from the file \a f.
+*/
+
+
+/*!
+    \class TQTextOStream
+    \reentrant
+    \brief The TQTextOStream class is a convenience class for output streams.
+
+    \ingroup io
+    \ingroup text
+
+    This class provides a shorthand for creating simple output
+    \l{TQTextStream}s without having to pass a \e mode argument to the
+    constructor.
+
+    This makes it easy for example, to write things like this:
+    \code
+    TQString result;
+    TQTextOStream(&result) << "pi = " << 3.14;
+    \endcode
+*/
+
+/*!
+    \fn TQTextOStream::TQTextOStream( TQString *s )
+
+    Constructs a stream to write to string \a s.
+*/
+/*!
+    \fn TQTextOStream::TQTextOStream( TQByteArray ba )
+
+    Constructs a stream to write to the array \a ba.
+*/
+/*!
+    \fn TQTextOStream::TQTextOStream( FILE *f )
+
+    Constructs a stream to write to the file \a f.
+*/
+
+
+
+/*!
+  Sets the encoding of this stream to \a e, where \a e is one of the
+  following values:
+  \table
+  \header \i Encoding \i Meaning
+  \row \i Locale
+       \i Uses local file format (Latin1 if locale is not set), but
+       autodetecting Unicode(utf16) on input.
+  \row \i Unicode
+       \i Uses Unicode(utf16) for input and output. Output will be
+       written in the order most efficient for the current platform
+       (i.e. the order used internally in TQString).
+  \row \i UnicodeUTF8
+       \i Using Unicode(utf8) for input and output. If you use it for
+       input it will autodetect utf16 and use it instead of utf8.
+  \row \i Latin1
+       \i ISO-8859-1. Will not autodetect utf16.
+  \row \i UnicodeNetworkOrder
+       \i Uses network order Unicode(utf16) for input and output.
+       Useful when reading Unicode data that does not start with the
+       byte order marker.
+  \row \i UnicodeReverse
+       \i Uses reverse network order Unicode(utf16) for input and
+       output. Useful when reading Unicode data that does not start
+       with the byte order marker or when writing data that should be
+       read by buggy Windows applications.
+  \row \i RawUnicode
+       \i Like Unicode, but does not write the byte order marker nor
+       does it auto-detect the byte order. Useful only when writing to
+       non-persistent storage used by a single process.
+  \endtable
+
+  \c Locale and all Unicode encodings, except \c RawUnicode, will look
+  at the first two bytes in an input stream to determine the byte
+  order. The initial byte order marker will be stripped off before
+  data is read.
+
+  Note that this function should be called before any data is read to
+  or written from the stream.
+
+  \sa setCodec()
+*/
+
+void TQTextStream::setEncoding( Encoding e )
+{
+    if ( d->sourceType == TQTextStreamPrivate::String )
+	return;
+
+    switch ( e ) {
+    case Unicode:
+	mapper = 0;
+	latin1 = FALSE;
+	doUnicodeHeader = TRUE;
+	internalOrder = TRUE;
+	networkOrder = TQChar::networkOrdered();
+	break;
+    case UnicodeUTF8:
+#ifndef TQT_NO_TEXTCODEC
+	mapper = TQTextCodec::codecForMib( 106 );
+	latin1 = FALSE;
+	doUnicodeHeader = TRUE;
+	internalOrder = TRUE;
+	networkOrder = TQChar::networkOrdered();
+#else
+	mapper = 0;
+	latin1 = TRUE;
+	doUnicodeHeader = TRUE;
+#endif
+	break;
+    case UnicodeNetworkOrder:
+	mapper = 0;
+	latin1 = FALSE;
+	doUnicodeHeader = TRUE;
+	internalOrder = TQChar::networkOrdered();
+	networkOrder = TRUE;
+	break;
+    case UnicodeReverse:
+	mapper = 0;
+	latin1 = FALSE;
+	doUnicodeHeader = TRUE;
+	internalOrder = !TQChar::networkOrdered();
+	networkOrder = FALSE;
+	break;
+    case RawUnicode:
+	mapper = 0;
+	latin1 = FALSE;
+	doUnicodeHeader = FALSE;
+	internalOrder = TRUE;
+	networkOrder = TQChar::networkOrdered();
+	break;
+    case Locale:
+	latin1 = TRUE; // fallback to Latin-1
+#ifndef TQT_NO_TEXTCODEC
+	mapper = TQTextCodec::codecForLocale();
+	// optimized Latin-1 processing
+#if defined(TQ_OS_WIN32)
+	if ( GetACP() == 1252 )
+	    mapper = 0;
+#endif
+	if ( mapper && mapper->mibEnum() == 4 )
+#endif
+	    mapper = 0;
+
+	doUnicodeHeader = TRUE; // If it reads as Unicode, accept it
+	break;
+    case Latin1:
+	mapper = 0;
+	doUnicodeHeader = FALSE;
+	latin1 = TRUE;
+	break;
+    }
+}
+
+
+#ifndef TQT_NO_TEXTCODEC
+/*!
+    Sets the codec for this stream to \a codec. Will not try to
+    autodetect Unicode.
+
+    Note that this function should be called before any data is read
+    to/written from the stream.
+
+    \sa setEncoding(), codec()
+*/
+
+void TQTextStream::setCodec( TQTextCodec *codec )
+{
+    if ( d->sourceType == TQTextStreamPrivate::String )
+	return; // TQString does not need any codec
+    mapper = codec;
+    latin1 = ( codec->mibEnum() == 4 );
+    if ( latin1 )
+	mapper = 0;
+    doUnicodeHeader = FALSE;
+}
+
+/*!
+  Returns the codec actually used for this stream.
+
+  If Unicode is automatically detected in input, a codec with \link
+  TQTextCodec::name() name() \endlink "ISO-10646-UCS-2" is returned.
+
+  \sa setCodec()
+*/
+
+TQTextCodec *TQTextStream::codec()
+{
+    if ( mapper ) {
+	return mapper;
+    } else {
+	// 4 is "ISO 8859-1", 1000 is "ISO-10646-UCS-2"
+	return TQTextCodec::codecForMib( latin1 ? 4 : 1000 );
+    }
+}
+
+#endif
+
+#endif // TQT_NO_TEXTSTREAM
diff --git a/tqtinterface/qt4/src/tools/tqtextstream.h b/tqtinterface/qt4/src/tools/tqtextstream.h
new file mode 100644
index 0000000..53aaddb
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqtextstream.h
@@ -0,0 +1,343 @@
+/****************************************************************************
+**
+** Definition of TQTextStream class
+**
+** Created : 940922
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQTEXTSTREAM_H
+#define TQTEXTSTREAM_H
+
+#ifndef TQT_H
+#include "tqiodevice.h"
+#include "tqfile.h"
+#include "tqstring.h"
+#include <stdio.h>
+#endif // TQT_H
+
+#ifndef TQT_NO_TEXTSTREAM
+class TQTextCodec;
+class TQTextDecoder;
+
+class TQTextStreamPrivate;
+
+class TQ_EXPORT TQTextStream				// text stream class
+{
+public:
+    enum Encoding { Locale, Latin1, Unicode, UnicodeNetworkOrder,
+		    UnicodeReverse, RawUnicode, UnicodeUTF8 };
+
+    void	setEncoding( Encoding );
+#ifndef TQT_NO_TEXTCODEC
+    void	setCodec( TQTextCodec* );
+    TQTextCodec *codec();
+#endif
+
+    TQTextStream();
+    TQTextStream( QIODevice * );
+    TQTextStream( QFile *tqf );
+    TQTextStream( TQString*, int mode );
+    TQTextStream( TQString&, int mode );		// obsolete
+    TQTextStream( TQByteArray, int mode );
+    TQTextStream( FILE *, int mode );
+    virtual ~TQTextStream();
+
+    TQIODevice	*tqdevice() const;
+    void	 setDevice( TQIODevice * );
+    void	 unsetDevice();
+
+    bool	 atEnd() const;
+    bool	 eof() const;
+
+    TQTextStream &operator>>( TQChar & );
+    TQTextStream &operator>>( char & );
+    TQTextStream &operator>>( signed short & );
+    TQTextStream &operator>>( unsigned short & );
+    TQTextStream &operator>>( signed int & );
+    TQTextStream &operator>>( unsigned int & );
+    TQTextStream &operator>>( signed long & );
+    TQTextStream &operator>>( unsigned long & );
+    TQTextStream &operator>>( float & );
+    TQTextStream &operator>>( double & );
+    TQTextStream &operator>>( char * );
+    TQTextStream &operator>>( TQString & );
+    TQTextStream &operator>>( TQCString & );
+
+    TQTextStream &operator<<( TQChar );
+    TQTextStream &operator<<( char );
+    TQTextStream &operator<<( signed short );
+    TQTextStream &operator<<( unsigned short );
+    TQTextStream &operator<<( signed int );
+    TQTextStream &operator<<( unsigned int );
+    TQTextStream &operator<<( signed long );
+    TQTextStream &operator<<( unsigned long );
+    TQTextStream &operator<<( float );
+    TQTextStream &operator<<( double );
+    TQTextStream &operator<<( const char* );
+    TQTextStream &operator<<( const TQString & );
+    TQTextStream &operator<<( const TQCString & );
+    TQTextStream &operator<<( void * );		// any pointer
+
+    TQTextStream &readRawBytes( char *, uint len );
+    TQTextStream &writeRawBytes( const char* , uint len );
+
+    TQString	readLine();
+    TQString	read();
+    void	skipWhiteSpace();
+
+    enum {
+	skipws	  = 0x0001,			// skip whitespace on input
+	left	  = 0x0002,			// left-adjust output
+	right	  = 0x0004,			// right-adjust output
+	internal  = 0x0008,			// pad after sign
+	bin	  = 0x0010,			// binary format integer
+	oct	  = 0x0020,			// octal format integer
+	dec	  = 0x0040,			// decimal format integer
+	hex	  = 0x0080,			// hex format integer
+	showbase  = 0x0100,			// show base indicator
+	showpoint = 0x0200,			// force decimal point (float)
+	uppercase = 0x0400,			// upper-case hex output
+	showpos	  = 0x0800,			// add '+' to positive integers
+	scientific= 0x1000,			// scientific float output
+	fixed	  = 0x2000			// fixed float output
+    };
+
+    static const int basefield;			// bin | oct | dec | hex
+    static const int adjustfield;		// left | right | internal
+    static const int floatfield;		// scientific | fixed
+
+    int	  flags() const;
+    int	  flags( int f );
+    int	  setf( int bits );
+    int	  setf( int bits, int tqmask );
+    int	  unsetf( int bits );
+
+    void  reset();
+
+    int	  width()	const;
+    int	  width( int );
+    int	  fill()	const;
+    int	  fill( int );
+    int	  precision()	const;
+    int	  precision( int );
+
+private:
+    long	input_int();
+    void	init();
+    TQTextStream &output_int( int, ulong, bool );
+    TQIODevice	*dev;
+
+    int		fflags;
+    int		fwidth;
+    int		fillchar;
+    int		fprec;
+    bool	doUnicodeHeader;
+    bool	owndev;
+    TQTextCodec 	*mapper;
+    TQTextStreamPrivate * d;
+    TQChar	unused1; // ### remove in TQt 4.0
+    bool	latin1;
+    bool 	internalOrder;
+    bool	networkOrder;
+    void	*unused2; // ### remove in TQt 4.0
+
+    TQChar	eat_ws();
+    uint 	ts_getline( TQChar* );
+    void	ts_ungetc( TQChar );
+    TQChar	ts_getc();
+    uint	ts_getbuf( TQChar*, uint );
+    void	ts_putc(int);
+    void	ts_putc(TQChar);
+    bool	ts_isspace(TQChar);
+    bool	ts_isdigit(TQChar);
+    ulong	input_bin();
+    ulong	input_oct();
+    ulong	input_dec();
+    ulong	input_hex();
+    double	input_double();
+    TQTextStream &writeBlock( const char* p, uint len );
+    TQTextStream &writeBlock( const TQChar* p, uint len );
+
+    int		dev_getch();
+    int		dev_ungetch(int ch);
+
+private:	// Disabled copy constructor and operator=
+#if defined(TQ_DISABLE_COPY)
+    TQTextStream( const TQTextStream & );
+    TQTextStream &operator=( const TQTextStream & );
+#endif
+};
+
+typedef TQTextStream TQTS;
+
+class TQ_EXPORT TQTextIStream : public TQTextStream {
+public:
+    TQTextIStream( const TQString* s ) :
+	TQTextStream((TQString*)s,IO_ReadOnly) { }
+    TQTextIStream( TQByteArray ba ) :
+	TQTextStream(ba,IO_ReadOnly) { }
+    TQTextIStream( FILE *f ) :
+	TQTextStream(f,IO_ReadOnly) { }
+
+private:	// Disabled copy constructor and operator=
+#if defined(TQ_DISABLE_COPY)
+    TQTextIStream( const TQTextIStream & );
+    TQTextIStream &operator=( const TQTextIStream & );
+#endif
+};
+
+class TQ_EXPORT TQTextOStream : public TQTextStream {
+public:
+    TQTextOStream( TQString* s ) :
+	TQTextStream(s,IO_WriteOnly) { }
+    TQTextOStream( TQByteArray ba ) :
+	TQTextStream(ba,IO_WriteOnly) { }
+    TQTextOStream( FILE *f ) :
+	TQTextStream(f,IO_WriteOnly) { }
+
+private:	// Disabled copy constructor and operator=
+#if defined(TQ_DISABLE_COPY)
+    TQTextOStream( const TQTextOStream & );
+    TQTextOStream &operator=( const TQTextOStream & );
+#endif
+};
+
+/*****************************************************************************
+  TQTextStream inline functions
+ *****************************************************************************/
+
+inline TQIODevice *TQTextStream::tqdevice() const
+{ return dev; }
+
+inline bool TQTextStream::atEnd() const
+{ return dev ? dev->atEnd() : FALSE; }
+
+inline bool TQTextStream::eof() const
+{ return atEnd(); }
+
+inline int TQTextStream::flags() const
+{ return fflags; }
+
+inline int TQTextStream::flags( int f )
+{ int oldf = fflags;  fflags = f;  return oldf; }
+
+inline int TQTextStream::setf( int bits )
+{ int oldf = fflags;  fflags |= bits;  return oldf; }
+
+inline int TQTextStream::setf( int bits, int tqmask )
+{ int oldf = fflags;  fflags = (fflags & ~tqmask) | (bits & tqmask); return oldf; }
+
+inline int TQTextStream::unsetf( int bits )
+{ int oldf = fflags;  fflags &= ~bits;	return oldf; }
+
+inline int TQTextStream::width() const
+{ return fwidth; }
+
+inline int TQTextStream::width( int w )
+{ int oldw = fwidth;  fwidth = w;  return oldw;	 }
+
+inline int TQTextStream::fill() const
+{ return fillchar; }
+
+inline int TQTextStream::fill( int f )
+{ int oldc = fillchar;	fillchar = f;  return oldc;  }
+
+inline int TQTextStream::precision() const
+{ return fprec; }
+
+inline int TQTextStream::precision( int p )
+{ int oldp = fprec;  fprec = p;	 return oldp;  }
+
+/*!
+  Returns one character from the stream, or EOF.
+*/
+inline TQChar TQTextStream::ts_getc()
+{ TQChar r; return ( ts_getbuf( &r,1 ) == 1 ? r : TQChar((ushort)0xffff) ); }
+
+/*****************************************************************************
+  TQTextStream manipulators
+ *****************************************************************************/
+
+typedef TQTextStream & (*TQTSFUNC)(TQTextStream &);// manipulator function
+typedef int (TQTextStream::*TQTSMFI)(int);	// manipulator w/int argument
+
+class TQ_EXPORT TQTSManip {			// text stream manipulator
+public:
+    TQTSManip( TQTSMFI m, int a ) { mf=m; arg=a; }
+    void exec( TQTextStream &s ) { (s.*mf)(arg); }
+private:
+    TQTSMFI mf;					// TQTextStream member function
+    int	   arg;					// member function argument
+};
+
+TQ_EXPORT inline TQTextStream &operator>>( TQTextStream &s, TQTSFUNC f )
+{ return (*f)( s ); }
+
+TQ_EXPORT inline TQTextStream &operator<<( TQTextStream &s, TQTSFUNC f )
+{ return (*f)( s ); }
+
+TQ_EXPORT inline TQTextStream &operator<<( TQTextStream &s, TQTSManip m )
+{ m.exec(s); return s; }
+
+TQ_EXPORT TQTextStream &bin( TQTextStream &s );	// set bin notation
+TQ_EXPORT TQTextStream &oct( TQTextStream &s );	// set oct notation
+TQ_EXPORT TQTextStream &dec( TQTextStream &s );	// set dec notation
+TQ_EXPORT TQTextStream &hex( TQTextStream &s );	// set hex notation
+TQ_EXPORT TQTextStream &endl( TQTextStream &s );	// insert EOL ('\n')
+TQ_EXPORT TQTextStream &flush( TQTextStream &s );	// flush output
+TQ_EXPORT TQTextStream &ws( TQTextStream &s );	// eat whitespace on input
+TQ_EXPORT TQTextStream &reset( TQTextStream &s );	// set default flags
+
+TQ_EXPORT inline TQTSManip qSetW( int w )
+{
+    TQTSMFI func = &TQTextStream::width;
+    return TQTSManip(func,w);
+}
+
+TQ_EXPORT inline TQTSManip qSetFill( int f )
+{
+    TQTSMFI func = &TQTextStream::fill;
+    return TQTSManip(func,f);
+}
+
+TQ_EXPORT inline TQTSManip qSetPrecision( int p )
+{
+    TQTSMFI func = &TQTextStream::precision;
+    return TQTSManip(func,p);
+}
+
+#endif // TQT_NO_TEXTSTREAM
+#endif // TQTEXTSTREAM_H
diff --git a/tqtinterface/qt4/src/tools/tqthreadinstance_p.h b/tqtinterface/qt4/src/tools/tqthreadinstance_p.h
new file mode 100644
index 0000000..5405472
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqthreadinstance_p.h
@@ -0,0 +1,101 @@
+/****************************************************************************
+**
+** ...
+**
+** Copyright (C) 2005-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQTHREAD_P_H
+#define TQTHREAD_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the TQt API.  It exists for the convenience
+// of TQThread and TQThreadStorage. This header file may change from
+// version to version without notice, or even be removed.
+//
+// We mean it.
+//
+//
+
+#ifdef TQT_THREAD_SUPPORT
+
+#ifndef TQT_H
+#include "tqmutex.h"
+#include "tqwindowdefs.h"
+#endif // TQT_H
+
+#ifdef TQ_OS_UNIX
+#include <pthread.h>
+#endif
+
+class TQThreadInstance {
+public:
+    static TQThreadInstance *current();
+
+    void init(unsigned int stackSize);
+    void deinit();
+
+    TQMutex *mutex() const;
+    void terminate();
+
+    unsigned int stacksize;
+    void *args[2];
+    void **thread_storage;
+    bool finished : 1;
+    bool running  : 1;
+    bool orphan   : 1;
+
+#ifdef TQ_OS_UNIX
+    pthread_cond_t thread_done;
+    pthread_t thread_id;
+
+    static void *start( void * );
+    static void finish( void * );
+#endif // TQ_OS_UNIX
+
+#ifdef TQ_OS_WIN32
+    TQt::HANDLE handle;
+    unsigned int thread_id;
+    int waiters;
+
+    static unsigned int __stdcall start( void * );
+    static void finish( TQThreadInstance * );
+#endif // TQ_OS_WIN32
+};
+
+#endif // TQT_THREAD_SUPPORT
+#endif // TQTHREAD_P_H
diff --git a/tqtinterface/qt4/src/tools/tqthreadstorage.h b/tqtinterface/qt4/src/tools/tqthreadstorage.h
new file mode 100644
index 0000000..a8ccec1
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqthreadstorage.h
@@ -0,0 +1,95 @@
+/****************************************************************************
+**
+** ...
+**
+** Copyright (C) 2005-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQTHREADSTORAGE_H
+#define TQTHREADSTORAGE_H
+
+#ifdef TQT_THREAD_SUPPORT
+
+#ifndef TQT_H
+#include "tqglobal.h"
+#endif // TQT_H
+
+class TQ_EXPORT TQThreadStorageData
+{
+public:
+    TQThreadStorageData( void (*func)(void *) );
+    ~TQThreadStorageData();
+
+    void** get() const;
+    void** set( void* p );
+
+    static void finish( void** );
+    int id;
+};
+
+
+template <class T>
+class TQThreadStorage
+{
+private:
+    TQThreadStorageData d;
+
+#if defined(TQ_DISABLE_COPY)
+    // disable copy constructor and operator=
+    TQThreadStorage( const TQThreadStorage & );
+    TQThreadStorage &operator=( const TQThreadStorage & );
+#endif // TQ_DISABLE_COPY
+
+    static void deleteData( void *x ) { delete (T)x; }
+
+public:
+    inline TQThreadStorage() : d( deleteData ) {  }
+    inline ~TQThreadStorage() { }
+
+    inline bool hasLocalData() const
+    { return d.get() != 0; }
+
+    inline T& localData()
+    { void **v = d.get(); if ( !v ) v = d.set( 0 ); return *(T*)v; }
+
+    inline T localData() const
+    { void **v = d.get(); return ( v ? *(T*)v : 0 ); }
+
+    inline void setLocalData( T t )
+    { (void) d.set( t ); }
+};
+
+#endif // TQT_THREAD_SUPPORT
+
+#endif // TQTHREADSTORAGE_H
diff --git a/tqtinterface/qt4/src/tools/tqthreadstorage_unix.cpp b/tqtinterface/qt4/src/tools/tqthreadstorage_unix.cpp
new file mode 100644
index 0000000..4f17c39
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqthreadstorage_unix.cpp
@@ -0,0 +1,349 @@
+/****************************************************************************
+**
+** ...
+**
+** Copyright (C) 2005-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifdef TQT_THREAD_SUPPORT
+
+#include "tqplatformdefs.h"
+
+#include "tqthreadstorage.h"
+#include <private/tqthreadinstance_p.h>
+
+#include <string.h>
+
+// #define TQTHREADSTORAGE_DEBUG
+
+
+// keep this in sync with the implementation in qthreadstorage.cpp
+static const int MAX_THREAD_STORAGE = 257; // 256 maximum + 1 used in TQRegExp
+
+static pthread_mutex_t thread_storage_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+static bool thread_storage_init = FALSE;
+static struct {
+    bool used;
+    void (*func)( void * );
+} thread_storage_usage[MAX_THREAD_STORAGE];
+
+
+TQThreadStorageData::TQThreadStorageData( void (*func)( void * ) )
+    : id( 0 )
+{
+    pthread_mutex_lock( &thread_storage_mutex );
+
+    // make sure things are initialized
+    if ( ! thread_storage_init )
+	memset( thread_storage_usage, 0, sizeof( thread_storage_usage ) );
+    thread_storage_init = TRUE;
+
+    for ( ; id < MAX_THREAD_STORAGE; ++id ) {
+	if ( !thread_storage_usage[id].used )
+	    break;
+    }
+
+    TQ_ASSERT( id >= 0 && id < MAX_THREAD_STORAGE );
+    thread_storage_usage[id].used = TRUE;
+    thread_storage_usage[id].func = func;
+
+#ifdef TQTHREADSTORAGE_DEBUG
+    qDebug( "TQThreadStorageData: allocated id %d", id );
+#endif // TQTHREADSTORAGE_DEBUG
+
+    pthread_mutex_unlock( &thread_storage_mutex );
+}
+
+TQThreadStorageData::~TQThreadStorageData()
+{
+    pthread_mutex_lock( &thread_storage_mutex );
+    thread_storage_usage[id].used = FALSE;
+    thread_storage_usage[id].func = 0;
+
+#ifdef TQTHREADSTORAGE_DEBUG
+    qDebug( "TQThreadStorageData: released id %d", id );
+#endif // TQTHREADSTORAGE_DEBUG
+
+    pthread_mutex_unlock( &thread_storage_mutex );
+}
+
+void **TQThreadStorageData::get() const
+{
+    TQThreadInstance *d = TQThreadInstance::current();
+    if (!d) {
+        qWarning("TQThreadStorage can only be used with threads started with TQThread");
+        return 0;
+    }
+    TQMutexLocker locker( d->mutex() );
+    return d->thread_storage && d->thread_storage[id] ? &d->thread_storage[id] : 0;
+}
+
+void **TQThreadStorageData::set( void *p )
+{
+    TQThreadInstance *d = TQThreadInstance::current();
+    if (!d) {
+        qWarning("TQThreadStorage can only be used with threads started with TQThread");
+        return 0;
+    }
+    TQMutexLocker locker( d->mutex() );
+    if ( !d->thread_storage ) {
+#ifdef TQTHREADSTORAGE_DEBUG
+	qDebug( "TQThreadStorageData: allocating storage for thread %lx",
+		(unsigned long) pthread_self() );
+#endif // TQTHREADSTORAGE_DEBUG
+
+	d->thread_storage = new void*[MAX_THREAD_STORAGE];
+	memset( d->thread_storage, 0, sizeof( void* ) * MAX_THREAD_STORAGE );
+    }
+
+    // delete any previous data
+    if ( d->thread_storage[id] )
+	thread_storage_usage[id].func( d->thread_storage[id] );
+
+    // store new data
+    d->thread_storage[id] = p;
+    return &d->thread_storage[id];
+}
+
+void TQThreadStorageData::finish( void **thread_storage )
+{
+    if ( ! thread_storage ) return; // nothing to do
+
+#ifdef TQTHREADSTORAGE_DEBUG
+    qDebug( "TQThreadStorageData: destroying storage for thread %lx",
+	    (unsigned long) pthread_self() );
+#endif // TQTHREADSTORAGE_DEBUG
+
+    for ( int i = 0; i < MAX_THREAD_STORAGE; ++i ) {
+	if ( ! thread_storage[i] ) continue;
+	if ( ! thread_storage_usage[i].used ) {
+#ifdef TQT_CHECK_STATE
+	    qWarning( "TQThreadStorage: thread %lx exited after TQThreadStorage destroyed",
+		      (unsigned long) pthread_self() );
+#endif // TQT_CHECK_STATE
+	    continue;
+	}
+
+	thread_storage_usage[i].func( thread_storage[i] );
+    }
+
+    delete [] thread_storage;
+}
+
+
+/*!
+    \class TQThreadStorage
+    \brief The TQThreadStorage class provides per-thread data storage.
+
+    \threadsafe
+    \ingroup thread
+    \ingroup environment
+
+    TQThreadStorage is a template class that provides per-thread data
+    storage.
+
+    \e{Note that due to compiler limitations, TQThreadStorage can only
+    store pointers.}
+
+    The setLocalData() function stores a single thread-specific value
+    for the calling thread. The data can be accessed later using the
+    localData() functions. TQThreadStorage takes ownership of the
+    data (which must be created on the heap with \e new) and deletes
+    it when the thread exits (either normally or via termination).
+
+    The hasLocalData() function allows the programmer to determine if
+    data has previously been set using the setLocalData() function.
+    This is useful for lazy initializiation.
+
+    For example, the following code uses TQThreadStorage to store a
+    single cache for each thread that calls the \e cacheObject() and
+    \e removeFromCache() functions. The cache is automatically
+    deleted when the calling thread exits (either normally or via
+    termination).
+
+    \code
+    TQThreadStorage<TQCache<SomeClass> *> caches;
+
+    void cacheObject( const TQString &key, SomeClass *object )
+    {
+        if ( ! caches.hasLocalData() )
+	    caches.setLocalData( new TQCache<SomeClass> );
+
+	caches.localData()->insert( key, object );
+    }
+
+    void removeFromCache( const TQString &key )
+    {
+        if ( ! caches.hasLocalData() )
+            return; // nothing to do
+
+	caches.localData()->remove( key );
+    }
+    \endcode
+
+    \section1 Caveats
+
+    \list
+
+    \i As noted above, TQThreadStorage can only store pointers due to
+    compiler limitations. Support for value-based objects will be
+    added when the majority of compilers are able to support partial
+    template specialization.
+
+    \i The \link ~TQThreadStorage() destructor\endlink does \e not
+    delete per-thread data. TQThreadStorage only deletes per-thread
+    data when the thread exits or when setLocalData() is called
+    multiple times.
+
+    \i TQThreadStorage can only be used with threads started with
+    TQThread. It \e cannot be used with threads started with
+    platform-specific APIs.
+
+    \i As a corollary to the above, platform-specific APIs cannot be
+    used to exit or terminate a TQThread using TQThreadStorage. Doing so
+    will cause all per-thread data to be leaked. See TQThread::exit()
+    and TQThread::terminate().
+
+    \i TQThreadStorage \e can be used to store data for the \e main()
+    thread \e after TQApplication has been constructed. TQThreadStorage
+    deletes all data set for the \e main() thread when TQApplication is
+    destroyed, regardless of whether or not the \e main() thread has
+    actually finished.
+
+    \i The implementation of TQThreadStorage limits the total number of
+    TQThreadStorage objects to 256. An unlimited number of threads
+    can store per-thread data in each TQThreadStorage object.
+
+    \endlist
+*/
+
+/*!
+    \fn TQThreadStorage::TQThreadStorage()
+
+    Constructs a new per-thread data storage object.
+*/
+
+/*!
+    \fn TQThreadStorage::~TQThreadStorage()
+
+    Destroys the per-thread data storage object.
+
+    Note: The per-thread data stored is \e not deleted. Any data left
+    in TQThreadStorage is leaked. Make sure that all threads using
+    TQThreadStorage have exited before deleting the TQThreadStorage.
+
+    \sa hasLocalData()
+*/
+
+/*!
+    \fn bool TQThreadStorage::hasLocalData() const
+
+    Returns TRUE if the calling thread has non-zero data available;
+    otherwise returns FALSE.
+
+    \sa localData()
+*/
+
+/*!
+    \fn T& TQThreadStorage::localData()
+
+    Returns a reference to the data that was set by the calling
+    thread.
+
+    Note: TQThreadStorage can only store pointers. This function
+    returns a \e reference to the pointer that was set by the calling
+    thread. The value of this reference is 0 if no data was set by
+    the calling thread,
+
+    \sa hasLocalData()
+*/
+/*
+  ### addition to the above documentation when we start supporting
+  ### partial template specialization, and TQThreadStorage can store
+  ### values *and* pointers
+
+  When using TQThreadStorage to store values (not pointers), this
+  function stores an object of type \e T (created with its default
+  constructor) and returns a reference to that object.
+*/
+
+/*!
+    \fn const T TQThreadStorage::localData() const
+    \overload
+
+    Returns a copy of the data that was set by the calling thread.
+
+    Note: TQThreadStorage can only store pointers. This function
+    returns a pointer to the data that was set by the calling thread.
+    If no data was set by the calling thread, this function returns 0.
+
+    \sa hasLocalData()
+*/
+/*
+  ### addition to the above documentation when we start supporting
+  ### partial template specialization, and TQThreadStorage can store
+  ### values *and* pointers
+
+  When using TQThreadStorage to store values (not pointers), this
+  function returns an object of type \e T (created with its default
+  constructor). Unlike the above function, this object is \e not
+  stored automatically. You will need to call setLocalData() to store
+  the object.
+*/
+
+/*!
+    \fn void TQThreadStorage::setLocalData( T data )
+
+    Sets the local data for the calling thread to \a data. It can be
+    accessed later using the localData() functions.
+
+    If \a data is 0, this function deletes the previous data (if
+    any) and returns immediately.
+
+    If \a data is non-zero, TQThreadStorage takes ownership of the \a
+    data and deletes it automatically either when the thread exits
+    (either normally or via termination) or when setLocalData() is
+    called again.
+
+    Note: TQThreadStorage can only store pointers. The \a data
+    argument must be either a pointer to an object created on the heap
+    (i.e. using \e new) or 0. You should not delete \a data
+    yourself; TQThreadStorage takes ownership and will delete the \a
+    data itself.
+
+    \sa localData() hasLocalData()
+*/
+
+#endif // TQT_THREAD_SUPPORT
diff --git a/tqtinterface/qt4/src/tools/tqtl.h b/tqtinterface/qt4/src/tools/tqtl.h
new file mode 100644
index 0000000..3f02d84
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqtl.h
@@ -0,0 +1,325 @@
+/****************************************************************************
+**
+** Definition of TQt template library classes
+**
+** Created : 990128
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQTL_H
+#define TQTL_H
+
+#ifndef TQT_H
+#include "tqglobal.h"
+#include "tqtextstream.h"
+#include "tqstring.h"
+#endif // TQT_H
+
+#ifndef TQT_NO_TEXTSTREAM
+template <class T>
+class TQTextOStreamIterator
+{
+protected:
+    TQTextOStream& stream;
+    TQString separator;
+
+public:
+    TQTextOStreamIterator( TQTextOStream& s) : stream( s ) {}
+    TQTextOStreamIterator( TQTextOStream& s, const TQString& sep )
+	: stream( s ), separator( sep )  {}
+    TQTextOStreamIterator<T>& operator= ( const T& x ) {
+	stream << x;
+	if ( !separator.isEmpty() )
+	    stream << separator;
+	return *this;
+    }
+    TQTextOStreamIterator<T>& operator*() { return *this; }
+    TQTextOStreamIterator<T>& operator++() { return *this; }
+    TQTextOStreamIterator<T>& operator++(int) { return *this; }
+};
+#endif //TQT_NO_TEXTSTREAM
+
+template <class InputIterator, class OutputIterator>
+inline OutputIterator tqCopy( InputIterator _begin, InputIterator _end,
+			     OutputIterator _dest )
+{
+    while( _begin != _end )
+	*_dest++ = *_begin++;
+    return _dest;
+}
+
+template <class BiIterator, class BiOutputIterator>
+inline BiOutputIterator tqCopyBackward( BiIterator _begin, BiIterator _end,
+				       BiOutputIterator _dest )
+{
+    while ( _begin != _end )
+	*--_dest = *--_end;
+    return _dest;
+}
+
+template <class InputIterator1, class InputIterator2>
+inline bool tqEqual( InputIterator1 first1, InputIterator1 last1, InputIterator2 first2 )
+{
+    // ### compare using !(*first1 == *first2) in TQt 4.0
+    for ( ; first1 != last1; ++first1, ++first2 )
+	if ( *first1 != *first2 )
+	    return FALSE;
+    return TRUE;
+}
+
+template <class ForwardIterator, class T>
+inline void tqFill( ForwardIterator first, ForwardIterator last, const T& val )
+{
+    for ( ; first != last; ++first )
+	*first = val;
+}
+
+#if 0
+template <class BiIterator, class OutputIterator>
+inline OutputIterator qReverseCopy( BiIterator _begin, BiIterator _end,
+				    OutputIterator _dest )
+{
+    while ( _begin != _end ) {
+	--_end;
+	*_dest = *_end;
+	++_dest;
+    }
+    return _dest;
+}
+#endif
+
+
+template <class InputIterator, class T>
+inline InputIterator tqFind( InputIterator first, InputIterator last,
+			    const T& val )
+{
+    while ( first != last && *first != val )
+	++first;
+    return first;
+}
+
+template <class InputIterator, class T, class Size>
+inline void tqCount( InputIterator first, InputIterator last, const T& value,
+		    Size& n )
+{
+    for ( ; first != last; ++first )
+	if ( *first == value )
+	    ++n;
+}
+
+template <class T>
+inline void tqSwap( T& _value1, T& _value2 )
+{
+    T tmp = _value1;
+    _value1 = _value2;
+    _value2 = tmp;
+}
+
+
+template <class InputIterator>
+TQ_INLINE_TEMPLATES void qBubbleSort( InputIterator b, InputIterator e )
+{
+    // Goto last element;
+    InputIterator last = e;
+    --last;
+    // only one element or no elements ?
+    if ( last == b )
+	return;
+
+    // So we have at least two elements in here
+    while( b != last ) {
+	bool swapped = FALSE;
+	InputIterator swap_pos = b;
+	InputIterator x = e;
+	InputIterator y = x;
+	y--;
+	do {
+	    --x;
+	    --y;
+	    if ( *x < *y ) {
+		swapped = TRUE;
+		tqSwap( *x, *y );
+		swap_pos = y;
+	    }
+	} while( y != b );
+	if ( !swapped )
+	    return;
+	b = swap_pos;
+	b++;
+    }
+}
+
+
+template <class Container>
+inline void qBubbleSort( Container &c )
+{
+  qBubbleSort( c.begin(), c.end() );
+}
+
+
+template <class Value>
+TQ_INLINE_TEMPLATES void qHeapSortPushDown( Value* heap, int first, int last )
+{
+    int r = first;
+    while ( r <= last / 2 ) {
+	if ( last == 2 * r ) {
+	    // node r has only one child
+	    if ( heap[2 * r] < heap[r] )
+		tqSwap( heap[r], heap[2 * r] );
+	    r = last;
+	} else {
+	    // node r has two tqchildren
+	    if ( heap[2 * r] < heap[r] && !(heap[2 * r + 1] < heap[2 * r]) ) {
+		// swap with left child
+		tqSwap( heap[r], heap[2 * r] );
+		r *= 2;
+	    } else if ( heap[2 * r + 1] < heap[r]
+			&& heap[2 * r + 1] < heap[2 * r] ) {
+		// swap with right child
+		tqSwap( heap[r], heap[2 * r + 1] );
+		r = 2 * r + 1;
+	    } else {
+		r = last;
+	    }
+	}
+    }
+}
+
+
+template <class InputIterator, class Value>
+TQ_INLINE_TEMPLATES void qHeapSortHelper( InputIterator b, InputIterator e, Value, uint n )
+{
+    // Create the heap
+    InputIterator insert = b;
+    Value* realheap = new Value[n];
+    // Wow, what a fake. But I want the heap to be indexed as 1...n
+    Value* heap = realheap - 1;
+    int size = 0;
+    for( ; insert != e; ++insert ) {
+	heap[++size] = *insert;
+	int i = size;
+	while( i > 1 && heap[i] < heap[i / 2] ) {
+	    tqSwap( heap[i], heap[i / 2] );
+	    i /= 2;
+	}
+    }
+
+    // Now do the sorting
+    for( uint i = n; i > 0; i-- ) {
+	*b++ = heap[1];
+	if ( i > 1 ) {
+	    heap[1] = heap[i];
+	    qHeapSortPushDown( heap, 1, (int)i - 1 );
+	}
+    }
+
+    delete[] realheap;
+}
+
+
+template <class InputIterator>
+TQ_INLINE_TEMPLATES void qHeapSort( InputIterator b, InputIterator e )
+{
+    // Empty ?
+    if ( b == e )
+	return;
+
+    // How many entries have to be sorted ?
+    InputIterator it = b;
+    uint n = 0;
+    while ( it != e ) {
+	++n;
+	++it;
+    }
+
+    // The second last parameter is a hack to retrieve the value type
+    // Do the real sorting here
+    qHeapSortHelper( b, e, *b, n );
+}
+
+
+template <class Container>
+TQ_INLINE_TEMPLATES void qHeapSort( Container &c )
+{
+    if ( c.begin() == c.end() )
+	return;
+
+    // The second last parameter is a hack to retrieve the value type
+    // Do the real sorting here
+    qHeapSortHelper( c.begin(), c.end(), *(c.begin()), (uint)c.count() );
+}
+
+template <class Container>
+class TQBackInsertIterator
+{
+public:
+    TQ_EXPLICIT TQBackInsertIterator( Container &c )
+	: container( &c )
+    {
+    }
+
+    TQBackInsertIterator<Container>&
+    operator=( const TQ_TYPENAME Container::value_type &value )
+    {
+	container->push_back( value );
+	return *this;
+    }
+
+    TQBackInsertIterator<Container>& operator*()
+    {
+	return *this;
+    }
+
+    TQBackInsertIterator<Container>& operator++()
+    {
+	return *this;
+    }
+
+    TQBackInsertIterator<Container>& operator++(int)
+    {
+	return *this;
+    }
+
+protected:
+    Container *container;
+};
+
+template <class Container>
+inline TQBackInsertIterator<Container> qBackInserter( Container &c )
+{
+    return TQBackInsertIterator<Container>( c );
+}
+
+#endif
diff --git a/tqtinterface/qt4/src/tools/tqucom.cpp b/tqtinterface/qt4/src/tools/tqucom.cpp
new file mode 100644
index 0000000..7f77a39
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqucom.cpp
@@ -0,0 +1,547 @@
+/****************************************************************************
+**
+** Implementation of the TQUcom classes
+**
+** Created : 990101
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "tqucom_p.h"
+
+// Standard types
+
+// {DE56510E-4E9F-4b76-A3C2-D1E2EF42F1AC}
+const TQUuid TID_TQUType_Null( 0xde56510e, 0x4e9f, 0x4b76, 0xa3, 0xc2, 0xd1, 0xe2, 0xef, 0x42, 0xf1, 0xac );
+const TQUuid *TQUType_Null::uuid() const { return &TID_TQUType_Null; }
+const char *TQUType_Null::desc() const { return "null"; }
+bool TQUType_Null::canConvertFrom( TQUObject *, TQUType * ) { return FALSE; }
+bool TQUType_Null::canConvertTo( TQUObject *, TQUType * ) { return FALSE; }
+bool TQUType_Null::convertFrom( TQUObject *, TQUType * ) { return FALSE; }
+bool TQUType_Null::convertTo( TQUObject *, TQUType * ) { return FALSE; }
+void TQUType_Null::clear( TQUObject *) {}
+int TQUType_Null::serializeTo( TQUObject *, TQUBuffer * ) { return 0; }
+int TQUType_Null::serializeFrom( TQUObject *, TQUBuffer * ) { return 0; }
+TQUType_Null static_TQUType_Null;
+
+
+// {7EE17B08-5419-47e2-9776-8EEA112DCAEC}
+const TQUuid TID_TQUType_enum( 0x7ee17b08, 0x5419, 0x47e2, 0x97, 0x76, 0x8e, 0xea, 0x11, 0x2d, 0xca, 0xec );
+TQUType_enum static_TQUType_enum;
+const TQUuid *TQUType_enum::uuid() const { return &TID_TQUType_enum; }
+const char *TQUType_enum::desc() const { return "enum"; }
+void TQUType_enum::set( TQUObject *o, int v )
+{
+    o->payload.i = v;
+    o->type = this;
+}
+
+bool TQUType_enum::canConvertFrom( TQUObject *o, TQUType *t )
+{
+    if ( isEqual( t, &static_TQUType_int ) ) // ## todo unsigned int?
+	return TRUE;
+
+    return t->canConvertTo( o, this );
+}
+
+bool TQUType_enum::canConvertTo( TQUObject * /*o*/, TQUType *t )
+{
+    return isEqual( t, &static_TQUType_int );
+}
+
+bool TQUType_enum::convertFrom( TQUObject *o, TQUType *t )
+{
+    if ( isEqual( t, &static_TQUType_int ) ) // ## todo unsigned int?
+	;
+    else
+	return t->convertTo( o, this );
+
+    o->type = this;
+    return TRUE;
+}
+
+bool TQUType_enum::convertTo( TQUObject *o, TQUType *t )
+{
+    if ( isEqual( t,  &static_TQUType_int ) ) {
+	o->type = &static_TQUType_int;
+	return TRUE;
+    }
+    return FALSE;
+}
+
+int TQUType_enum::serializeTo( TQUObject *, TQUBuffer * )
+{
+    return 0;
+}
+
+int TQUType_enum::serializeFrom( TQUObject *, TQUBuffer * )
+{
+    return 0;
+}
+
+// {8AC26448-5AB4-49eb-968C-8F30AB13D732}
+const TQUuid TID_TQUType_ptr( 0x8ac26448, 0x5ab4, 0x49eb, 0x96, 0x8c, 0x8f, 0x30, 0xab, 0x13, 0xd7, 0x32 );
+TQUType_ptr static_TQUType_ptr;
+const TQUuid *TQUType_ptr::uuid() const  { return &TID_TQUType_ptr; }
+const char *TQUType_ptr::desc() const { return "ptr"; }
+
+void TQUType_ptr::set( TQUObject *o, const void* v )
+{
+    o->payload.ptr = (void*) v;
+    o->type = this;
+}
+
+bool TQUType_ptr::canConvertFrom( TQUObject *o, TQUType *t )
+{
+    return t->canConvertTo( o, this );
+}
+
+bool TQUType_ptr::canConvertTo( TQUObject *, TQUType * )
+{
+    return FALSE;
+}
+
+bool TQUType_ptr::convertFrom( TQUObject *o, TQUType *t )
+{
+    return t->convertTo( o, this );
+}
+
+bool TQUType_ptr::convertTo( TQUObject *, TQUType * )
+{
+    return FALSE;
+}
+
+int TQUType_ptr::serializeTo( TQUObject *, TQUBuffer * )
+{
+    return 0;
+}
+
+int TQUType_ptr::serializeFrom( TQUObject *, TQUBuffer * )
+{
+    return 0;
+}
+
+// {97A2594D-6496-4402-A11E-55AEF2D4D25C}
+const TQUuid TID_TQUType_iface( 0x97a2594d, 0x6496, 0x4402, 0xa1, 0x1e, 0x55, 0xae, 0xf2, 0xd4, 0xd2, 0x5c );
+TQUType_iface static_TQUType_iface;
+const TQUuid *TQUType_iface::uuid() const  { return &TID_TQUType_iface; }
+const char *TQUType_iface::desc() const { return "UnknownInterface"; }
+
+void TQUType_iface::set( TQUObject *o, TQUnknownInterface* iface )
+{
+    o->payload.iface = iface;
+    o->type = this;
+}
+
+bool TQUType_iface::canConvertFrom( TQUObject *o, TQUType *t )
+{
+    return t->canConvertTo( o, this );
+}
+
+bool TQUType_iface::canConvertTo( TQUObject *, TQUType * )
+{
+    return FALSE;
+}
+
+bool TQUType_iface::convertFrom( TQUObject *o, TQUType *t )
+{
+    return t->convertTo( o, this );
+}
+
+bool TQUType_iface::convertTo( TQUObject *, TQUType * )
+{
+    return FALSE;
+}
+
+int TQUType_iface::serializeTo( TQUObject *, TQUBuffer * )
+{
+    return 0;
+}
+
+int TQUType_iface::serializeFrom( TQUObject *, TQUBuffer * )
+{
+    return 0;
+}
+
+// {2F358164-E28F-4bf4-9FA9-4E0CDCABA50B}
+const TQUuid TID_TQUType_idisp( 0x2f358164, 0xe28f, 0x4bf4, 0x9f, 0xa9, 0x4e, 0xc, 0xdc, 0xab, 0xa5, 0xb );
+TQUType_idisp static_TQUType_idisp;
+const TQUuid *TQUType_idisp::uuid() const  { return &TID_TQUType_idisp; }
+const char *TQUType_idisp::desc() const { return "DispatchInterface"; }
+
+void TQUType_idisp::set( TQUObject *o, TQDispatchInterface* idisp )
+{
+    o->payload.idisp = idisp;
+    o->type = this;
+}
+
+bool TQUType_idisp::canConvertFrom( TQUObject *o, TQUType *t )
+{
+    return t->canConvertTo( o, this );
+}
+
+bool TQUType_idisp::canConvertTo( TQUObject * /*o*/, TQUType *t )
+{
+    return isEqual( t, &static_TQUType_iface );
+}
+
+bool TQUType_idisp::convertFrom( TQUObject *o, TQUType *t )
+{
+    return t->convertTo( o, this );
+}
+
+bool TQUType_idisp::convertTo( TQUObject *o, TQUType *t )
+{
+#ifndef TQT_NO_COMPONENT
+    if ( isEqual( t, &static_TQUType_iface ) ) {
+	o->payload.iface = (TQUnknownInterface*)o->payload.idisp;
+	o->type = &static_TQUType_iface;
+	return TRUE;
+    }
+#endif
+    return FALSE;
+}
+
+int TQUType_idisp::serializeTo( TQUObject *, TQUBuffer * )
+{
+    return 0;
+}
+
+int TQUType_idisp::serializeFrom( TQUObject *, TQUBuffer * )
+{
+    return 0;
+}
+
+// {CA42115D-13D0-456c-82B5-FC10187F313E}
+const TQUuid TID_TQUType_bool( 0xca42115d, 0x13d0, 0x456c, 0x82, 0xb5, 0xfc, 0x10, 0x18, 0x7f, 0x31, 0x3e );
+TQUType_bool static_TQUType_bool;
+const TQUuid *TQUType_bool::uuid() const  { return &TID_TQUType_bool; }
+const char *TQUType_bool::desc() const { return "bool"; }
+
+void TQUType_bool::set( TQUObject *o, bool v )
+{
+    o->payload.b = v;
+    o->type = this;
+}
+
+bool TQUType_bool::canConvertFrom( TQUObject *o, TQUType *t )
+{
+    return t->canConvertTo( o, this );
+}
+
+bool TQUType_bool::canConvertTo( TQUObject *, TQUType * )
+{
+    return FALSE;
+}
+
+bool TQUType_bool::convertFrom( TQUObject *o, TQUType *t )
+{
+    return t->convertTo( o, this );
+}
+
+bool TQUType_bool::convertTo( TQUObject *, TQUType * )
+{
+    return FALSE;
+}
+
+int TQUType_bool::serializeTo( TQUObject *, TQUBuffer * )
+{
+    return 0;
+}
+
+int TQUType_bool::serializeFrom( TQUObject *, TQUBuffer * )
+{
+    return 0;
+}
+
+// {53C1F3BE-73C3-4c7d-9E05-CCF09EB676B5}
+const TQUuid TID_TQUType_int( 0x53c1f3be, 0x73c3, 0x4c7d, 0x9e, 0x5, 0xcc, 0xf0, 0x9e, 0xb6, 0x76, 0xb5 );
+TQUType_int static_TQUType_int;
+const TQUuid *TQUType_int::uuid() const  { return &TID_TQUType_int; }
+const char *TQUType_int::desc() const { return "int"; }
+
+void TQUType_int::set( TQUObject *o, int v )
+{
+    o->payload.i = v;
+    o->type = this;
+}
+
+bool TQUType_int::canConvertFrom( TQUObject *o, TQUType *t )
+{
+    if ( isEqual( t, &static_TQUType_double ) )
+	return TRUE;
+
+    return t->canConvertTo( o, this );
+}
+
+bool TQUType_int::canConvertTo( TQUObject * /*o*/, TQUType *t )
+{
+    return isEqual( t,  &static_TQUType_double );
+}
+
+bool TQUType_int::convertFrom( TQUObject *o, TQUType *t )
+{
+    if ( isEqual( t, &static_TQUType_double ) )
+	o->payload.i = (long)o->payload.d;
+    else
+	return t->convertTo( o, this );
+
+    o->type = this;
+    return TRUE;
+}
+
+bool TQUType_int::convertTo( TQUObject *o, TQUType *t )
+{
+    if ( isEqual( t,  &static_TQUType_double ) ) {
+	o->payload.d = (double)o->payload.i;
+	o->type = &static_TQUType_double;
+    } else
+	return FALSE;
+    return TRUE;
+}
+
+int TQUType_int::serializeTo( TQUObject *, TQUBuffer * )
+{
+    return 0;
+}
+
+int TQUType_int::serializeFrom( TQUObject *, TQUBuffer * )
+{
+    return 0;
+}
+
+// {2D0974E5-0BA6-4ec2-8837-C198972CB48C}
+const TQUuid TID_TQUType_double( 0x2d0974e5, 0xba6, 0x4ec2, 0x88, 0x37, 0xc1, 0x98, 0x97, 0x2c, 0xb4, 0x8c );
+TQUType_double static_TQUType_double;
+const TQUuid *TQUType_double::uuid() const { return &TID_TQUType_double; }
+const char *TQUType_double::desc() const {return "double"; }
+
+void TQUType_double::set( TQUObject *o, double v )
+{
+    o->payload.d = v;
+    o->type = this;
+}
+
+bool TQUType_double::canConvertFrom( TQUObject *o, TQUType *t )
+{
+    if ( isEqual( t, &static_TQUType_int ) )
+	return TRUE;
+
+    return t->canConvertTo( o, this );
+}
+
+bool TQUType_double::canConvertTo( TQUObject * /*o*/, TQUType *t )
+{
+    return isEqual( t,  &static_TQUType_int );
+}
+
+bool TQUType_double::convertFrom( TQUObject *o, TQUType *t )
+{
+    if ( isEqual( t, &static_TQUType_int ) )
+	o->payload.d = (double)o->payload.i;
+     else
+	return t->convertTo( o, this );
+
+    o->type = this;
+    return TRUE;
+}
+
+bool TQUType_double::convertTo( TQUObject *o, TQUType *t )
+{
+    if ( isEqual( t,  &static_TQUType_int ) ) {
+	o->payload.i = (int) o->payload.d;
+	o->type = &static_TQUType_int;
+    } else if ( isEqual( t,  &static_TQUType_double ) ) {
+	o->payload.d = (double) o->payload.f;
+	o->type = &static_TQUType_double;
+    } else
+	return FALSE;
+    return TRUE;
+}
+
+int TQUType_double::serializeTo( TQUObject *, TQUBuffer * )
+{
+    return 0;
+}
+
+int TQUType_double::serializeFrom( TQUObject *, TQUBuffer * )
+{
+    return 0;
+}
+
+// {EFCDD1D4-77A3-4b8e-8D46-DC14B8D393E9}
+const TQUuid TID_TQUType_charstar( 0xefcdd1d4, 0x77a3, 0x4b8e, 0x8d, 0x46, 0xdc, 0x14, 0xb8, 0xd3, 0x93, 0xe9 );
+TQUType_charstar static_TQUType_charstar;
+const TQUuid *TQUType_charstar::uuid() const { return &TID_TQUType_charstar; }
+const char *TQUType_charstar::desc() const { return "char*"; }
+
+void TQUType_charstar::set( TQUObject *o, const char* v, bool take )
+{
+    if ( take ) {
+	if ( v ) {
+	    o->payload.charstar.ptr = new char[ strlen(v) + 1 ];
+	    strcpy( o->payload.charstar.ptr, v );
+	} else {
+	    o->payload.charstar.ptr = 0;
+	}
+	o->payload.charstar.owner = TRUE;
+    } else {
+	o->payload.charstar.ptr = (char*) v;
+	o->payload.charstar.owner = FALSE;
+    }
+    o->type = this;
+}
+
+bool TQUType_charstar::canConvertFrom( TQUObject *o, TQUType *t )
+{
+    return t->canConvertTo( o, this );
+}
+
+bool TQUType_charstar::canConvertTo( TQUObject *, TQUType * )
+{
+    return FALSE;
+}
+
+bool TQUType_charstar::convertFrom( TQUObject *o, TQUType *t )
+{
+    return t->convertTo( o, this );
+}
+
+bool TQUType_charstar::convertTo( TQUObject *, TQUType * )
+{
+    return FALSE;
+}
+
+void TQUType_charstar::clear( TQUObject *o )
+{
+    if ( o->payload.charstar.owner )
+	delete [] o->payload.charstar.ptr;
+    o->payload.charstar.ptr = 0;
+}
+
+int TQUType_charstar::serializeTo( TQUObject *, TQUBuffer * )
+{
+    return 0;
+}
+
+int TQUType_charstar::serializeFrom( TQUObject *, TQUBuffer * )
+{
+    return 0;
+}
+
+
+// TQt specific types
+
+// {44C2A547-01E7-4e56-8559-35AF9D2F42B7}
+const TQUuid TID_TQUType_TQString( 0x44c2a547, 0x1e7, 0x4e56, 0x85, 0x59, 0x35, 0xaf, 0x9d, 0x2f, 0x42, 0xb7 );
+TQUType_TQString static_TQUType_TQString;
+const TQUuid *TQUType_TQString::uuid() const { return &TID_TQUType_TQString; }
+const char *TQUType_TQString::desc() const { return "TQString"; }
+
+void TQUType_TQString::set( TQUObject *o, const TQString& v )
+{
+    o->payload.ptr = new TQString( v );
+    o->type = this;
+}
+
+bool TQUType_TQString::canConvertFrom( TQUObject *o, TQUType *t )
+{
+    if ( isEqual( t, &static_TQUType_charstar ) ||
+	 isEqual( t, &static_TQUType_double ) ||
+	 isEqual( t, &static_TQUType_int ) )
+	return TRUE;
+
+    return t->canConvertTo( o, this );
+}
+
+bool TQUType_TQString::canConvertTo( TQUObject * /*o*/, TQUType *t )
+{
+    return isEqual( t, &static_TQUType_charstar ) ||
+	isEqual( t,  &static_TQUType_int ) ||
+	isEqual( t,  &static_TQUType_double );
+}
+
+bool TQUType_TQString::convertFrom( TQUObject *o, TQUType *t )
+{
+    TQString *str = 0;
+    if ( isEqual( t, &static_TQUType_charstar ) )
+	str = new TQString( o->payload.charstar.ptr );
+    else if ( isEqual( t, &static_TQUType_double ) )
+	str = new TQString( TQString::number( o->payload.d ) );
+    else if ( isEqual( t, &static_TQUType_int ) )
+	str = new TQString( TQString::number( o->payload.i ) );
+    else
+	return t->convertTo( o, this );
+
+    o->type->clear( o );
+    o->payload.ptr = str;
+    o->type = this;
+    return TRUE;
+}
+
+bool TQUType_TQString::convertTo( TQUObject *o, TQUType *t )
+{
+    TQString *str = (TQString *)o->payload.ptr;
+    if ( isEqual( t, &static_TQUType_charstar ) ) {
+	o->payload.charstar.ptr = qstrdup( str->local8Bit().data() );
+	o->payload.charstar.owner = TRUE;
+	o->type = &static_TQUType_charstar;
+    } else if ( isEqual( t,  &static_TQUType_int ) ) {
+	o->payload.l = str->toLong();
+	o->type = &static_TQUType_int;
+    } else if ( isEqual( t,  &static_TQUType_double ) ) {
+	o->payload.d = str->toDouble();
+	o->type = &static_TQUType_double;
+    } else {
+        return FALSE;
+    }
+    delete str;
+    return TRUE;
+}
+
+int TQUType_TQString::serializeTo( TQUObject *, TQUBuffer * )
+{
+    return 0;
+}
+
+int TQUType_TQString::serializeFrom( TQUObject *, TQUBuffer * )
+{
+    return 0;
+}
+
+void TQUType_TQString::clear( TQUObject *o )
+{
+    delete (TQString*)o->payload.ptr;
+    o->payload.ptr = 0;
+}
diff --git a/tqtinterface/qt4/src/tools/tqucom_p.h b/tqtinterface/qt4/src/tools/tqucom_p.h
new file mode 100644
index 0000000..546e0f2
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqucom_p.h
@@ -0,0 +1,470 @@
+/****************************************************************************
+**
+** Definition of the TQUcom interfaces
+**
+** Created : 990101
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQUCOM_P_H
+#define TQUCOM_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the TQt API.  It exists for the convenience
+// of a number of TQt sources files.  This header file may change from
+// version to version without notice, or even be removed.
+//
+// We mean it.
+//
+//
+
+#ifndef TQT_H
+#include "tqstring.h"
+#include "tquuid.h"
+#endif // TQT_H
+
+#ifdef check
+#undef check
+#endif
+
+#if __GNUC__ - 0 > 3
+#pragma GCC system_header
+#endif
+
+struct TQUObject;
+struct TQUInterfaceDescription;
+struct TQUnknownInterface;
+struct TQDispatchInterface;
+
+
+struct TQ_EXPORT TQUBuffer
+{
+    virtual long read( char *data, ulong maxlen ) = 0;
+    virtual long write( const char *data, ulong len ) = 0;
+};
+
+
+// A type for a TQUObject
+struct TQ_EXPORT TQUType
+{
+    virtual const TQUuid *uuid() const = 0;
+    virtual const char *desc() const = 0;
+
+
+    virtual bool canConvertFrom( TQUObject *, TQUType * ) = 0;
+    // virtual private, only called by canConvertFrom
+    virtual bool canConvertTo( TQUObject *, TQUType * ) = 0;
+
+
+    virtual bool convertFrom( TQUObject *, TQUType * ) = 0;
+    // virtual private, only called by convertFrom
+    virtual bool convertTo( TQUObject *, TQUType * ) = 0;
+
+    virtual void clear( TQUObject * ) = 0;
+
+    virtual int serializeTo( TQUObject *, TQUBuffer * ) = 0;
+    virtual int serializeFrom( TQUObject *, TQUBuffer * ) = 0;
+
+    static bool isEqual( const TQUType *t1, const TQUType *t2 );
+    static bool check( TQUObject* o, TQUType* t );
+};
+
+
+// {DE56510E-4E9F-4b76-A3C2-D1E2EF42F1AC}
+extern TQ_EXPORT const TQUuid TID_TQUType_Null;
+struct TQ_EXPORT TQUType_Null : public TQUType
+{
+    const TQUuid *uuid() const;
+    const char *desc() const;
+
+    bool canConvertFrom( TQUObject *, TQUType * );
+    bool canConvertTo( TQUObject *, TQUType * );
+    bool convertFrom( TQUObject *, TQUType * );
+    bool convertTo( TQUObject *, TQUType * );
+    void clear( TQUObject * );
+    int serializeTo( TQUObject *, TQUBuffer * );
+    int serializeFrom( TQUObject *, TQUBuffer * );
+};
+extern TQ_EXPORT TQUType_Null static_TQUType_Null;
+
+
+// The magic TQUObject
+struct TQ_EXPORT TQUObject
+{
+public: // scary MSVC bug makes this necessary
+    TQUObject() : type( &static_TQUType_Null ) {}
+    ~TQUObject() { type->clear( this ); }
+
+    TQUType *type;
+
+    // the unavoidable union
+    union
+    {
+	bool b;
+
+	char c;
+	short s;
+	int i;
+	long l;
+
+	unsigned char uc;
+	unsigned short us;
+	unsigned int ui;
+	unsigned long ul;
+
+	float f;
+	double d;
+
+	char byte[16];
+
+	struct {
+	   char* data;
+	   unsigned long size;
+	} bytearray;
+
+	void* ptr;
+
+	struct {
+	    void *ptr;
+	    bool owner;
+	} voidstar;
+
+	struct {
+	    char *ptr;
+	    bool owner;
+	} charstar;
+
+	struct {
+	    char *ptr;
+	    bool owner;
+	} utf8;
+
+	struct {
+	    char *ptr;
+	    bool owner;
+	} local8bit;
+
+	TQUnknownInterface* iface;
+	TQDispatchInterface* idisp;
+
+    } payload;
+
+};
+
+
+// A parameter description describes one method parameters. A
+// parameter has a name, a type and a flag describing whether it's an
+// in parameter, an out parameter, or both ways
+struct TQ_EXPORT TQUParameter
+{
+    const char* name;
+    TQUType *type;
+    const void* typeExtra; //Usually 0, UEnum* for TQUType_enum, const char* for TQUType_ptr, int* for TQUType_varptr
+    enum { In = 1, Out = 2, InOut = In | Out };
+    int inOut;
+};
+
+// A method description describes one method. A method has a name and
+// an array of parameters.
+struct TQ_EXPORT TQUMethod
+{
+    const char* name;
+    int count;
+    const TQUParameter* parameters;
+};
+
+// A Property description. Not used yet in the example.
+struct TQ_EXPORT TQUProperty
+{
+    const char* name;
+    TQUType* type;
+    const void* typeExtra; //type dependend. Usually 0, but UEnum for TQUTypeenum or const char* for TQUTypeptr
+
+    int set; // -1 undefined
+    int get; // -1 undefined
+
+    int designable; // -1 FALSE, -2 TRUE, else method
+    int stored; // -1 FALSE, -2 TRUE, else method
+};
+
+// An interface description describes one interface, that is all its
+// methods and properties.
+struct TQ_EXPORT TQUInterfaceDescription
+{
+    int methodCount;
+    const TQUMethod* methods;
+    int propertyCount;
+    const TQUProperty* properties;
+};
+
+
+// A component description describe one component, that is its name,
+// vendor, release, info, its component uuid and all its interface
+// uuids.
+struct TQ_EXPORT TQUComponentDescription
+{
+    const char* name;
+    const char* vendor;
+    const char* release;
+    const char* info;
+    TQUuid cid;
+    int count;
+    const TQUuid* interfaces;
+};
+
+
+// A component server description describe one component server, that
+// is its name, vendor, release, info and the descriptions of all
+// components it can instantiate.
+struct TQ_EXPORT TQUComponentServerDescription
+{
+    const char* name;
+    const char* vendor;
+    const char* release;
+    const char* info;
+    int count;
+    const TQUComponentDescription* components;
+};
+
+
+
+struct TQ_EXPORT TQUEnumItem 				// - a name/value pair
+{
+    const char *key;
+    int value;
+};
+
+struct TQ_EXPORT TQUEnum
+{
+    const char *name;			// - enumerator name
+    unsigned int count;			// - number of values
+    const TQUEnumItem *items;		// - the name/value pairs
+    bool set;				// whether enum has to be treated as a set
+};
+
+inline bool TQUType::isEqual( const TQUType *t1, const TQUType *t2 ) {
+    return t1 == t2 || t1->uuid() == t2->uuid() ||
+	*(t1->uuid()) == *(t2->uuid());
+}
+
+inline bool TQUType::check( TQUObject* o, TQUType* t ) {
+    return isEqual( o->type, t ) || t->convertFrom( o, o->type );
+}
+
+
+
+// {7EE17B08-5419-47e2-9776-8EEA112DCAEC}
+extern TQ_EXPORT const TQUuid TID_TQUType_enum;
+struct TQ_EXPORT TQUType_enum : public TQUType
+{
+    const TQUuid *uuid() const;
+    const char *desc() const;
+
+    void set( TQUObject *, int );
+    int &get( TQUObject * o ) { return o->payload.i; }
+    bool canConvertFrom( TQUObject *, TQUType * );
+    bool canConvertTo( TQUObject *, TQUType * );
+    bool convertFrom( TQUObject *, TQUType * );
+    bool convertTo( TQUObject *, TQUType * );
+    void clear( TQUObject * ) {}
+    int serializeTo( TQUObject *, TQUBuffer * );
+    int serializeFrom( TQUObject *, TQUBuffer * );
+};
+extern TQ_EXPORT TQUType_enum static_TQUType_enum;
+
+
+// {8AC26448-5AB4-49eb-968C-8F30AB13D732}
+extern TQ_EXPORT const TQUuid TID_TQUType_ptr;
+struct TQ_EXPORT TQUType_ptr : public TQUType
+{
+    const TQUuid *uuid() const;
+    const char *desc() const;
+
+    void set( TQUObject *, const void* );
+    void* &get( TQUObject * o ) { return o->payload.ptr; }
+    bool canConvertFrom( TQUObject *, TQUType * );
+    bool canConvertTo( TQUObject *, TQUType * );
+    bool convertFrom( TQUObject *, TQUType * );
+    bool convertTo( TQUObject *, TQUType * );
+    void clear( TQUObject * ) {}
+    int serializeTo( TQUObject *, TQUBuffer * );
+    int serializeFrom( TQUObject *, TQUBuffer * );
+};
+extern TQ_EXPORT TQUType_ptr static_TQUType_ptr;
+
+// {97A2594D-6496-4402-A11E-55AEF2D4D25C}
+extern TQ_EXPORT const TQUuid TID_TQUType_iface;
+struct TQ_EXPORT TQUType_iface : public TQUType
+{
+    const TQUuid *uuid() const;
+    const char *desc() const;
+
+    void set( TQUObject *, TQUnknownInterface* );
+    TQUnknownInterface* &get( TQUObject *o ){ return o->payload.iface; }
+    bool canConvertFrom( TQUObject *, TQUType * );
+    bool canConvertTo( TQUObject *, TQUType * );
+    bool convertFrom( TQUObject *, TQUType * );
+    bool convertTo( TQUObject *, TQUType * );
+    void clear( TQUObject * ) {}
+    int serializeTo( TQUObject *, TQUBuffer * );
+    int serializeFrom( TQUObject *, TQUBuffer * );
+};
+extern TQ_EXPORT TQUType_iface static_TQUType_iface;
+
+// {2F358164-E28F-4bf4-9FA9-4E0CDCABA50B}
+extern TQ_EXPORT const TQUuid TID_TQUType_idisp;
+struct TQ_EXPORT TQUType_idisp : public TQUType
+{
+    const TQUuid *uuid() const;
+    const char *desc() const;
+
+    void set( TQUObject *, TQDispatchInterface* );
+    TQDispatchInterface* &get( TQUObject *o ){ return o->payload.idisp; }
+    bool canConvertFrom( TQUObject *, TQUType * );
+    bool canConvertTo( TQUObject *, TQUType * );
+    bool convertFrom( TQUObject *, TQUType * );
+    bool convertTo( TQUObject *, TQUType * );
+    void clear( TQUObject * ) {}
+    int serializeTo( TQUObject *, TQUBuffer * );
+    int serializeFrom( TQUObject *, TQUBuffer * );
+};
+extern TQ_EXPORT TQUType_idisp static_TQUType_idisp;
+
+// {CA42115D-13D0-456c-82B5-FC10187F313E}
+extern TQ_EXPORT const TQUuid TID_TQUType_bool;
+struct TQ_EXPORT TQUType_bool : public TQUType
+{
+    const TQUuid *uuid() const;
+    const char *desc() const;
+
+    void set( TQUObject *, bool );
+    bool &get( TQUObject *o ) { return o->payload.b; }
+    bool canConvertFrom( TQUObject *, TQUType * );
+    bool canConvertTo( TQUObject *, TQUType * );
+    bool convertFrom( TQUObject *, TQUType * );
+    bool convertTo( TQUObject *, TQUType * );
+    void clear( TQUObject * ) {}
+    int serializeTo( TQUObject *, TQUBuffer * );
+    int serializeFrom( TQUObject *, TQUBuffer * );
+};
+extern TQ_EXPORT TQUType_bool static_TQUType_bool;
+
+// {53C1F3BE-73C3-4c7d-9E05-CCF09EB676B5}
+extern TQ_EXPORT const TQUuid TID_TQUType_int;
+struct TQ_EXPORT TQUType_int : public TQUType
+{
+    const TQUuid *uuid() const;
+    const char *desc() const;
+
+    void set( TQUObject *, int );
+    int &get( TQUObject *o ) { return o->payload.i; }
+    bool canConvertFrom( TQUObject *, TQUType * );
+    bool canConvertTo( TQUObject *, TQUType * );
+    bool convertFrom( TQUObject *, TQUType * );
+    bool convertTo( TQUObject *, TQUType * );
+    void clear( TQUObject * ) {}
+    int serializeTo( TQUObject *, TQUBuffer * );
+    int serializeFrom( TQUObject *, TQUBuffer * );
+};
+extern TQ_EXPORT TQUType_int static_TQUType_int;
+
+
+// {2D0974E5-0BA6-4ec2-8837-C198972CB48C}
+extern TQ_EXPORT const TQUuid TID_TQUType_double;
+struct TQ_EXPORT TQUType_double : public TQUType
+{
+    const TQUuid *uuid() const;
+    const char *desc() const;
+
+    void set( TQUObject *, double );
+    double &get( TQUObject *o ) { return o->payload.d; }
+    bool canConvertFrom( TQUObject *, TQUType * );
+    bool canConvertTo( TQUObject *, TQUType * );
+    bool convertFrom( TQUObject *, TQUType * );
+    bool convertTo( TQUObject *, TQUType * );
+    void clear( TQUObject * ) {}
+    int serializeTo( TQUObject *, TQUBuffer * );
+    int serializeFrom( TQUObject *, TQUBuffer * );
+};
+extern TQ_EXPORT TQUType_double static_TQUType_double;
+
+
+// {EFCDD1D4-77A3-4b8e-8D46-DC14B8D393E9}
+extern TQ_EXPORT const TQUuid TID_TQUType_charstar;
+struct TQ_EXPORT TQUType_charstar : public TQUType
+{
+    const TQUuid *uuid() const;
+    const char *desc() const;
+
+    void set( TQUObject *, const char*, bool take = FALSE );
+    char* get( TQUObject *o ){ return o->payload.charstar.ptr; }
+    bool canConvertFrom( TQUObject *, TQUType * );
+    bool canConvertTo( TQUObject *, TQUType * );
+    bool convertFrom( TQUObject *, TQUType * );
+    bool convertTo( TQUObject *, TQUType * );
+    void clear( TQUObject * );
+    int serializeTo( TQUObject *, TQUBuffer * );
+    int serializeFrom( TQUObject *, TQUBuffer * );
+
+};
+extern TQ_EXPORT TQUType_charstar static_TQUType_charstar;
+
+// {44C2A547-01E7-4e56-8559-35AF9D2F42B7}
+extern const TQUuid TID_TQUType_TQString;
+
+struct TQ_EXPORT TQUType_TQString : public TQUType
+{
+    const TQUuid *uuid() const;
+    const char *desc() const;
+
+    void set( TQUObject *, const TQString & );
+    TQString &get( TQUObject * o ) { return *(TQString*)o->payload.ptr; }
+
+    bool canConvertFrom( TQUObject *, TQUType * );
+    bool canConvertTo( TQUObject *, TQUType * );
+    bool convertFrom( TQUObject *, TQUType * );
+    bool convertTo( TQUObject *, TQUType * );
+    void clear( TQUObject * );
+    int serializeTo( TQUObject *, TQUBuffer * );
+    int serializeFrom( TQUObject *, TQUBuffer * );
+
+};
+extern TQ_EXPORT TQUType_TQString static_TQUType_TQString;
+
+
+#endif // TQUCOM_P_H
diff --git a/tqtinterface/qt4/src/tools/tqunicodetables.cpp b/tqtinterface/qt4/src/tools/tqunicodetables.cpp
new file mode 100644
index 0000000..750dcd5
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqunicodetables.cpp
@@ -0,0 +1,13240 @@
+/****************************************************************************
+**
+** ???
+**
+** Copyright (C) 2002-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the kernel module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "tqunicodetables_p.h"
+
+/* -------------------------------------------------------------------------
+ * tqunicode information
+ * these tables are generated from the tqunicode reference file
+ * ftp://ftp.tqunicode.org/Public/3.2-Update/UnicodeData.txt
+ *
+ * Lars
+ * -------------------------------------------------------------------------
+ */
+
+/* Perl script to generate (run perl -x tools/qstringdata.cpp)
+
+#!perl
+
+sub numberize
+{
+    my(%r, $n, $id);
+    for $id ( @_ ) {
+      $i = $id;
+	$i="" if $i eq "EMPTY";
+	$r{$i}=$n++;
+    }
+    return %r;
+}
+
+
+sub readUnicodeDataLine {
+    $code = shift @_;
+    for $n (qw{
+	    name category combining_class bidi_category
+	    character_decomposition decimal_digit_value digit_value
+	    numeric_value mirrored oldname comment
+	    uppercase lowercase titlecase})
+    {
+	$id = shift @_;
+	$codes = "${n}_code";
+	if ( defined %$codes && defined $$codes{$id} ) {
+	    $id = $$codes{$id};
+	}
+	${$n}{$code}=$id;
+    }
+    $decomp = $character_decomposition{$code};
+    if ( length $decomp == 0 ) {
+	$decomp = "<single>";
+    }
+    if (substr($decomp, 0, 1) ne '<') {
+	$decomp = "<canonical> " . $decomp;
+    }
+    @_ = split(" ", $decomp);
+    $tag = shift @_;
+    $tag = $character_decomposition_tag{$tag};
+    $decomp = join( ", 0x", @_ );
+    $decomp = "0x".$decomp;
+    $decomposition{$code} = $decomp;
+    $decomposition_tag{$code} = $tag;
+    $decomposition_pos{$code} = $position;
+    $len = scalar(@_);
+    $decomposition_len{$code} = $len;
+
+#   we use canonical decompositions longer than 1 char
+#   we exlude Arabic ligatures from the table
+    if($len > 1 and $tag == 1) {
+#      ligature to add...
+	$start = shift @_;
+	$ligature{$start} = $ligature{$start}." ".$code;
+    }
+
+#   adjust position
+    if($len != 0) {
+	$position += $len + 3;
+    }
+}
+
+
+# Code to integer mappings...
+#
+%category_code = numberize(qw{
+      EMPTY
+      Mn Mc Me
+      Nd Nl No
+      Zs Zl Zp
+      Cc Cf Cs Co Cn
+
+      Lu Ll Lt Lm Lo
+      Pc Pd Ps Pe Pi Pf Po
+      Sm Sc Sk So
+});
+%bidi_category_code = numberize(qw{
+      L R EN ES ET AN CS B S WS ON LRE LRO AL RLE RLO PDF NSM BN});
+%character_decomposition_tag = numberize(qw{
+      <single> <canonical> <font> <noBreak> <initial> <medial>
+      <final> <isolated> <circle> <super> <sub> <vertical>
+      <wide> <narrow> <small> <square> <compat> <fraction>
+});
+%mirrored_code = numberize(qw{N Y});
+
+%joining_code = numberize(qw{U D R C});
+
+# we map AI and XX to AL for now, as we can't handle them any better
+%line_break_code = numberize(qw{OP CL QU GL NS EX SY
+				IS PR PO NU AL ID IN HY
+				BA BB B2
+				ZW CM
+				SA
+				BK CR LF SG CB SP
+});
+
+# Read data into hashes...
+#
+open IN, "UnicodeData.txt";
+$position = 1;
+while (<IN>) {
+    @fields = split /;/;
+    if ( length($fields[0]) < 5 ) {
+      if ( $fields[1] =~ /, First>/ ) {
+	$codeRangeBegin = $fields[0];
+      } elsif ( $fields[1] =~ /, Last>/ ) {
+	for ( $i=hex($codeRangeBegin); $i<=hex($fields[0]); $i+=1 ) {
+	  @fields2 = @fields;
+	  $fields2[0] = sprintf "%lX", $i;
+	  readUnicodeDataLine @fields2;
+	}
+      } else {
+	readUnicodeDataLine @fields;
+      }
+    }
+}
+
+open IN2, "ArabicShaping.txt";
+$position = 1;
+while (<IN2>) {
+    @fields = split /;/;
+    $code = shift @fields;
+    $dummy = shift @fields;
+    $join = shift @fields;
+    $join =~ s/ //g;
+    $join = $joining_code{$join};
+    $joining{$code}=$join;
+}
+
+open IN3, "LineBreak.txt";
+$position = 1;
+while (<IN3>) {
+    @fields = split /;/;
+    $code = shift @fields;
+    $break = shift @fields;
+    if (length($break) > 0) {
+      chomp $break;
+      $break =~ s/ .*$//;
+
+      $from = $code;
+      $to = $code;
+      if ( length($code) > 5 ) {
+	$from =~ s,\.\..*,,;
+	$to =~ s/......//;
+#      print "$from..$to = $break\n";
+      }
+      if($break eq "AI") {
+	$break = "AL";
+      }
+      if($break eq "XX") {
+	$break = "AL";
+      }
+      for ( $i=hex($from); $i<=hex($to); $i+=1 ) {
+	$breaks{sprintf("%04X",$i)}=$line_break_code{$break};
+      }
+    }
+}
+
+# Build pages...
+#
+$rowtable_txt = "";
+$row_txt = "";
+$pos = 1;
+for $row ( 0..255 ) {
+    $nonzero=0;
+    $txt = "";
+    for $cell ( 0..255 ) {
+	$code = sprintf("%02X%02X",$row,$cell);
+	$info = $category{$code};
+	$info = 0 if !defined $info;
+	$txt .= "\n    " if $cell%8 == 0;
+	$txt .= "$info, ";
+    }
+    $therow = $row{$txt};
+    if ( !defined $therow ) {
+	$therow = sprintf("%d",$pos);
+	$row_txt = $row_txt."$txt\n";
+	$row{$txt}=$therow;
+	$pos += 1;
+	$size += 256;
+    }
+    $rowtable_txt .= "\n    " if $row%8 == 0;
+    $rowtable_txt .= "$therow, ";
+}
+
+print "// START OF GENERATED DATA\n\n";
+print "#ifndef TQT_NO_UNICODETABLES\n\n";
+
+# Print pages...
+#
+
+print "const TQ_UINT8 TQUnicodeTables::tqunicode_info[] = {";
+print $rowtable_txt;
+$size += 256;
+print "\n\n";
+print $row_txt;
+print "};\n\n";
+print "// $size bytes\n\n";
+
+# Build decomposition tables
+#
+$rowtable_txt = "";
+$row_txt = "";
+$table_txt =
+    "const TQ_UINT16 TQUnicodeTables::decomposition_map[] = {\n    0,\n";
+$pos = 1;
+for $row ( 0..255 ) {
+    $nonzero=0;
+    $txt = "";
+    for $cell ( 0..255 ) {
+	$code = sprintf("%02X%02X",$row,$cell);
+	$txt .= "\n   " if $cell%8 == 0;
+	if( $decomposition_tag{$code} != 0 ) {
+	    $txt .= " $decomposition_pos{$code},";
+	    $table_txt .= "    $decomposition_tag{$code},";
+	    $table_txt .= " 0x$code,";
+	    $table_txt .= " $decomposition{$code}, 0,\n";
+	    $size += 2 * $decomposition_len{$code} + 6;
+	} else {
+	    $txt .= " 0,";
+	}
+    }
+    $therow = $row{$txt};
+    if ( !defined $therow ) {
+	$therow = sprintf("%d",$pos);
+	$row_txt = $row_txt."$txt\n";
+	$row{$txt}=$therow;
+	$pos += 1;
+	$size += 512;
+    }
+    $rowtable_txt .= "\n    " if $row%8 == 0;
+    $rowtable_txt .= "$therow, ";
+}
+
+# Print decomposition tables
+#
+print "$table_txt\n};\n\n";
+
+print "const TQ_UINT16 TQUnicodeTables::decomposition_info[] = {";
+print "$rowtable_txt\n";
+$size += 512;
+print $row_txt;
+print "};\n\n";
+print "// $size bytes\n\n";
+
+
+# build ligature tables
+#
+$size = 0;
+$position = 1;
+$pos = 1;
+$rowtable_txt = "";
+$row_txt = "";
+$table_txt =
+    "const TQ_UINT16 TQUnicodeTables::ligature_map[] = {\n    0,\n";
+for $lig_row ( 0..255 ) {
+    $nonzero=0;
+    $txt = "";
+    for $cell ( 0..255 ) {
+	$code = sprintf("%02X%02X",$lig_row,$cell);
+	$txt .= "\n   " if $cell%8 == 0;
+	if( defined $ligature{$code} ) {
+	    $txt .= " $position,";
+	    @ligature = split(" ", $ligature{$code});
+#           we need to sort ligatures according to their length.
+#           long ones have to come first!
+	    @ligature_sort = sort { $decomposition_len{$b} <=>  $decomposition_len{$a} } @ligature;
+#           now tqreplace each code by its position in
+#           the decomposition map.
+	    undef(@lig_pos);
+	    for $n (@ligature_sort) {
+		push(@lig_pos, $decomposition_pos{$n});
+	    }
+#           debug info
+	    if( 0 ) {
+		print "ligatures: $ligature{$code}\n";
+		$sort = join(" ", @ligature_sort);
+		print "sorted   : $sort\n";
+	    }
+	    $lig = join(", ", @lig_pos);
+	    $table_txt .= "    $lig, 0,\n";
+	    $size += 2 * scalar(@ligature) + 2;
+	    $position += scalar(@ligature) + 1;
+	} else {
+	    $txt .= " 0,";
+	}
+    }
+    $therow = $lig_row{$txt};
+    if ( !defined $therow ) {
+	$therow = sprintf("%d",$pos);
+	$row_txt = $row_txt."$txt\n";
+	$lig_row{$txt}=$therow;
+	$pos += 1;
+	$size += 512;
+    }
+    $rowtable_txt .= "\n    " if $lig_row%8 == 0;
+    $rowtable_txt .= "$therow, ";
+}
+
+# Print ligature tables
+#
+print "$table_txt\n};\n\n";
+print "const TQ_UINT16 TQUnicodeTables::ligature_info[] = {";
+print "$rowtable_txt\n\n";
+$size+=512;
+print $row_txt;
+print "};\n\n";
+print "// $size bytes\n\n";
+
+
+
+# Build direction/joining/mirrored pages...
+#
+$rowtable_txt = "";
+$row_txt = "";
+$pos = 1;
+for $dir_row ( 0..255 ) {
+    $txt = "";
+    for $cell ( 0..255 ) {
+	$code = sprintf("%02X%02X",$dir_row,$cell);
+	$dir = $bidi_category{$code};
+	$dir = 0 if !defined $dir;
+	$join = $joining{$code};
+	$join = 0 if !defined $join;
+	$mirr = $mirrored{$code};
+	$mirr = 0 if !defined $mirr;
+	$info = $dir + 32*$join + 128*$mirr;
+	$txt .= "\n    " if $cell%8 == 0;
+	$txt .= "$info, ";
+    }
+    $therow = $dir_row{$txt};
+    if ( !defined $therow ) {
+	$therow = sprintf("%d",$pos);
+	$row_txt = $row_txt."$txt\n";
+	$dir_row{$txt}=$therow;
+	$pos += 1;
+	$size+=256;
+    }
+    $rowtable_txt .= "\n    " if $dir_row%8 == 0;
+    $rowtable_txt .= "$therow, ";
+}
+
+# Print pages...
+#
+print "const TQ_UINT8 TQUnicodeTables::direction_info[] = {";
+print "$rowtable_txt\n\n";
+$size+=256;
+print $row_txt;
+print "};\n\n";
+print "// $size bytes\n\n";
+
+# Build table of combining classes
+#
+$rowtable_txt = "";
+$row_txt = "";
+$pos = 1;
+for $combining_row ( 0..255 ) {
+    $txt = "";
+    for $cell ( 0..255 ) {
+	$code = sprintf("%02X%02X",$combining_row,$cell);
+	$info = $combining_class{$code};
+	$info = 0 if !defined $info;
+	$txt .= "\n    " if $cell%8 == 0;
+	$txt .= "$info, ";
+    }
+    $therow = $combining_row{$txt};
+    if ( !defined $therow ) {
+	$therow = sprintf("%d",$pos);
+	$row_txt = $row_txt."$txt\n";
+	$combining_row{$txt}=$therow;
+	$pos += 1;
+	$size += 256;
+    }
+    $rowtable_txt .= "\n    " if $combining_row%8 == 0;
+    $rowtable_txt .= "$therow, ";
+}
+
+# Print pages...
+#
+print "const TQ_UINT8 TQUnicodeTables::combining_info[] = {";
+print "$rowtable_txt\n\n";
+$size+=256;
+print $row_txt;
+print "};\n\n";
+print "// $size bytes\n\n";
+
+# Build case info
+#
+$rowtable_txt = "";
+$row_txt = "";
+$pos = 1;
+for $row ( 0..255 ) {
+    $nonzero=0;
+    $txt = "";
+    for $cell ( 0..255 ) {
+	$code = sprintf("%02X%02X",$row,$cell);
+	$info = $uppercase{$code};
+	if ( length( $info ) eq 0 ) {
+	  $info = $lowercase{$code};
+	}
+	$info =~ s/^0+//;
+	if ( length( $info ) eq 0 ) {
+	  $info = "0";
+	} else {
+	  $info = "0x".lc($info);
+	}
+	if ( length( $info ) ne 1 ) {
+	  $nonzero = 1;
+	}
+	$txt .= "\n    " if $cell%8 == 0;
+	$txt .= "$info, ";
+    }
+    $therow = $case_row{$txt};
+    if ( !defined $therow && $nonzero ne 0 ) {
+	$therow = sprintf("%d",$pos);
+	$row_txt = $row_txt."$txt\n";
+	$case_row{$txt}=$therow;
+	$pos += 1;
+	$size += 512;
+    }
+    $rowtable_txt .= "\n    " if $row%8 == 0;
+    if ( $nonzero ne 0 ) {
+      $rowtable_txt .= "$therow, ";
+    } else {
+      $rowtable_txt .= "0, ";
+    }
+}
+
+# Print pages...
+#
+print "const TQ_UINT16 TQUnicodeTables::case_info[] = {";
+print "$rowtable_txt\n\n";
+$size+=512;
+print $row_txt;
+print "};\n";
+print "// $size bytes\n\n";
+
+# Build decimal info
+#
+$rowtable_txt = "";
+$row_txt = "";
+$pos = 1;
+for $row ( 0..255 ) {
+    $nonzero=0;
+    $txt = "";
+    for $cell ( 0..255 ) {
+	$code = sprintf("%02X%02X",$row,$cell);
+	$info = $digit_value{$code};
+	if ( length( $info ) eq 0 ) {
+	  $info = -1;
+	} else {
+	  $nonzero = 1;
+	}
+	$txt .= "\n    " if $cell%8 == 0;
+	$txt .= "$info, ";
+    }
+    $therow = $decimal_row{$txt};
+    if ( !defined $therow && $nonzero ne 0 ) {
+	$therow = sprintf("%d",$pos);
+	$row_txt = $row_txt."$txt\n";
+	$decimal_row{$txt}=$therow;
+	$pos += 1;
+	$size += 256;
+    }
+    $rowtable_txt .= "\n    " if $row%8 == 0;
+    if ( $nonzero ne 0 ) {
+      $rowtable_txt .= "$therow, ";
+    } else {
+      $rowtable_txt .= "0, ";
+    }
+}
+
+# Print pages...
+#
+print "const TQ_INT8 TQUnicodeTables::decimal_info[] = {";
+print "$rowtable_txt\n\n";
+$size+=512;
+print $row_txt;
+print "};\n";
+print "// $size bytes\n\n";
+
+
+# Build line break info
+#
+$rowtable_txt = "";
+$row_txt = "";
+$pos = 1;
+for $row ( 0..255 ) {
+    $txt = "";
+    for $cell ( 0..255 ) {
+	$code = sprintf("%02X%02X",$row,$cell);
+	$info = $breaks{$code};
+	if ( length( $info ) eq 0 ) {
+	  $info = $line_break_code{"AL"};
+	}
+	$txt .= "\n    " if $cell%8 == 0;
+	$txt .= "$info, ";
+    }
+    $therow = $lb_row{$txt};
+    if ( !defined $therow ) {
+	$therow = sprintf("%d",$pos);
+	$row_txt = $row_txt."$txt\n";
+	$lb_row{$txt}=$therow;
+	$pos += 1;
+	$size += 256;
+    }
+    $rowtable_txt .= "\n    " if $row%8 == 0;
+    $rowtable_txt .= "$therow, ";
+}
+
+# Print pages...
+#
+print "const TQ_UINT8 TQUnicodeTables::line_break_info[] = {";
+print "$rowtable_txt\n\n";
+$size+=512;
+print $row_txt;
+print "};\n";
+print "// $size bytes\n\n";
+
+
+
+print "#endif\n\n";
+print "// END OF GENERATED DATA\n\n";
+
+
+__END__
+
+*/
+
+// START OF GENERATED DATA
+
+#ifndef TQT_NO_UNICODETABLES
+
+const TQ_UINT8 TQUnicodeTables::tqunicode_info[] = {
+    1, 2, 3, 4, 5, 6, 7, 8,
+    9, 10, 11, 12, 13, 14, 15, 16,
+    17, 18, 19, 20, 21, 22, 23, 24,
+    25, 9, 9, 9, 9, 9, 26, 27,
+    28, 29, 30, 31, 32, 33, 34, 35,
+    36, 37, 30, 9, 9, 9, 38, 39,
+    40, 41, 42, 43, 22, 22, 22, 22,
+    22, 22, 22, 22, 22, 22, 22, 22,
+    22, 22, 22, 22, 22, 22, 22, 22,
+    22, 22, 22, 22, 22, 44, 22, 22,
+    22, 22, 22, 22, 22, 22, 22, 22,
+    22, 22, 22, 22, 22, 22, 22, 22,
+    22, 22, 22, 22, 22, 22, 22, 22,
+    22, 22, 22, 22, 22, 22, 22, 22,
+    22, 22, 22, 22, 22, 22, 22, 22,
+    22, 22, 22, 22, 22, 22, 22, 22,
+    22, 22, 22, 22, 22, 22, 22, 22,
+    22, 22, 22, 22, 22, 22, 22, 22,
+    22, 22, 22, 22, 22, 22, 22, 22,
+    22, 22, 22, 22, 22, 22, 22, 45,
+    22, 22, 22, 22, 46, 9, 9, 9,
+    9, 9, 9, 9, 22, 22, 22, 22,
+    22, 22, 22, 22, 22, 22, 22, 22,
+    22, 22, 22, 22, 22, 22, 22, 22,
+    22, 22, 22, 22, 22, 22, 22, 22,
+    22, 22, 22, 22, 22, 22, 22, 22,
+    22, 22, 22, 22, 22, 22, 22, 47,
+    48, 48, 48, 48, 48, 48, 48, 48,
+    49, 49, 49, 49, 49, 49, 49, 49,
+    49, 49, 49, 49, 49, 49, 49, 49,
+    49, 49, 49, 49, 49, 49, 49, 49,
+    49, 22, 50, 51, 22, 52, 53, 54,
+
+
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    7, 26, 26, 26, 28, 26, 26, 26,
+    22, 23, 26, 27, 26, 21, 26, 26,
+    4, 4, 4, 4, 4, 4, 4, 4,
+    4, 4, 26, 26, 27, 27, 27, 26,
+    26, 15, 15, 15, 15, 15, 15, 15,
+    15, 15, 15, 15, 15, 15, 15, 15,
+    15, 15, 15, 15, 15, 15, 15, 15,
+    15, 15, 15, 22, 26, 23, 29, 20,
+    29, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 22, 27, 23, 27, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    7, 26, 28, 28, 28, 28, 30, 30,
+    29, 30, 16, 24, 27, 21, 30, 29,
+    30, 27, 6, 6, 29, 16, 30, 26,
+    29, 6, 16, 25, 6, 6, 6, 26,
+    15, 15, 15, 15, 15, 15, 15, 15,
+    15, 15, 15, 15, 15, 15, 15, 15,
+    15, 15, 15, 15, 15, 15, 15, 27,
+    15, 15, 15, 15, 15, 15, 15, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 27,
+    16, 16, 16, 16, 16, 16, 16, 16,
+
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    16, 15, 16, 15, 16, 15, 16, 15,
+    16, 15, 16, 15, 16, 15, 16, 15,
+    16, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 15, 16, 15, 16, 15, 16, 16,
+    16, 15, 15, 16, 15, 16, 15, 15,
+    16, 15, 15, 15, 16, 16, 15, 15,
+    15, 15, 16, 15, 15, 16, 15, 15,
+    15, 16, 16, 16, 15, 15, 16, 15,
+    15, 16, 15, 16, 15, 16, 15, 15,
+    16, 15, 16, 16, 15, 16, 15, 15,
+    16, 15, 15, 15, 16, 15, 16, 15,
+    15, 16, 16, 19, 15, 16, 16, 16,
+    19, 19, 19, 19, 15, 17, 16, 15,
+    17, 16, 15, 17, 16, 15, 16, 15,
+    16, 15, 16, 15, 16, 15, 16, 15,
+    16, 15, 16, 15, 16, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    16, 15, 17, 16, 15, 16, 15, 15,
+    15, 16, 15, 16, 15, 16, 15, 16,
+
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 0, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 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,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 0, 0,
+    18, 18, 18, 18, 18, 18, 18, 18,
+    18, 29, 29, 18, 18, 18, 18, 18,
+    18, 18, 29, 29, 29, 29, 29, 29,
+    29, 29, 29, 29, 29, 29, 29, 29,
+    18, 18, 29, 29, 29, 29, 29, 29,
+    29, 29, 29, 29, 29, 29, 29, 29,
+    18, 18, 18, 18, 18, 29, 29, 29,
+    29, 29, 29, 29, 29, 29, 18, 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,
+    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,
+    0, 0, 0, 0, 29, 29, 0, 0,
+    0, 0, 18, 0, 0, 0, 26, 0,
+    0, 0, 0, 0, 29, 29, 15, 26,
+    15, 15, 15, 0, 15, 0, 15, 15,
+    16, 15, 15, 15, 15, 15, 15, 15,
+    15, 15, 15, 15, 15, 15, 15, 15,
+    15, 15, 0, 15, 15, 15, 15, 15,
+    15, 15, 15, 15, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 0,
+    16, 16, 15, 15, 15, 16, 16, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    16, 16, 16, 16, 15, 16, 27, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+
+    15, 15, 15, 15, 15, 15, 15, 15,
+    15, 15, 15, 15, 15, 15, 15, 15,
+    15, 15, 15, 15, 15, 15, 15, 15,
+    15, 15, 15, 15, 15, 15, 15, 15,
+    15, 15, 15, 15, 15, 15, 15, 15,
+    15, 15, 15, 15, 15, 15, 15, 15,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 30, 1, 1, 1, 1, 0,
+    3, 3, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 15, 16, 15, 16, 15, 16, 15,
+    16, 15, 16, 15, 16, 15, 16, 0,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 0, 0,
+    15, 16, 0, 0, 0, 0, 0, 0,
+
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    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, 15, 15, 15, 15, 15, 15, 15,
+    15, 15, 15, 15, 15, 15, 15, 15,
+    15, 15, 15, 15, 15, 15, 15, 15,
+    15, 15, 15, 15, 15, 15, 15, 15,
+    15, 15, 15, 15, 15, 15, 15, 0,
+    0, 18, 26, 26, 26, 26, 26, 26,
+    0, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    0, 26, 21, 0, 0, 0, 0, 0,
+    0, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 0, 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, 1, 1, 26, 1,
+    26, 1, 1, 26, 1, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 0, 0, 0, 0, 0,
+    19, 19, 19, 26, 26, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 26, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 26, 0, 0, 0, 26,
+    0, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 0, 0, 0, 0, 0,
+    18, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    4, 4, 4, 4, 4, 4, 4, 4,
+    4, 4, 26, 26, 26, 26, 19, 19,
+    1, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 26, 19, 1, 1,
+    1, 1, 1, 1, 1, 11, 3, 1,
+    1, 1, 1, 1, 1, 18, 18, 1,
+    1, 30, 1, 1, 1, 1, 0, 0,
+    4, 4, 4, 4, 4, 4, 4, 4,
+    4, 4, 19, 19, 19, 30, 30, 0,
+
+    26, 26, 26, 26, 26, 26, 26, 26,
+    26, 26, 26, 26, 26, 26, 0, 11,
+    19, 1, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 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, 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,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1,
+    1, 19, 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, 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,
+    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, 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, 2, 0, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 0, 0, 1, 19, 2, 2,
+    2, 1, 1, 1, 1, 1, 1, 1,
+    1, 2, 2, 2, 2, 1, 0, 0,
+    19, 1, 1, 1, 1, 0, 0, 0,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 1, 1, 26, 26, 4, 4,
+    4, 4, 4, 4, 4, 4, 4, 4,
+    26, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 1, 2, 2, 0, 19, 19, 19,
+    19, 19, 19, 19, 19, 0, 0, 19,
+    19, 0, 0, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 0, 19, 19, 19, 19, 19, 19,
+    19, 0, 19, 0, 0, 0, 19, 19,
+    19, 19, 0, 0, 1, 0, 2, 2,
+    2, 1, 1, 1, 1, 0, 0, 2,
+    2, 0, 0, 2, 2, 1, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 2,
+    0, 0, 0, 0, 19, 19, 0, 19,
+    19, 19, 1, 1, 0, 0, 4, 4,
+    4, 4, 4, 4, 4, 4, 4, 4,
+    19, 19, 28, 28, 6, 6, 6, 6,
+    6, 6, 30, 0, 0, 0, 0, 0,
+
+    0, 0, 1, 0, 0, 19, 19, 19,
+    19, 19, 19, 0, 0, 0, 0, 19,
+    19, 0, 0, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 0, 19, 19, 19, 19, 19, 19,
+    19, 0, 19, 19, 0, 19, 19, 0,
+    19, 19, 0, 0, 1, 0, 2, 2,
+    2, 1, 1, 0, 0, 0, 0, 1,
+    1, 0, 0, 1, 1, 1, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 19, 19, 19, 19, 0, 19, 0,
+    0, 0, 0, 0, 0, 0, 4, 4,
+    4, 4, 4, 4, 4, 4, 4, 4,
+    1, 1, 19, 19, 19, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 1, 1, 2, 0, 19, 19, 19,
+    19, 19, 19, 19, 0, 19, 0, 19,
+    19, 19, 0, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 0, 19, 19, 19, 19, 19, 19,
+    19, 0, 19, 19, 0, 19, 19, 19,
+    19, 19, 0, 0, 1, 19, 2, 2,
+    2, 1, 1, 1, 1, 1, 0, 1,
+    1, 2, 0, 2, 2, 1, 0, 0,
+    19, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    19, 0, 0, 0, 0, 0, 4, 4,
+    4, 4, 4, 4, 4, 4, 4, 4,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+
+    0, 1, 2, 2, 0, 19, 19, 19,
+    19, 19, 19, 19, 19, 0, 0, 19,
+    19, 0, 0, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 0, 19, 19, 19, 19, 19, 19,
+    19, 0, 19, 19, 0, 0, 19, 19,
+    19, 19, 0, 0, 1, 19, 2, 1,
+    2, 1, 1, 1, 0, 0, 0, 2,
+    2, 0, 0, 2, 2, 1, 0, 0,
+    0, 0, 0, 0, 0, 0, 1, 2,
+    0, 0, 0, 0, 19, 19, 0, 19,
+    19, 19, 0, 0, 0, 0, 4, 4,
+    4, 4, 4, 4, 4, 4, 4, 4,
+    30, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 1, 19, 0, 19, 19, 19,
+    19, 19, 19, 0, 0, 0, 19, 19,
+    19, 0, 19, 19, 19, 19, 0, 0,
+    0, 19, 19, 0, 19, 0, 19, 19,
+    0, 0, 0, 19, 19, 0, 0, 0,
+    19, 19, 19, 0, 0, 0, 19, 19,
+    19, 19, 19, 19, 19, 19, 0, 19,
+    19, 19, 0, 0, 0, 0, 2, 2,
+    1, 2, 2, 0, 0, 0, 2, 2,
+    2, 0, 2, 2, 2, 1, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 2,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 4,
+    4, 4, 4, 4, 4, 4, 4, 4,
+    6, 6, 6, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+
+    0, 2, 2, 2, 0, 19, 19, 19,
+    19, 19, 19, 19, 19, 0, 19, 19,
+    19, 0, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 0, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 0, 19, 19, 19,
+    19, 19, 0, 0, 0, 0, 1, 1,
+    1, 2, 2, 2, 2, 0, 1, 1,
+    1, 0, 1, 1, 1, 1, 0, 0,
+    0, 0, 0, 0, 0, 1, 1, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    19, 19, 0, 0, 0, 0, 4, 4,
+    4, 4, 4, 4, 4, 4, 4, 4,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 2, 2, 0, 19, 19, 19,
+    19, 19, 19, 19, 19, 0, 19, 19,
+    19, 0, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 0, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 0, 19, 19, 19,
+    19, 19, 0, 0, 0, 0, 2, 1,
+    2, 2, 2, 2, 2, 0, 1, 2,
+    2, 0, 2, 2, 1, 1, 0, 0,
+    0, 0, 0, 0, 0, 2, 2, 0,
+    0, 0, 0, 0, 0, 0, 19, 0,
+    19, 19, 0, 0, 0, 0, 4, 4,
+    4, 4, 4, 4, 4, 4, 4, 4,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+
+    0, 0, 2, 2, 0, 19, 19, 19,
+    19, 19, 19, 19, 19, 0, 19, 19,
+    19, 0, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 0, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 0, 0, 0, 0, 2, 2,
+    2, 1, 1, 1, 0, 0, 2, 2,
+    2, 0, 2, 2, 2, 1, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 2,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    19, 19, 0, 0, 0, 0, 4, 4,
+    4, 4, 4, 4, 4, 4, 4, 4,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 2, 2, 0, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 0,
+    0, 0, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 0, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 0, 19, 0, 0,
+    19, 19, 19, 19, 19, 19, 19, 0,
+    0, 0, 1, 0, 0, 0, 0, 2,
+    2, 2, 1, 1, 1, 0, 1, 0,
+    2, 2, 2, 2, 2, 2, 2, 2,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 2, 2, 26, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+
+    0, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 1, 19, 19, 1, 1, 1, 1,
+    1, 1, 1, 0, 0, 0, 0, 28,
+    19, 19, 19, 19, 19, 19, 18, 1,
+    1, 1, 1, 1, 1, 1, 1, 26,
+    4, 4, 4, 4, 4, 4, 4, 4,
+    4, 4, 26, 26, 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, 19, 19, 0, 19, 0, 0, 19,
+    19, 0, 19, 0, 0, 19, 0, 0,
+    0, 0, 0, 0, 19, 19, 19, 19,
+    0, 19, 19, 19, 19, 19, 19, 19,
+    0, 19, 19, 19, 0, 19, 0, 19,
+    0, 0, 19, 19, 0, 19, 19, 19,
+    19, 1, 19, 19, 1, 1, 1, 1,
+    1, 1, 0, 1, 1, 19, 0, 0,
+    19, 19, 19, 19, 19, 0, 18, 0,
+    1, 1, 1, 1, 1, 1, 0, 0,
+    4, 4, 4, 4, 4, 4, 4, 4,
+    4, 4, 0, 0, 19, 19, 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,
+
+    19, 30, 30, 30, 26, 26, 26, 26,
+    26, 26, 26, 26, 26, 26, 26, 26,
+    26, 26, 26, 30, 30, 30, 30, 30,
+    1, 1, 30, 30, 30, 30, 30, 30,
+    4, 4, 4, 4, 4, 4, 4, 4,
+    4, 4, 6, 6, 6, 6, 6, 6,
+    6, 6, 6, 6, 30, 1, 30, 1,
+    30, 1, 22, 23, 22, 23, 2, 2,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    0, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 0, 0, 0, 0, 0,
+    0, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 2,
+    1, 1, 1, 1, 1, 26, 1, 1,
+    19, 19, 19, 19, 0, 0, 0, 0,
+    1, 1, 1, 1, 1, 1, 1, 1,
+    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, 0, 30, 30,
+    30, 30, 30, 30, 30, 30, 1, 30,
+    30, 30, 30, 30, 30, 0, 0, 30,
+    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,
+
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 0, 19, 19, 19, 19, 19,
+    0, 19, 19, 0, 2, 1, 1, 1,
+    1, 2, 1, 0, 0, 0, 1, 1,
+    2, 1, 0, 0, 0, 0, 0, 0,
+    4, 4, 4, 4, 4, 4, 4, 4,
+    4, 4, 26, 26, 26, 26, 26, 26,
+    19, 19, 19, 19, 19, 19, 2, 2,
+    1, 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,
+    15, 15, 15, 15, 15, 15, 15, 15,
+    15, 15, 15, 15, 15, 15, 15, 15,
+    15, 15, 15, 15, 15, 15, 15, 15,
+    15, 15, 15, 15, 15, 15, 15, 15,
+    15, 15, 15, 15, 15, 15, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 0, 0, 26, 0, 0, 0, 0,
+
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 0, 0, 0, 0, 0, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 0, 0, 0, 0, 0,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 0, 0, 0, 0, 0, 0,
+
+    19, 19, 19, 19, 19, 19, 19, 0,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 0,
+    19, 0, 19, 19, 19, 19, 0, 0,
+    19, 19, 19, 19, 19, 19, 19, 0,
+    19, 0, 19, 19, 19, 19, 0, 0,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 0,
+    19, 0, 19, 19, 19, 19, 0, 0,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 0,
+    19, 0, 19, 19, 19, 19, 0, 0,
+    19, 19, 19, 19, 19, 19, 19, 0,
+    19, 0, 19, 19, 19, 19, 0, 0,
+    19, 19, 19, 19, 19, 19, 19, 0,
+    19, 19, 19, 19, 19, 19, 19, 0,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 0,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 0,
+    19, 0, 19, 19, 19, 19, 0, 0,
+    19, 19, 19, 19, 19, 19, 19, 0,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 0,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 0, 0, 0, 0, 0,
+    0, 26, 26, 26, 26, 26, 26, 26,
+    26, 4, 4, 4, 4, 4, 4, 4,
+    4, 4, 6, 6, 6, 6, 6, 6,
+    6, 6, 6, 6, 6, 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,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+
+    0, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 26, 26, 19,
+    19, 19, 19, 19, 19, 19, 19, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    7, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 22, 23, 0, 0, 0,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 26, 26, 26, 5, 5,
+    5, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 0, 19, 19,
+    19, 19, 1, 1, 1, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 1, 1, 1, 26, 26, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 1, 1, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 0, 19, 19,
+    19, 0, 1, 1, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 2, 2, 2, 1,
+    1, 1, 1, 1, 1, 1, 2, 2,
+    2, 2, 2, 2, 2, 2, 1, 2,
+    2, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 26, 26, 26, 18,
+    26, 26, 26, 28, 19, 0, 0, 0,
+    4, 4, 4, 4, 4, 4, 4, 4,
+    4, 4, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+
+    26, 26, 26, 26, 26, 26, 21, 26,
+    26, 26, 26, 1, 1, 1, 11, 0,
+    4, 4, 4, 4, 4, 4, 4, 4,
+    4, 4, 0, 0, 0, 0, 0, 0,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 18, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 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,
+
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 16, 16,
+    16, 16, 16, 16, 0, 0, 0, 0,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 15, 16, 15, 16, 15, 16,
+    15, 16, 0, 0, 0, 0, 0, 0,
+
+    16, 16, 16, 16, 16, 16, 16, 16,
+    15, 15, 15, 15, 15, 15, 15, 15,
+    16, 16, 16, 16, 16, 16, 0, 0,
+    15, 15, 15, 15, 15, 15, 0, 0,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    15, 15, 15, 15, 15, 15, 15, 15,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    15, 15, 15, 15, 15, 15, 15, 15,
+    16, 16, 16, 16, 16, 16, 0, 0,
+    15, 15, 15, 15, 15, 15, 0, 0,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    0, 15, 0, 15, 0, 15, 0, 15,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    15, 15, 15, 15, 15, 15, 15, 15,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 0, 0,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    17, 17, 17, 17, 17, 17, 17, 17,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    17, 17, 17, 17, 17, 17, 17, 17,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    17, 17, 17, 17, 17, 17, 17, 17,
+    16, 16, 16, 16, 16, 0, 16, 16,
+    15, 15, 15, 15, 17, 29, 16, 29,
+    29, 29, 16, 16, 16, 0, 16, 16,
+    15, 15, 15, 15, 17, 29, 29, 29,
+    16, 16, 16, 16, 0, 0, 16, 16,
+    15, 15, 15, 15, 0, 29, 29, 29,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    15, 15, 15, 15, 15, 29, 29, 29,
+    0, 0, 16, 16, 16, 0, 16, 16,
+    15, 15, 15, 15, 17, 29, 29, 0,
+
+    7, 7, 7, 7, 7, 7, 7, 7,
+    7, 7, 7, 7, 11, 11, 11, 11,
+    21, 21, 21, 21, 21, 21, 26, 26,
+    24, 25, 22, 24, 24, 25, 22, 24,
+    26, 26, 26, 26, 26, 26, 26, 26,
+    8, 9, 11, 11, 11, 11, 11, 7,
+    26, 26, 26, 26, 26, 26, 26, 26,
+    26, 24, 25, 26, 26, 26, 26, 20,
+    20, 26, 26, 26, 27, 22, 23, 26,
+    26, 26, 26, 26, 26, 26, 26, 26,
+    26, 26, 27, 0, 0, 0, 0, 26,
+    0, 0, 0, 0, 0, 0, 0, 7,
+    11, 11, 11, 11, 0, 0, 0, 0,
+    0, 0, 11, 11, 11, 11, 11, 11,
+    6, 16, 0, 0, 6, 6, 6, 6,
+    6, 6, 27, 27, 27, 22, 23, 16,
+    6, 6, 6, 6, 6, 6, 6, 6,
+    6, 6, 27, 27, 27, 22, 23, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    28, 28, 28, 28, 28, 28, 28, 28,
+    28, 28, 28, 28, 28, 28, 28, 28,
+    28, 28, 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, 3, 3, 3,
+    3, 1, 3, 3, 3, 1, 1, 1,
+    1, 1, 1, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+
+    30, 30, 15, 30, 30, 30, 30, 15,
+    30, 30, 16, 15, 15, 15, 16, 16,
+    15, 15, 15, 16, 30, 15, 30, 30,
+    30, 15, 15, 15, 15, 15, 30, 30,
+    30, 30, 30, 30, 15, 30, 15, 30,
+    15, 30, 15, 15, 15, 15, 30, 16,
+    15, 15, 30, 15, 16, 19, 19, 19,
+    19, 16, 30, 0, 0, 16, 15, 15,
+    27, 27, 27, 27, 27, 15, 16, 16,
+    16, 16, 30, 27, 0, 0, 0, 0,
+    0, 0, 0, 6, 6, 6, 6, 6,
+    6, 6, 6, 6, 6, 6, 6, 6,
+    5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    27, 27, 27, 27, 27, 30, 30, 30,
+    30, 30, 27, 27, 30, 30, 30, 30,
+    27, 30, 30, 27, 30, 30, 27, 30,
+    30, 30, 30, 30, 30, 30, 27, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 27, 27,
+    30, 30, 27, 30, 27, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+
+    30, 30, 30, 30, 30, 30, 30, 30,
+    27, 27, 27, 27, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    27, 27, 30, 30, 30, 30, 30, 30,
+    30, 22, 23, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 27, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 22, 23, 26, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 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,
+
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 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,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    6, 6, 6, 6, 6, 6, 6, 6,
+    6, 6, 6, 6, 6, 6, 6, 6,
+    6, 6, 6, 6, 6, 6, 6, 6,
+    6, 6, 6, 6, 6, 6, 6, 6,
+    6, 6, 6, 6, 6, 6, 6, 6,
+    6, 6, 6, 6, 6, 6, 6, 6,
+    6, 6, 6, 6, 6, 6, 6, 6,
+    6, 6, 6, 6, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 6, 6, 6, 6, 6, 6,
+    6, 6, 6, 6, 6, 6, 6, 6,
+    6, 6, 6, 6, 6, 6, 6, 0,
+
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 27,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 27, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    27, 27, 27, 27, 27, 27, 27, 27,
+
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 0, 0, 30, 30,
+    0, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 27,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 0, 0,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 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, 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, 30, 30, 30, 30, 0, 30, 30,
+    30, 30, 0, 0, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    0, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 0, 30, 0, 30,
+    30, 30, 30, 0, 0, 0, 30, 0,
+    30, 30, 30, 30, 30, 30, 30, 0,
+    0, 30, 30, 30, 30, 30, 30, 30,
+    22, 23, 22, 23, 22, 23, 22, 23,
+    22, 23, 22, 23, 22, 23, 6, 6,
+    6, 6, 6, 6, 6, 6, 6, 6,
+    6, 6, 6, 6, 6, 6, 6, 6,
+    6, 6, 6, 6, 6, 6, 6, 6,
+    6, 6, 6, 6, 30, 0, 0, 0,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    0, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 22, 23,
+    22, 23, 22, 23, 0, 0, 0, 0,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 22, 23, 22, 23, 22,
+    23, 22, 23, 22, 23, 22, 23, 22,
+    23, 22, 23, 22, 23, 22, 23, 22,
+    23, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    22, 23, 22, 23, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 22, 23, 27, 27,
+
+    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, 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,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 0, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 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,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 0, 0, 0, 0,
+
+    7, 26, 26, 26, 30, 18, 19, 5,
+    22, 23, 22, 23, 22, 23, 22, 23,
+    22, 23, 30, 30, 22, 23, 22, 23,
+    22, 23, 22, 23, 21, 22, 23, 23,
+    30, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 1, 1, 1, 1, 1, 1,
+    21, 18, 18, 18, 18, 18, 30, 30,
+    5, 5, 5, 18, 19, 26, 30, 30,
+    0, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 0,
+    0, 1, 1, 29, 29, 18, 18, 19,
+    21, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 20, 18, 18, 18, 19,
+
+    0, 0, 0, 0, 0, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 0, 0, 0,
+    0, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 0,
+    30, 30, 6, 6, 6, 6, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    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,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 0, 0, 0,
+    6, 6, 6, 6, 6, 6, 6, 6,
+    6, 6, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 6, 6, 6, 6, 6, 6, 6,
+    6, 6, 6, 6, 6, 6, 6, 6,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 0, 0, 0, 30,
+    6, 6, 6, 6, 6, 6, 6, 6,
+    6, 6, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 6, 6, 6, 6, 6, 6, 6,
+    6, 6, 6, 6, 6, 6, 6, 6,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 0, 0, 0, 0,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 0,
+
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 0,
+    0, 0, 0, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 0, 0,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 0,
+
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 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,
+
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 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, 0, 0, 0,
+
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 0, 0, 0,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 30,
+    30, 30, 30, 30, 30, 30, 30, 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,
+
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 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, 0, 0, 0, 0, 0,
+
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 0, 0,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 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, 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,
+
+    16, 16, 16, 16, 16, 16, 16, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 16, 16, 16, 16, 16,
+    0, 0, 0, 0, 0, 19, 1, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 27, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 0,
+    19, 19, 19, 19, 19, 0, 19, 0,
+    19, 19, 0, 19, 19, 0, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 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, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 22, 23,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    0, 0, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    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,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 28, 0, 0, 0,
+
+    1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    1, 1, 1, 1, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    26, 21, 21, 20, 20, 22, 23, 22,
+    23, 22, 23, 22, 23, 22, 23, 22,
+    23, 22, 23, 22, 23, 26, 26, 0,
+    0, 26, 26, 26, 26, 20, 20, 20,
+    26, 26, 26, 0, 26, 26, 26, 26,
+    21, 22, 23, 22, 23, 22, 23, 26,
+    26, 26, 27, 21, 27, 27, 27, 0,
+    26, 28, 26, 26, 0, 0, 0, 0,
+    19, 19, 19, 19, 19, 0, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 0, 0, 11,
+
+    0, 26, 26, 26, 28, 26, 26, 26,
+    22, 23, 26, 27, 26, 21, 26, 26,
+    4, 4, 4, 4, 4, 4, 4, 4,
+    4, 4, 26, 26, 27, 27, 27, 26,
+    26, 15, 15, 15, 15, 15, 15, 15,
+    15, 15, 15, 15, 15, 15, 15, 15,
+    15, 15, 15, 15, 15, 15, 15, 15,
+    15, 15, 15, 22, 26, 23, 29, 20,
+    29, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 22, 27, 23, 27, 22,
+    23, 26, 22, 23, 26, 20, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    18, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 18, 18,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 0,
+    0, 0, 19, 19, 19, 19, 19, 19,
+    0, 0, 19, 19, 19, 19, 19, 19,
+    0, 0, 19, 19, 19, 19, 19, 19,
+    0, 0, 19, 19, 19, 0, 0, 0,
+    28, 28, 27, 29, 30, 28, 28, 0,
+    30, 27, 27, 27, 27, 30, 30, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 11, 11, 11, 30, 30, 0, 0,
+};
+
+// 14080 bytes
+
+const TQ_UINT16 TQUnicodeTables::decomposition_map[] = {
+    0,
+    3, 0x00A0, 0x0020, 0,
+    16, 0x00A8, 0x0020, 0x0308, 0,
+    9, 0x00AA, 0x0061, 0,
+    16, 0x00AF, 0x0020, 0x0304, 0,
+    9, 0x00B2, 0x0032, 0,
+    9, 0x00B3, 0x0033, 0,
+    16, 0x00B4, 0x0020, 0x0301, 0,
+    16, 0x00B5, 0x03BC, 0,
+    16, 0x00B8, 0x0020, 0x0327, 0,
+    9, 0x00B9, 0x0031, 0,
+    9, 0x00BA, 0x006F, 0,
+    17, 0x00BC, 0x0031, 0x2044, 0x0034, 0,
+    17, 0x00BD, 0x0031, 0x2044, 0x0032, 0,
+    17, 0x00BE, 0x0033, 0x2044, 0x0034, 0,
+    1, 0x00C0, 0x0041, 0x0300, 0,
+    1, 0x00C1, 0x0041, 0x0301, 0,
+    1, 0x00C2, 0x0041, 0x0302, 0,
+    1, 0x00C3, 0x0041, 0x0303, 0,
+    1, 0x00C4, 0x0041, 0x0308, 0,
+    1, 0x00C5, 0x0041, 0x030A, 0,
+    1, 0x00C7, 0x0043, 0x0327, 0,
+    1, 0x00C8, 0x0045, 0x0300, 0,
+    1, 0x00C9, 0x0045, 0x0301, 0,
+    1, 0x00CA, 0x0045, 0x0302, 0,
+    1, 0x00CB, 0x0045, 0x0308, 0,
+    1, 0x00CC, 0x0049, 0x0300, 0,
+    1, 0x00CD, 0x0049, 0x0301, 0,
+    1, 0x00CE, 0x0049, 0x0302, 0,
+    1, 0x00CF, 0x0049, 0x0308, 0,
+    1, 0x00D1, 0x004E, 0x0303, 0,
+    1, 0x00D2, 0x004F, 0x0300, 0,
+    1, 0x00D3, 0x004F, 0x0301, 0,
+    1, 0x00D4, 0x004F, 0x0302, 0,
+    1, 0x00D5, 0x004F, 0x0303, 0,
+    1, 0x00D6, 0x004F, 0x0308, 0,
+    1, 0x00D9, 0x0055, 0x0300, 0,
+    1, 0x00DA, 0x0055, 0x0301, 0,
+    1, 0x00DB, 0x0055, 0x0302, 0,
+    1, 0x00DC, 0x0055, 0x0308, 0,
+    1, 0x00DD, 0x0059, 0x0301, 0,
+    1, 0x00E0, 0x0061, 0x0300, 0,
+    1, 0x00E1, 0x0061, 0x0301, 0,
+    1, 0x00E2, 0x0061, 0x0302, 0,
+    1, 0x00E3, 0x0061, 0x0303, 0,
+    1, 0x00E4, 0x0061, 0x0308, 0,
+    1, 0x00E5, 0x0061, 0x030A, 0,
+    1, 0x00E7, 0x0063, 0x0327, 0,
+    1, 0x00E8, 0x0065, 0x0300, 0,
+    1, 0x00E9, 0x0065, 0x0301, 0,
+    1, 0x00EA, 0x0065, 0x0302, 0,
+    1, 0x00EB, 0x0065, 0x0308, 0,
+    1, 0x00EC, 0x0069, 0x0300, 0,
+    1, 0x00ED, 0x0069, 0x0301, 0,
+    1, 0x00EE, 0x0069, 0x0302, 0,
+    1, 0x00EF, 0x0069, 0x0308, 0,
+    1, 0x00F1, 0x006E, 0x0303, 0,
+    1, 0x00F2, 0x006F, 0x0300, 0,
+    1, 0x00F3, 0x006F, 0x0301, 0,
+    1, 0x00F4, 0x006F, 0x0302, 0,
+    1, 0x00F5, 0x006F, 0x0303, 0,
+    1, 0x00F6, 0x006F, 0x0308, 0,
+    1, 0x00F9, 0x0075, 0x0300, 0,
+    1, 0x00FA, 0x0075, 0x0301, 0,
+    1, 0x00FB, 0x0075, 0x0302, 0,
+    1, 0x00FC, 0x0075, 0x0308, 0,
+    1, 0x00FD, 0x0079, 0x0301, 0,
+    1, 0x00FF, 0x0079, 0x0308, 0,
+    1, 0x0100, 0x0041, 0x0304, 0,
+    1, 0x0101, 0x0061, 0x0304, 0,
+    1, 0x0102, 0x0041, 0x0306, 0,
+    1, 0x0103, 0x0061, 0x0306, 0,
+    1, 0x0104, 0x0041, 0x0328, 0,
+    1, 0x0105, 0x0061, 0x0328, 0,
+    1, 0x0106, 0x0043, 0x0301, 0,
+    1, 0x0107, 0x0063, 0x0301, 0,
+    1, 0x0108, 0x0043, 0x0302, 0,
+    1, 0x0109, 0x0063, 0x0302, 0,
+    1, 0x010A, 0x0043, 0x0307, 0,
+    1, 0x010B, 0x0063, 0x0307, 0,
+    1, 0x010C, 0x0043, 0x030C, 0,
+    1, 0x010D, 0x0063, 0x030C, 0,
+    1, 0x010E, 0x0044, 0x030C, 0,
+    1, 0x010F, 0x0064, 0x030C, 0,
+    1, 0x0112, 0x0045, 0x0304, 0,
+    1, 0x0113, 0x0065, 0x0304, 0,
+    1, 0x0114, 0x0045, 0x0306, 0,
+    1, 0x0115, 0x0065, 0x0306, 0,
+    1, 0x0116, 0x0045, 0x0307, 0,
+    1, 0x0117, 0x0065, 0x0307, 0,
+    1, 0x0118, 0x0045, 0x0328, 0,
+    1, 0x0119, 0x0065, 0x0328, 0,
+    1, 0x011A, 0x0045, 0x030C, 0,
+    1, 0x011B, 0x0065, 0x030C, 0,
+    1, 0x011C, 0x0047, 0x0302, 0,
+    1, 0x011D, 0x0067, 0x0302, 0,
+    1, 0x011E, 0x0047, 0x0306, 0,
+    1, 0x011F, 0x0067, 0x0306, 0,
+    1, 0x0120, 0x0047, 0x0307, 0,
+    1, 0x0121, 0x0067, 0x0307, 0,
+    1, 0x0122, 0x0047, 0x0327, 0,
+    1, 0x0123, 0x0067, 0x0327, 0,
+    1, 0x0124, 0x0048, 0x0302, 0,
+    1, 0x0125, 0x0068, 0x0302, 0,
+    1, 0x0128, 0x0049, 0x0303, 0,
+    1, 0x0129, 0x0069, 0x0303, 0,
+    1, 0x012A, 0x0049, 0x0304, 0,
+    1, 0x012B, 0x0069, 0x0304, 0,
+    1, 0x012C, 0x0049, 0x0306, 0,
+    1, 0x012D, 0x0069, 0x0306, 0,
+    1, 0x012E, 0x0049, 0x0328, 0,
+    1, 0x012F, 0x0069, 0x0328, 0,
+    1, 0x0130, 0x0049, 0x0307, 0,
+    16, 0x0132, 0x0049, 0x004A, 0,
+    16, 0x0133, 0x0069, 0x006A, 0,
+    1, 0x0134, 0x004A, 0x0302, 0,
+    1, 0x0135, 0x006A, 0x0302, 0,
+    1, 0x0136, 0x004B, 0x0327, 0,
+    1, 0x0137, 0x006B, 0x0327, 0,
+    1, 0x0139, 0x004C, 0x0301, 0,
+    1, 0x013A, 0x006C, 0x0301, 0,
+    1, 0x013B, 0x004C, 0x0327, 0,
+    1, 0x013C, 0x006C, 0x0327, 0,
+    1, 0x013D, 0x004C, 0x030C, 0,
+    1, 0x013E, 0x006C, 0x030C, 0,
+    16, 0x013F, 0x004C, 0x00B7, 0,
+    16, 0x0140, 0x006C, 0x00B7, 0,
+    1, 0x0143, 0x004E, 0x0301, 0,
+    1, 0x0144, 0x006E, 0x0301, 0,
+    1, 0x0145, 0x004E, 0x0327, 0,
+    1, 0x0146, 0x006E, 0x0327, 0,
+    1, 0x0147, 0x004E, 0x030C, 0,
+    1, 0x0148, 0x006E, 0x030C, 0,
+    16, 0x0149, 0x02BC, 0x006E, 0,
+    1, 0x014C, 0x004F, 0x0304, 0,
+    1, 0x014D, 0x006F, 0x0304, 0,
+    1, 0x014E, 0x004F, 0x0306, 0,
+    1, 0x014F, 0x006F, 0x0306, 0,
+    1, 0x0150, 0x004F, 0x030B, 0,
+    1, 0x0151, 0x006F, 0x030B, 0,
+    1, 0x0154, 0x0052, 0x0301, 0,
+    1, 0x0155, 0x0072, 0x0301, 0,
+    1, 0x0156, 0x0052, 0x0327, 0,
+    1, 0x0157, 0x0072, 0x0327, 0,
+    1, 0x0158, 0x0052, 0x030C, 0,
+    1, 0x0159, 0x0072, 0x030C, 0,
+    1, 0x015A, 0x0053, 0x0301, 0,
+    1, 0x015B, 0x0073, 0x0301, 0,
+    1, 0x015C, 0x0053, 0x0302, 0,
+    1, 0x015D, 0x0073, 0x0302, 0,
+    1, 0x015E, 0x0053, 0x0327, 0,
+    1, 0x015F, 0x0073, 0x0327, 0,
+    1, 0x0160, 0x0053, 0x030C, 0,
+    1, 0x0161, 0x0073, 0x030C, 0,
+    1, 0x0162, 0x0054, 0x0327, 0,
+    1, 0x0163, 0x0074, 0x0327, 0,
+    1, 0x0164, 0x0054, 0x030C, 0,
+    1, 0x0165, 0x0074, 0x030C, 0,
+    1, 0x0168, 0x0055, 0x0303, 0,
+    1, 0x0169, 0x0075, 0x0303, 0,
+    1, 0x016A, 0x0055, 0x0304, 0,
+    1, 0x016B, 0x0075, 0x0304, 0,
+    1, 0x016C, 0x0055, 0x0306, 0,
+    1, 0x016D, 0x0075, 0x0306, 0,
+    1, 0x016E, 0x0055, 0x030A, 0,
+    1, 0x016F, 0x0075, 0x030A, 0,
+    1, 0x0170, 0x0055, 0x030B, 0,
+    1, 0x0171, 0x0075, 0x030B, 0,
+    1, 0x0172, 0x0055, 0x0328, 0,
+    1, 0x0173, 0x0075, 0x0328, 0,
+    1, 0x0174, 0x0057, 0x0302, 0,
+    1, 0x0175, 0x0077, 0x0302, 0,
+    1, 0x0176, 0x0059, 0x0302, 0,
+    1, 0x0177, 0x0079, 0x0302, 0,
+    1, 0x0178, 0x0059, 0x0308, 0,
+    1, 0x0179, 0x005A, 0x0301, 0,
+    1, 0x017A, 0x007A, 0x0301, 0,
+    1, 0x017B, 0x005A, 0x0307, 0,
+    1, 0x017C, 0x007A, 0x0307, 0,
+    1, 0x017D, 0x005A, 0x030C, 0,
+    1, 0x017E, 0x007A, 0x030C, 0,
+    16, 0x017F, 0x0073, 0,
+    1, 0x01A0, 0x004F, 0x031B, 0,
+    1, 0x01A1, 0x006F, 0x031B, 0,
+    1, 0x01AF, 0x0055, 0x031B, 0,
+    1, 0x01B0, 0x0075, 0x031B, 0,
+    16, 0x01C4, 0x0044, 0x017D, 0,
+    16, 0x01C5, 0x0044, 0x017E, 0,
+    16, 0x01C6, 0x0064, 0x017E, 0,
+    16, 0x01C7, 0x004C, 0x004A, 0,
+    16, 0x01C8, 0x004C, 0x006A, 0,
+    16, 0x01C9, 0x006C, 0x006A, 0,
+    16, 0x01CA, 0x004E, 0x004A, 0,
+    16, 0x01CB, 0x004E, 0x006A, 0,
+    16, 0x01CC, 0x006E, 0x006A, 0,
+    1, 0x01CD, 0x0041, 0x030C, 0,
+    1, 0x01CE, 0x0061, 0x030C, 0,
+    1, 0x01CF, 0x0049, 0x030C, 0,
+    1, 0x01D0, 0x0069, 0x030C, 0,
+    1, 0x01D1, 0x004F, 0x030C, 0,
+    1, 0x01D2, 0x006F, 0x030C, 0,
+    1, 0x01D3, 0x0055, 0x030C, 0,
+    1, 0x01D4, 0x0075, 0x030C, 0,
+    1, 0x01D5, 0x00DC, 0x0304, 0,
+    1, 0x01D6, 0x00FC, 0x0304, 0,
+    1, 0x01D7, 0x00DC, 0x0301, 0,
+    1, 0x01D8, 0x00FC, 0x0301, 0,
+    1, 0x01D9, 0x00DC, 0x030C, 0,
+    1, 0x01DA, 0x00FC, 0x030C, 0,
+    1, 0x01DB, 0x00DC, 0x0300, 0,
+    1, 0x01DC, 0x00FC, 0x0300, 0,
+    1, 0x01DE, 0x00C4, 0x0304, 0,
+    1, 0x01DF, 0x00E4, 0x0304, 0,
+    1, 0x01E0, 0x0226, 0x0304, 0,
+    1, 0x01E1, 0x0227, 0x0304, 0,
+    1, 0x01E2, 0x00C6, 0x0304, 0,
+    1, 0x01E3, 0x00E6, 0x0304, 0,
+    1, 0x01E6, 0x0047, 0x030C, 0,
+    1, 0x01E7, 0x0067, 0x030C, 0,
+    1, 0x01E8, 0x004B, 0x030C, 0,
+    1, 0x01E9, 0x006B, 0x030C, 0,
+    1, 0x01EA, 0x004F, 0x0328, 0,
+    1, 0x01EB, 0x006F, 0x0328, 0,
+    1, 0x01EC, 0x01EA, 0x0304, 0,
+    1, 0x01ED, 0x01EB, 0x0304, 0,
+    1, 0x01EE, 0x01B7, 0x030C, 0,
+    1, 0x01EF, 0x0292, 0x030C, 0,
+    1, 0x01F0, 0x006A, 0x030C, 0,
+    16, 0x01F1, 0x0044, 0x005A, 0,
+    16, 0x01F2, 0x0044, 0x007A, 0,
+    16, 0x01F3, 0x0064, 0x007A, 0,
+    1, 0x01F4, 0x0047, 0x0301, 0,
+    1, 0x01F5, 0x0067, 0x0301, 0,
+    1, 0x01F8, 0x004E, 0x0300, 0,
+    1, 0x01F9, 0x006E, 0x0300, 0,
+    1, 0x01FA, 0x00C5, 0x0301, 0,
+    1, 0x01FB, 0x00E5, 0x0301, 0,
+    1, 0x01FC, 0x00C6, 0x0301, 0,
+    1, 0x01FD, 0x00E6, 0x0301, 0,
+    1, 0x01FE, 0x00D8, 0x0301, 0,
+    1, 0x01FF, 0x00F8, 0x0301, 0,
+    1, 0x0200, 0x0041, 0x030F, 0,
+    1, 0x0201, 0x0061, 0x030F, 0,
+    1, 0x0202, 0x0041, 0x0311, 0,
+    1, 0x0203, 0x0061, 0x0311, 0,
+    1, 0x0204, 0x0045, 0x030F, 0,
+    1, 0x0205, 0x0065, 0x030F, 0,
+    1, 0x0206, 0x0045, 0x0311, 0,
+    1, 0x0207, 0x0065, 0x0311, 0,
+    1, 0x0208, 0x0049, 0x030F, 0,
+    1, 0x0209, 0x0069, 0x030F, 0,
+    1, 0x020A, 0x0049, 0x0311, 0,
+    1, 0x020B, 0x0069, 0x0311, 0,
+    1, 0x020C, 0x004F, 0x030F, 0,
+    1, 0x020D, 0x006F, 0x030F, 0,
+    1, 0x020E, 0x004F, 0x0311, 0,
+    1, 0x020F, 0x006F, 0x0311, 0,
+    1, 0x0210, 0x0052, 0x030F, 0,
+    1, 0x0211, 0x0072, 0x030F, 0,
+    1, 0x0212, 0x0052, 0x0311, 0,
+    1, 0x0213, 0x0072, 0x0311, 0,
+    1, 0x0214, 0x0055, 0x030F, 0,
+    1, 0x0215, 0x0075, 0x030F, 0,
+    1, 0x0216, 0x0055, 0x0311, 0,
+    1, 0x0217, 0x0075, 0x0311, 0,
+    1, 0x0218, 0x0053, 0x0326, 0,
+    1, 0x0219, 0x0073, 0x0326, 0,
+    1, 0x021A, 0x0054, 0x0326, 0,
+    1, 0x021B, 0x0074, 0x0326, 0,
+    1, 0x021E, 0x0048, 0x030C, 0,
+    1, 0x021F, 0x0068, 0x030C, 0,
+    1, 0x0226, 0x0041, 0x0307, 0,
+    1, 0x0227, 0x0061, 0x0307, 0,
+    1, 0x0228, 0x0045, 0x0327, 0,
+    1, 0x0229, 0x0065, 0x0327, 0,
+    1, 0x022A, 0x00D6, 0x0304, 0,
+    1, 0x022B, 0x00F6, 0x0304, 0,
+    1, 0x022C, 0x00D5, 0x0304, 0,
+    1, 0x022D, 0x00F5, 0x0304, 0,
+    1, 0x022E, 0x004F, 0x0307, 0,
+    1, 0x022F, 0x006F, 0x0307, 0,
+    1, 0x0230, 0x022E, 0x0304, 0,
+    1, 0x0231, 0x022F, 0x0304, 0,
+    1, 0x0232, 0x0059, 0x0304, 0,
+    1, 0x0233, 0x0079, 0x0304, 0,
+    9, 0x02B0, 0x0068, 0,
+    9, 0x02B1, 0x0266, 0,
+    9, 0x02B2, 0x006A, 0,
+    9, 0x02B3, 0x0072, 0,
+    9, 0x02B4, 0x0279, 0,
+    9, 0x02B5, 0x027B, 0,
+    9, 0x02B6, 0x0281, 0,
+    9, 0x02B7, 0x0077, 0,
+    9, 0x02B8, 0x0079, 0,
+    16, 0x02D8, 0x0020, 0x0306, 0,
+    16, 0x02D9, 0x0020, 0x0307, 0,
+    16, 0x02DA, 0x0020, 0x030A, 0,
+    16, 0x02DB, 0x0020, 0x0328, 0,
+    16, 0x02DC, 0x0020, 0x0303, 0,
+    16, 0x02DD, 0x0020, 0x030B, 0,
+    9, 0x02E0, 0x0263, 0,
+    9, 0x02E1, 0x006C, 0,
+    9, 0x02E2, 0x0073, 0,
+    9, 0x02E3, 0x0078, 0,
+    9, 0x02E4, 0x0295, 0,
+    1, 0x0340, 0x0300, 0,
+    1, 0x0341, 0x0301, 0,
+    1, 0x0343, 0x0313, 0,
+    1, 0x0344, 0x0308, 0x0301, 0,
+    1, 0x0374, 0x02B9, 0,
+    16, 0x037A, 0x0020, 0x0345, 0,
+    1, 0x037E, 0x003B, 0,
+    16, 0x0384, 0x0020, 0x0301, 0,
+    1, 0x0385, 0x00A8, 0x0301, 0,
+    1, 0x0386, 0x0391, 0x0301, 0,
+    1, 0x0387, 0x00B7, 0,
+    1, 0x0388, 0x0395, 0x0301, 0,
+    1, 0x0389, 0x0397, 0x0301, 0,
+    1, 0x038A, 0x0399, 0x0301, 0,
+    1, 0x038C, 0x039F, 0x0301, 0,
+    1, 0x038E, 0x03A5, 0x0301, 0,
+    1, 0x038F, 0x03A9, 0x0301, 0,
+    1, 0x0390, 0x03CA, 0x0301, 0,
+    1, 0x03AA, 0x0399, 0x0308, 0,
+    1, 0x03AB, 0x03A5, 0x0308, 0,
+    1, 0x03AC, 0x03B1, 0x0301, 0,
+    1, 0x03AD, 0x03B5, 0x0301, 0,
+    1, 0x03AE, 0x03B7, 0x0301, 0,
+    1, 0x03AF, 0x03B9, 0x0301, 0,
+    1, 0x03B0, 0x03CB, 0x0301, 0,
+    1, 0x03CA, 0x03B9, 0x0308, 0,
+    1, 0x03CB, 0x03C5, 0x0308, 0,
+    1, 0x03CC, 0x03BF, 0x0301, 0,
+    1, 0x03CD, 0x03C5, 0x0301, 0,
+    1, 0x03CE, 0x03C9, 0x0301, 0,
+    16, 0x03D0, 0x03B2, 0,
+    16, 0x03D1, 0x03B8, 0,
+    16, 0x03D2, 0x03A5, 0,
+    1, 0x03D3, 0x03D2, 0x0301, 0,
+    1, 0x03D4, 0x03D2, 0x0308, 0,
+    16, 0x03D5, 0x03C6, 0,
+    16, 0x03D6, 0x03C0, 0,
+    16, 0x03F0, 0x03BA, 0,
+    16, 0x03F1, 0x03C1, 0,
+    16, 0x03F2, 0x03C2, 0,
+    16, 0x03F4, 0x0398, 0,
+    16, 0x03F5, 0x03B5, 0,
+    1, 0x0400, 0x0415, 0x0300, 0,
+    1, 0x0401, 0x0415, 0x0308, 0,
+    1, 0x0403, 0x0413, 0x0301, 0,
+    1, 0x0407, 0x0406, 0x0308, 0,
+    1, 0x040C, 0x041A, 0x0301, 0,
+    1, 0x040D, 0x0418, 0x0300, 0,
+    1, 0x040E, 0x0423, 0x0306, 0,
+    1, 0x0419, 0x0418, 0x0306, 0,
+    1, 0x0439, 0x0438, 0x0306, 0,
+    1, 0x0450, 0x0435, 0x0300, 0,
+    1, 0x0451, 0x0435, 0x0308, 0,
+    1, 0x0453, 0x0433, 0x0301, 0,
+    1, 0x0457, 0x0456, 0x0308, 0,
+    1, 0x045C, 0x043A, 0x0301, 0,
+    1, 0x045D, 0x0438, 0x0300, 0,
+    1, 0x045E, 0x0443, 0x0306, 0,
+    1, 0x0476, 0x0474, 0x030F, 0,
+    1, 0x0477, 0x0475, 0x030F, 0,
+    1, 0x04C1, 0x0416, 0x0306, 0,
+    1, 0x04C2, 0x0436, 0x0306, 0,
+    1, 0x04D0, 0x0410, 0x0306, 0,
+    1, 0x04D1, 0x0430, 0x0306, 0,
+    1, 0x04D2, 0x0410, 0x0308, 0,
+    1, 0x04D3, 0x0430, 0x0308, 0,
+    1, 0x04D6, 0x0415, 0x0306, 0,
+    1, 0x04D7, 0x0435, 0x0306, 0,
+    1, 0x04DA, 0x04D8, 0x0308, 0,
+    1, 0x04DB, 0x04D9, 0x0308, 0,
+    1, 0x04DC, 0x0416, 0x0308, 0,
+    1, 0x04DD, 0x0436, 0x0308, 0,
+    1, 0x04DE, 0x0417, 0x0308, 0,
+    1, 0x04DF, 0x0437, 0x0308, 0,
+    1, 0x04E2, 0x0418, 0x0304, 0,
+    1, 0x04E3, 0x0438, 0x0304, 0,
+    1, 0x04E4, 0x0418, 0x0308, 0,
+    1, 0x04E5, 0x0438, 0x0308, 0,
+    1, 0x04E6, 0x041E, 0x0308, 0,
+    1, 0x04E7, 0x043E, 0x0308, 0,
+    1, 0x04EA, 0x04E8, 0x0308, 0,
+    1, 0x04EB, 0x04E9, 0x0308, 0,
+    1, 0x04EC, 0x042D, 0x0308, 0,
+    1, 0x04ED, 0x044D, 0x0308, 0,
+    1, 0x04EE, 0x0423, 0x0304, 0,
+    1, 0x04EF, 0x0443, 0x0304, 0,
+    1, 0x04F0, 0x0423, 0x0308, 0,
+    1, 0x04F1, 0x0443, 0x0308, 0,
+    1, 0x04F2, 0x0423, 0x030B, 0,
+    1, 0x04F3, 0x0443, 0x030B, 0,
+    1, 0x04F4, 0x0427, 0x0308, 0,
+    1, 0x04F5, 0x0447, 0x0308, 0,
+    1, 0x04F8, 0x042B, 0x0308, 0,
+    1, 0x04F9, 0x044B, 0x0308, 0,
+    16, 0x0587, 0x0565, 0x0582, 0,
+    1, 0x0622, 0x0627, 0x0653, 0,
+    1, 0x0623, 0x0627, 0x0654, 0,
+    1, 0x0624, 0x0648, 0x0654, 0,
+    1, 0x0625, 0x0627, 0x0655, 0,
+    1, 0x0626, 0x064A, 0x0654, 0,
+    16, 0x0675, 0x0627, 0x0674, 0,
+    16, 0x0676, 0x0648, 0x0674, 0,
+    16, 0x0677, 0x06C7, 0x0674, 0,
+    16, 0x0678, 0x064A, 0x0674, 0,
+    1, 0x06C0, 0x06D5, 0x0654, 0,
+    1, 0x06C2, 0x06C1, 0x0654, 0,
+    1, 0x06D3, 0x06D2, 0x0654, 0,
+    1, 0x0929, 0x0928, 0x093C, 0,
+    1, 0x0931, 0x0930, 0x093C, 0,
+    1, 0x0934, 0x0933, 0x093C, 0,
+    1, 0x0958, 0x0915, 0x093C, 0,
+    1, 0x0959, 0x0916, 0x093C, 0,
+    1, 0x095A, 0x0917, 0x093C, 0,
+    1, 0x095B, 0x091C, 0x093C, 0,
+    1, 0x095C, 0x0921, 0x093C, 0,
+    1, 0x095D, 0x0922, 0x093C, 0,
+    1, 0x095E, 0x092B, 0x093C, 0,
+    1, 0x095F, 0x092F, 0x093C, 0,
+    1, 0x09CB, 0x09C7, 0x09BE, 0,
+    1, 0x09CC, 0x09C7, 0x09D7, 0,
+    1, 0x09DC, 0x09A1, 0x09BC, 0,
+    1, 0x09DD, 0x09A2, 0x09BC, 0,
+    1, 0x09DF, 0x09AF, 0x09BC, 0,
+    1, 0x0A33, 0x0A32, 0x0A3C, 0,
+    1, 0x0A36, 0x0A38, 0x0A3C, 0,
+    1, 0x0A59, 0x0A16, 0x0A3C, 0,
+    1, 0x0A5A, 0x0A17, 0x0A3C, 0,
+    1, 0x0A5B, 0x0A1C, 0x0A3C, 0,
+    1, 0x0A5E, 0x0A2B, 0x0A3C, 0,
+    1, 0x0B48, 0x0B47, 0x0B56, 0,
+    1, 0x0B4B, 0x0B47, 0x0B3E, 0,
+    1, 0x0B4C, 0x0B47, 0x0B57, 0,
+    1, 0x0B5C, 0x0B21, 0x0B3C, 0,
+    1, 0x0B5D, 0x0B22, 0x0B3C, 0,
+    1, 0x0B94, 0x0B92, 0x0BD7, 0,
+    1, 0x0BCA, 0x0BC6, 0x0BBE, 0,
+    1, 0x0BCB, 0x0BC7, 0x0BBE, 0,
+    1, 0x0BCC, 0x0BC6, 0x0BD7, 0,
+    1, 0x0C48, 0x0C46, 0x0C56, 0,
+    1, 0x0CC0, 0x0CBF, 0x0CD5, 0,
+    1, 0x0CC7, 0x0CC6, 0x0CD5, 0,
+    1, 0x0CC8, 0x0CC6, 0x0CD6, 0,
+    1, 0x0CCA, 0x0CC6, 0x0CC2, 0,
+    1, 0x0CCB, 0x0CCA, 0x0CD5, 0,
+    1, 0x0D4A, 0x0D46, 0x0D3E, 0,
+    1, 0x0D4B, 0x0D47, 0x0D3E, 0,
+    1, 0x0D4C, 0x0D46, 0x0D57, 0,
+    1, 0x0DDA, 0x0DD9, 0x0DCA, 0,
+    1, 0x0DDC, 0x0DD9, 0x0DCF, 0,
+    1, 0x0DDD, 0x0DDC, 0x0DCA, 0,
+    1, 0x0DDE, 0x0DD9, 0x0DDF, 0,
+    16, 0x0E33, 0x0E4D, 0x0E32, 0,
+    16, 0x0EB3, 0x0ECD, 0x0EB2, 0,
+    16, 0x0EDC, 0x0EAB, 0x0E99, 0,
+    16, 0x0EDD, 0x0EAB, 0x0EA1, 0,
+    3, 0x0F0C, 0x0F0B, 0,
+    1, 0x0F43, 0x0F42, 0x0FB7, 0,
+    1, 0x0F4D, 0x0F4C, 0x0FB7, 0,
+    1, 0x0F52, 0x0F51, 0x0FB7, 0,
+    1, 0x0F57, 0x0F56, 0x0FB7, 0,
+    1, 0x0F5C, 0x0F5B, 0x0FB7, 0,
+    1, 0x0F69, 0x0F40, 0x0FB5, 0,
+    1, 0x0F73, 0x0F71, 0x0F72, 0,
+    1, 0x0F75, 0x0F71, 0x0F74, 0,
+    1, 0x0F76, 0x0FB2, 0x0F80, 0,
+    16, 0x0F77, 0x0FB2, 0x0F81, 0,
+    1, 0x0F78, 0x0FB3, 0x0F80, 0,
+    16, 0x0F79, 0x0FB3, 0x0F81, 0,
+    1, 0x0F81, 0x0F71, 0x0F80, 0,
+    1, 0x0F93, 0x0F92, 0x0FB7, 0,
+    1, 0x0F9D, 0x0F9C, 0x0FB7, 0,
+    1, 0x0FA2, 0x0FA1, 0x0FB7, 0,
+    1, 0x0FA7, 0x0FA6, 0x0FB7, 0,
+    1, 0x0FAC, 0x0FAB, 0x0FB7, 0,
+    1, 0x0FB9, 0x0F90, 0x0FB5, 0,
+    1, 0x1026, 0x1025, 0x102E, 0,
+    1, 0x1E00, 0x0041, 0x0325, 0,
+    1, 0x1E01, 0x0061, 0x0325, 0,
+    1, 0x1E02, 0x0042, 0x0307, 0,
+    1, 0x1E03, 0x0062, 0x0307, 0,
+    1, 0x1E04, 0x0042, 0x0323, 0,
+    1, 0x1E05, 0x0062, 0x0323, 0,
+    1, 0x1E06, 0x0042, 0x0331, 0,
+    1, 0x1E07, 0x0062, 0x0331, 0,
+    1, 0x1E08, 0x00C7, 0x0301, 0,
+    1, 0x1E09, 0x00E7, 0x0301, 0,
+    1, 0x1E0A, 0x0044, 0x0307, 0,
+    1, 0x1E0B, 0x0064, 0x0307, 0,
+    1, 0x1E0C, 0x0044, 0x0323, 0,
+    1, 0x1E0D, 0x0064, 0x0323, 0,
+    1, 0x1E0E, 0x0044, 0x0331, 0,
+    1, 0x1E0F, 0x0064, 0x0331, 0,
+    1, 0x1E10, 0x0044, 0x0327, 0,
+    1, 0x1E11, 0x0064, 0x0327, 0,
+    1, 0x1E12, 0x0044, 0x032D, 0,
+    1, 0x1E13, 0x0064, 0x032D, 0,
+    1, 0x1E14, 0x0112, 0x0300, 0,
+    1, 0x1E15, 0x0113, 0x0300, 0,
+    1, 0x1E16, 0x0112, 0x0301, 0,
+    1, 0x1E17, 0x0113, 0x0301, 0,
+    1, 0x1E18, 0x0045, 0x032D, 0,
+    1, 0x1E19, 0x0065, 0x032D, 0,
+    1, 0x1E1A, 0x0045, 0x0330, 0,
+    1, 0x1E1B, 0x0065, 0x0330, 0,
+    1, 0x1E1C, 0x0228, 0x0306, 0,
+    1, 0x1E1D, 0x0229, 0x0306, 0,
+    1, 0x1E1E, 0x0046, 0x0307, 0,
+    1, 0x1E1F, 0x0066, 0x0307, 0,
+    1, 0x1E20, 0x0047, 0x0304, 0,
+    1, 0x1E21, 0x0067, 0x0304, 0,
+    1, 0x1E22, 0x0048, 0x0307, 0,
+    1, 0x1E23, 0x0068, 0x0307, 0,
+    1, 0x1E24, 0x0048, 0x0323, 0,
+    1, 0x1E25, 0x0068, 0x0323, 0,
+    1, 0x1E26, 0x0048, 0x0308, 0,
+    1, 0x1E27, 0x0068, 0x0308, 0,
+    1, 0x1E28, 0x0048, 0x0327, 0,
+    1, 0x1E29, 0x0068, 0x0327, 0,
+    1, 0x1E2A, 0x0048, 0x032E, 0,
+    1, 0x1E2B, 0x0068, 0x032E, 0,
+    1, 0x1E2C, 0x0049, 0x0330, 0,
+    1, 0x1E2D, 0x0069, 0x0330, 0,
+    1, 0x1E2E, 0x00CF, 0x0301, 0,
+    1, 0x1E2F, 0x00EF, 0x0301, 0,
+    1, 0x1E30, 0x004B, 0x0301, 0,
+    1, 0x1E31, 0x006B, 0x0301, 0,
+    1, 0x1E32, 0x004B, 0x0323, 0,
+    1, 0x1E33, 0x006B, 0x0323, 0,
+    1, 0x1E34, 0x004B, 0x0331, 0,
+    1, 0x1E35, 0x006B, 0x0331, 0,
+    1, 0x1E36, 0x004C, 0x0323, 0,
+    1, 0x1E37, 0x006C, 0x0323, 0,
+    1, 0x1E38, 0x1E36, 0x0304, 0,
+    1, 0x1E39, 0x1E37, 0x0304, 0,
+    1, 0x1E3A, 0x004C, 0x0331, 0,
+    1, 0x1E3B, 0x006C, 0x0331, 0,
+    1, 0x1E3C, 0x004C, 0x032D, 0,
+    1, 0x1E3D, 0x006C, 0x032D, 0,
+    1, 0x1E3E, 0x004D, 0x0301, 0,
+    1, 0x1E3F, 0x006D, 0x0301, 0,
+    1, 0x1E40, 0x004D, 0x0307, 0,
+    1, 0x1E41, 0x006D, 0x0307, 0,
+    1, 0x1E42, 0x004D, 0x0323, 0,
+    1, 0x1E43, 0x006D, 0x0323, 0,
+    1, 0x1E44, 0x004E, 0x0307, 0,
+    1, 0x1E45, 0x006E, 0x0307, 0,
+    1, 0x1E46, 0x004E, 0x0323, 0,
+    1, 0x1E47, 0x006E, 0x0323, 0,
+    1, 0x1E48, 0x004E, 0x0331, 0,
+    1, 0x1E49, 0x006E, 0x0331, 0,
+    1, 0x1E4A, 0x004E, 0x032D, 0,
+    1, 0x1E4B, 0x006E, 0x032D, 0,
+    1, 0x1E4C, 0x00D5, 0x0301, 0,
+    1, 0x1E4D, 0x00F5, 0x0301, 0,
+    1, 0x1E4E, 0x00D5, 0x0308, 0,
+    1, 0x1E4F, 0x00F5, 0x0308, 0,
+    1, 0x1E50, 0x014C, 0x0300, 0,
+    1, 0x1E51, 0x014D, 0x0300, 0,
+    1, 0x1E52, 0x014C, 0x0301, 0,
+    1, 0x1E53, 0x014D, 0x0301, 0,
+    1, 0x1E54, 0x0050, 0x0301, 0,
+    1, 0x1E55, 0x0070, 0x0301, 0,
+    1, 0x1E56, 0x0050, 0x0307, 0,
+    1, 0x1E57, 0x0070, 0x0307, 0,
+    1, 0x1E58, 0x0052, 0x0307, 0,
+    1, 0x1E59, 0x0072, 0x0307, 0,
+    1, 0x1E5A, 0x0052, 0x0323, 0,
+    1, 0x1E5B, 0x0072, 0x0323, 0,
+    1, 0x1E5C, 0x1E5A, 0x0304, 0,
+    1, 0x1E5D, 0x1E5B, 0x0304, 0,
+    1, 0x1E5E, 0x0052, 0x0331, 0,
+    1, 0x1E5F, 0x0072, 0x0331, 0,
+    1, 0x1E60, 0x0053, 0x0307, 0,
+    1, 0x1E61, 0x0073, 0x0307, 0,
+    1, 0x1E62, 0x0053, 0x0323, 0,
+    1, 0x1E63, 0x0073, 0x0323, 0,
+    1, 0x1E64, 0x015A, 0x0307, 0,
+    1, 0x1E65, 0x015B, 0x0307, 0,
+    1, 0x1E66, 0x0160, 0x0307, 0,
+    1, 0x1E67, 0x0161, 0x0307, 0,
+    1, 0x1E68, 0x1E62, 0x0307, 0,
+    1, 0x1E69, 0x1E63, 0x0307, 0,
+    1, 0x1E6A, 0x0054, 0x0307, 0,
+    1, 0x1E6B, 0x0074, 0x0307, 0,
+    1, 0x1E6C, 0x0054, 0x0323, 0,
+    1, 0x1E6D, 0x0074, 0x0323, 0,
+    1, 0x1E6E, 0x0054, 0x0331, 0,
+    1, 0x1E6F, 0x0074, 0x0331, 0,
+    1, 0x1E70, 0x0054, 0x032D, 0,
+    1, 0x1E71, 0x0074, 0x032D, 0,
+    1, 0x1E72, 0x0055, 0x0324, 0,
+    1, 0x1E73, 0x0075, 0x0324, 0,
+    1, 0x1E74, 0x0055, 0x0330, 0,
+    1, 0x1E75, 0x0075, 0x0330, 0,
+    1, 0x1E76, 0x0055, 0x032D, 0,
+    1, 0x1E77, 0x0075, 0x032D, 0,
+    1, 0x1E78, 0x0168, 0x0301, 0,
+    1, 0x1E79, 0x0169, 0x0301, 0,
+    1, 0x1E7A, 0x016A, 0x0308, 0,
+    1, 0x1E7B, 0x016B, 0x0308, 0,
+    1, 0x1E7C, 0x0056, 0x0303, 0,
+    1, 0x1E7D, 0x0076, 0x0303, 0,
+    1, 0x1E7E, 0x0056, 0x0323, 0,
+    1, 0x1E7F, 0x0076, 0x0323, 0,
+    1, 0x1E80, 0x0057, 0x0300, 0,
+    1, 0x1E81, 0x0077, 0x0300, 0,
+    1, 0x1E82, 0x0057, 0x0301, 0,
+    1, 0x1E83, 0x0077, 0x0301, 0,
+    1, 0x1E84, 0x0057, 0x0308, 0,
+    1, 0x1E85, 0x0077, 0x0308, 0,
+    1, 0x1E86, 0x0057, 0x0307, 0,
+    1, 0x1E87, 0x0077, 0x0307, 0,
+    1, 0x1E88, 0x0057, 0x0323, 0,
+    1, 0x1E89, 0x0077, 0x0323, 0,
+    1, 0x1E8A, 0x0058, 0x0307, 0,
+    1, 0x1E8B, 0x0078, 0x0307, 0,
+    1, 0x1E8C, 0x0058, 0x0308, 0,
+    1, 0x1E8D, 0x0078, 0x0308, 0,
+    1, 0x1E8E, 0x0059, 0x0307, 0,
+    1, 0x1E8F, 0x0079, 0x0307, 0,
+    1, 0x1E90, 0x005A, 0x0302, 0,
+    1, 0x1E91, 0x007A, 0x0302, 0,
+    1, 0x1E92, 0x005A, 0x0323, 0,
+    1, 0x1E93, 0x007A, 0x0323, 0,
+    1, 0x1E94, 0x005A, 0x0331, 0,
+    1, 0x1E95, 0x007A, 0x0331, 0,
+    1, 0x1E96, 0x0068, 0x0331, 0,
+    1, 0x1E97, 0x0074, 0x0308, 0,
+    1, 0x1E98, 0x0077, 0x030A, 0,
+    1, 0x1E99, 0x0079, 0x030A, 0,
+    16, 0x1E9A, 0x0061, 0x02BE, 0,
+    1, 0x1E9B, 0x017F, 0x0307, 0,
+    1, 0x1EA0, 0x0041, 0x0323, 0,
+    1, 0x1EA1, 0x0061, 0x0323, 0,
+    1, 0x1EA2, 0x0041, 0x0309, 0,
+    1, 0x1EA3, 0x0061, 0x0309, 0,
+    1, 0x1EA4, 0x00C2, 0x0301, 0,
+    1, 0x1EA5, 0x00E2, 0x0301, 0,
+    1, 0x1EA6, 0x00C2, 0x0300, 0,
+    1, 0x1EA7, 0x00E2, 0x0300, 0,
+    1, 0x1EA8, 0x00C2, 0x0309, 0,
+    1, 0x1EA9, 0x00E2, 0x0309, 0,
+    1, 0x1EAA, 0x00C2, 0x0303, 0,
+    1, 0x1EAB, 0x00E2, 0x0303, 0,
+    1, 0x1EAC, 0x1EA0, 0x0302, 0,
+    1, 0x1EAD, 0x1EA1, 0x0302, 0,
+    1, 0x1EAE, 0x0102, 0x0301, 0,
+    1, 0x1EAF, 0x0103, 0x0301, 0,
+    1, 0x1EB0, 0x0102, 0x0300, 0,
+    1, 0x1EB1, 0x0103, 0x0300, 0,
+    1, 0x1EB2, 0x0102, 0x0309, 0,
+    1, 0x1EB3, 0x0103, 0x0309, 0,
+    1, 0x1EB4, 0x0102, 0x0303, 0,
+    1, 0x1EB5, 0x0103, 0x0303, 0,
+    1, 0x1EB6, 0x1EA0, 0x0306, 0,
+    1, 0x1EB7, 0x1EA1, 0x0306, 0,
+    1, 0x1EB8, 0x0045, 0x0323, 0,
+    1, 0x1EB9, 0x0065, 0x0323, 0,
+    1, 0x1EBA, 0x0045, 0x0309, 0,
+    1, 0x1EBB, 0x0065, 0x0309, 0,
+    1, 0x1EBC, 0x0045, 0x0303, 0,
+    1, 0x1EBD, 0x0065, 0x0303, 0,
+    1, 0x1EBE, 0x00CA, 0x0301, 0,
+    1, 0x1EBF, 0x00EA, 0x0301, 0,
+    1, 0x1EC0, 0x00CA, 0x0300, 0,
+    1, 0x1EC1, 0x00EA, 0x0300, 0,
+    1, 0x1EC2, 0x00CA, 0x0309, 0,
+    1, 0x1EC3, 0x00EA, 0x0309, 0,
+    1, 0x1EC4, 0x00CA, 0x0303, 0,
+    1, 0x1EC5, 0x00EA, 0x0303, 0,
+    1, 0x1EC6, 0x1EB8, 0x0302, 0,
+    1, 0x1EC7, 0x1EB9, 0x0302, 0,
+    1, 0x1EC8, 0x0049, 0x0309, 0,
+    1, 0x1EC9, 0x0069, 0x0309, 0,
+    1, 0x1ECA, 0x0049, 0x0323, 0,
+    1, 0x1ECB, 0x0069, 0x0323, 0,
+    1, 0x1ECC, 0x004F, 0x0323, 0,
+    1, 0x1ECD, 0x006F, 0x0323, 0,
+    1, 0x1ECE, 0x004F, 0x0309, 0,
+    1, 0x1ECF, 0x006F, 0x0309, 0,
+    1, 0x1ED0, 0x00D4, 0x0301, 0,
+    1, 0x1ED1, 0x00F4, 0x0301, 0,
+    1, 0x1ED2, 0x00D4, 0x0300, 0,
+    1, 0x1ED3, 0x00F4, 0x0300, 0,
+    1, 0x1ED4, 0x00D4, 0x0309, 0,
+    1, 0x1ED5, 0x00F4, 0x0309, 0,
+    1, 0x1ED6, 0x00D4, 0x0303, 0,
+    1, 0x1ED7, 0x00F4, 0x0303, 0,
+    1, 0x1ED8, 0x1ECC, 0x0302, 0,
+    1, 0x1ED9, 0x1ECD, 0x0302, 0,
+    1, 0x1EDA, 0x01A0, 0x0301, 0,
+    1, 0x1EDB, 0x01A1, 0x0301, 0,
+    1, 0x1EDC, 0x01A0, 0x0300, 0,
+    1, 0x1EDD, 0x01A1, 0x0300, 0,
+    1, 0x1EDE, 0x01A0, 0x0309, 0,
+    1, 0x1EDF, 0x01A1, 0x0309, 0,
+    1, 0x1EE0, 0x01A0, 0x0303, 0,
+    1, 0x1EE1, 0x01A1, 0x0303, 0,
+    1, 0x1EE2, 0x01A0, 0x0323, 0,
+    1, 0x1EE3, 0x01A1, 0x0323, 0,
+    1, 0x1EE4, 0x0055, 0x0323, 0,
+    1, 0x1EE5, 0x0075, 0x0323, 0,
+    1, 0x1EE6, 0x0055, 0x0309, 0,
+    1, 0x1EE7, 0x0075, 0x0309, 0,
+    1, 0x1EE8, 0x01AF, 0x0301, 0,
+    1, 0x1EE9, 0x01B0, 0x0301, 0,
+    1, 0x1EEA, 0x01AF, 0x0300, 0,
+    1, 0x1EEB, 0x01B0, 0x0300, 0,
+    1, 0x1EEC, 0x01AF, 0x0309, 0,
+    1, 0x1EED, 0x01B0, 0x0309, 0,
+    1, 0x1EEE, 0x01AF, 0x0303, 0,
+    1, 0x1EEF, 0x01B0, 0x0303, 0,
+    1, 0x1EF0, 0x01AF, 0x0323, 0,
+    1, 0x1EF1, 0x01B0, 0x0323, 0,
+    1, 0x1EF2, 0x0059, 0x0300, 0,
+    1, 0x1EF3, 0x0079, 0x0300, 0,
+    1, 0x1EF4, 0x0059, 0x0323, 0,
+    1, 0x1EF5, 0x0079, 0x0323, 0,
+    1, 0x1EF6, 0x0059, 0x0309, 0,
+    1, 0x1EF7, 0x0079, 0x0309, 0,
+    1, 0x1EF8, 0x0059, 0x0303, 0,
+    1, 0x1EF9, 0x0079, 0x0303, 0,
+    1, 0x1F00, 0x03B1, 0x0313, 0,
+    1, 0x1F01, 0x03B1, 0x0314, 0,
+    1, 0x1F02, 0x1F00, 0x0300, 0,
+    1, 0x1F03, 0x1F01, 0x0300, 0,
+    1, 0x1F04, 0x1F00, 0x0301, 0,
+    1, 0x1F05, 0x1F01, 0x0301, 0,
+    1, 0x1F06, 0x1F00, 0x0342, 0,
+    1, 0x1F07, 0x1F01, 0x0342, 0,
+    1, 0x1F08, 0x0391, 0x0313, 0,
+    1, 0x1F09, 0x0391, 0x0314, 0,
+    1, 0x1F0A, 0x1F08, 0x0300, 0,
+    1, 0x1F0B, 0x1F09, 0x0300, 0,
+    1, 0x1F0C, 0x1F08, 0x0301, 0,
+    1, 0x1F0D, 0x1F09, 0x0301, 0,
+    1, 0x1F0E, 0x1F08, 0x0342, 0,
+    1, 0x1F0F, 0x1F09, 0x0342, 0,
+    1, 0x1F10, 0x03B5, 0x0313, 0,
+    1, 0x1F11, 0x03B5, 0x0314, 0,
+    1, 0x1F12, 0x1F10, 0x0300, 0,
+    1, 0x1F13, 0x1F11, 0x0300, 0,
+    1, 0x1F14, 0x1F10, 0x0301, 0,
+    1, 0x1F15, 0x1F11, 0x0301, 0,
+    1, 0x1F18, 0x0395, 0x0313, 0,
+    1, 0x1F19, 0x0395, 0x0314, 0,
+    1, 0x1F1A, 0x1F18, 0x0300, 0,
+    1, 0x1F1B, 0x1F19, 0x0300, 0,
+    1, 0x1F1C, 0x1F18, 0x0301, 0,
+    1, 0x1F1D, 0x1F19, 0x0301, 0,
+    1, 0x1F20, 0x03B7, 0x0313, 0,
+    1, 0x1F21, 0x03B7, 0x0314, 0,
+    1, 0x1F22, 0x1F20, 0x0300, 0,
+    1, 0x1F23, 0x1F21, 0x0300, 0,
+    1, 0x1F24, 0x1F20, 0x0301, 0,
+    1, 0x1F25, 0x1F21, 0x0301, 0,
+    1, 0x1F26, 0x1F20, 0x0342, 0,
+    1, 0x1F27, 0x1F21, 0x0342, 0,
+    1, 0x1F28, 0x0397, 0x0313, 0,
+    1, 0x1F29, 0x0397, 0x0314, 0,
+    1, 0x1F2A, 0x1F28, 0x0300, 0,
+    1, 0x1F2B, 0x1F29, 0x0300, 0,
+    1, 0x1F2C, 0x1F28, 0x0301, 0,
+    1, 0x1F2D, 0x1F29, 0x0301, 0,
+    1, 0x1F2E, 0x1F28, 0x0342, 0,
+    1, 0x1F2F, 0x1F29, 0x0342, 0,
+    1, 0x1F30, 0x03B9, 0x0313, 0,
+    1, 0x1F31, 0x03B9, 0x0314, 0,
+    1, 0x1F32, 0x1F30, 0x0300, 0,
+    1, 0x1F33, 0x1F31, 0x0300, 0,
+    1, 0x1F34, 0x1F30, 0x0301, 0,
+    1, 0x1F35, 0x1F31, 0x0301, 0,
+    1, 0x1F36, 0x1F30, 0x0342, 0,
+    1, 0x1F37, 0x1F31, 0x0342, 0,
+    1, 0x1F38, 0x0399, 0x0313, 0,
+    1, 0x1F39, 0x0399, 0x0314, 0,
+    1, 0x1F3A, 0x1F38, 0x0300, 0,
+    1, 0x1F3B, 0x1F39, 0x0300, 0,
+    1, 0x1F3C, 0x1F38, 0x0301, 0,
+    1, 0x1F3D, 0x1F39, 0x0301, 0,
+    1, 0x1F3E, 0x1F38, 0x0342, 0,
+    1, 0x1F3F, 0x1F39, 0x0342, 0,
+    1, 0x1F40, 0x03BF, 0x0313, 0,
+    1, 0x1F41, 0x03BF, 0x0314, 0,
+    1, 0x1F42, 0x1F40, 0x0300, 0,
+    1, 0x1F43, 0x1F41, 0x0300, 0,
+    1, 0x1F44, 0x1F40, 0x0301, 0,
+    1, 0x1F45, 0x1F41, 0x0301, 0,
+    1, 0x1F48, 0x039F, 0x0313, 0,
+    1, 0x1F49, 0x039F, 0x0314, 0,
+    1, 0x1F4A, 0x1F48, 0x0300, 0,
+    1, 0x1F4B, 0x1F49, 0x0300, 0,
+    1, 0x1F4C, 0x1F48, 0x0301, 0,
+    1, 0x1F4D, 0x1F49, 0x0301, 0,
+    1, 0x1F50, 0x03C5, 0x0313, 0,
+    1, 0x1F51, 0x03C5, 0x0314, 0,
+    1, 0x1F52, 0x1F50, 0x0300, 0,
+    1, 0x1F53, 0x1F51, 0x0300, 0,
+    1, 0x1F54, 0x1F50, 0x0301, 0,
+    1, 0x1F55, 0x1F51, 0x0301, 0,
+    1, 0x1F56, 0x1F50, 0x0342, 0,
+    1, 0x1F57, 0x1F51, 0x0342, 0,
+    1, 0x1F59, 0x03A5, 0x0314, 0,
+    1, 0x1F5B, 0x1F59, 0x0300, 0,
+    1, 0x1F5D, 0x1F59, 0x0301, 0,
+    1, 0x1F5F, 0x1F59, 0x0342, 0,
+    1, 0x1F60, 0x03C9, 0x0313, 0,
+    1, 0x1F61, 0x03C9, 0x0314, 0,
+    1, 0x1F62, 0x1F60, 0x0300, 0,
+    1, 0x1F63, 0x1F61, 0x0300, 0,
+    1, 0x1F64, 0x1F60, 0x0301, 0,
+    1, 0x1F65, 0x1F61, 0x0301, 0,
+    1, 0x1F66, 0x1F60, 0x0342, 0,
+    1, 0x1F67, 0x1F61, 0x0342, 0,
+    1, 0x1F68, 0x03A9, 0x0313, 0,
+    1, 0x1F69, 0x03A9, 0x0314, 0,
+    1, 0x1F6A, 0x1F68, 0x0300, 0,
+    1, 0x1F6B, 0x1F69, 0x0300, 0,
+    1, 0x1F6C, 0x1F68, 0x0301, 0,
+    1, 0x1F6D, 0x1F69, 0x0301, 0,
+    1, 0x1F6E, 0x1F68, 0x0342, 0,
+    1, 0x1F6F, 0x1F69, 0x0342, 0,
+    1, 0x1F70, 0x03B1, 0x0300, 0,
+    1, 0x1F71, 0x03AC, 0,
+    1, 0x1F72, 0x03B5, 0x0300, 0,
+    1, 0x1F73, 0x03AD, 0,
+    1, 0x1F74, 0x03B7, 0x0300, 0,
+    1, 0x1F75, 0x03AE, 0,
+    1, 0x1F76, 0x03B9, 0x0300, 0,
+    1, 0x1F77, 0x03AF, 0,
+    1, 0x1F78, 0x03BF, 0x0300, 0,
+    1, 0x1F79, 0x03CC, 0,
+    1, 0x1F7A, 0x03C5, 0x0300, 0,
+    1, 0x1F7B, 0x03CD, 0,
+    1, 0x1F7C, 0x03C9, 0x0300, 0,
+    1, 0x1F7D, 0x03CE, 0,
+    1, 0x1F80, 0x1F00, 0x0345, 0,
+    1, 0x1F81, 0x1F01, 0x0345, 0,
+    1, 0x1F82, 0x1F02, 0x0345, 0,
+    1, 0x1F83, 0x1F03, 0x0345, 0,
+    1, 0x1F84, 0x1F04, 0x0345, 0,
+    1, 0x1F85, 0x1F05, 0x0345, 0,
+    1, 0x1F86, 0x1F06, 0x0345, 0,
+    1, 0x1F87, 0x1F07, 0x0345, 0,
+    1, 0x1F88, 0x1F08, 0x0345, 0,
+    1, 0x1F89, 0x1F09, 0x0345, 0,
+    1, 0x1F8A, 0x1F0A, 0x0345, 0,
+    1, 0x1F8B, 0x1F0B, 0x0345, 0,
+    1, 0x1F8C, 0x1F0C, 0x0345, 0,
+    1, 0x1F8D, 0x1F0D, 0x0345, 0,
+    1, 0x1F8E, 0x1F0E, 0x0345, 0,
+    1, 0x1F8F, 0x1F0F, 0x0345, 0,
+    1, 0x1F90, 0x1F20, 0x0345, 0,
+    1, 0x1F91, 0x1F21, 0x0345, 0,
+    1, 0x1F92, 0x1F22, 0x0345, 0,
+    1, 0x1F93, 0x1F23, 0x0345, 0,
+    1, 0x1F94, 0x1F24, 0x0345, 0,
+    1, 0x1F95, 0x1F25, 0x0345, 0,
+    1, 0x1F96, 0x1F26, 0x0345, 0,
+    1, 0x1F97, 0x1F27, 0x0345, 0,
+    1, 0x1F98, 0x1F28, 0x0345, 0,
+    1, 0x1F99, 0x1F29, 0x0345, 0,
+    1, 0x1F9A, 0x1F2A, 0x0345, 0,
+    1, 0x1F9B, 0x1F2B, 0x0345, 0,
+    1, 0x1F9C, 0x1F2C, 0x0345, 0,
+    1, 0x1F9D, 0x1F2D, 0x0345, 0,
+    1, 0x1F9E, 0x1F2E, 0x0345, 0,
+    1, 0x1F9F, 0x1F2F, 0x0345, 0,
+    1, 0x1FA0, 0x1F60, 0x0345, 0,
+    1, 0x1FA1, 0x1F61, 0x0345, 0,
+    1, 0x1FA2, 0x1F62, 0x0345, 0,
+    1, 0x1FA3, 0x1F63, 0x0345, 0,
+    1, 0x1FA4, 0x1F64, 0x0345, 0,
+    1, 0x1FA5, 0x1F65, 0x0345, 0,
+    1, 0x1FA6, 0x1F66, 0x0345, 0,
+    1, 0x1FA7, 0x1F67, 0x0345, 0,
+    1, 0x1FA8, 0x1F68, 0x0345, 0,
+    1, 0x1FA9, 0x1F69, 0x0345, 0,
+    1, 0x1FAA, 0x1F6A, 0x0345, 0,
+    1, 0x1FAB, 0x1F6B, 0x0345, 0,
+    1, 0x1FAC, 0x1F6C, 0x0345, 0,
+    1, 0x1FAD, 0x1F6D, 0x0345, 0,
+    1, 0x1FAE, 0x1F6E, 0x0345, 0,
+    1, 0x1FAF, 0x1F6F, 0x0345, 0,
+    1, 0x1FB0, 0x03B1, 0x0306, 0,
+    1, 0x1FB1, 0x03B1, 0x0304, 0,
+    1, 0x1FB2, 0x1F70, 0x0345, 0,
+    1, 0x1FB3, 0x03B1, 0x0345, 0,
+    1, 0x1FB4, 0x03AC, 0x0345, 0,
+    1, 0x1FB6, 0x03B1, 0x0342, 0,
+    1, 0x1FB7, 0x1FB6, 0x0345, 0,
+    1, 0x1FB8, 0x0391, 0x0306, 0,
+    1, 0x1FB9, 0x0391, 0x0304, 0,
+    1, 0x1FBA, 0x0391, 0x0300, 0,
+    1, 0x1FBB, 0x0386, 0,
+    1, 0x1FBC, 0x0391, 0x0345, 0,
+    16, 0x1FBD, 0x0020, 0x0313, 0,
+    1, 0x1FBE, 0x03B9, 0,
+    16, 0x1FBF, 0x0020, 0x0313, 0,
+    16, 0x1FC0, 0x0020, 0x0342, 0,
+    1, 0x1FC1, 0x00A8, 0x0342, 0,
+    1, 0x1FC2, 0x1F74, 0x0345, 0,
+    1, 0x1FC3, 0x03B7, 0x0345, 0,
+    1, 0x1FC4, 0x03AE, 0x0345, 0,
+    1, 0x1FC6, 0x03B7, 0x0342, 0,
+    1, 0x1FC7, 0x1FC6, 0x0345, 0,
+    1, 0x1FC8, 0x0395, 0x0300, 0,
+    1, 0x1FC9, 0x0388, 0,
+    1, 0x1FCA, 0x0397, 0x0300, 0,
+    1, 0x1FCB, 0x0389, 0,
+    1, 0x1FCC, 0x0397, 0x0345, 0,
+    1, 0x1FCD, 0x1FBF, 0x0300, 0,
+    1, 0x1FCE, 0x1FBF, 0x0301, 0,
+    1, 0x1FCF, 0x1FBF, 0x0342, 0,
+    1, 0x1FD0, 0x03B9, 0x0306, 0,
+    1, 0x1FD1, 0x03B9, 0x0304, 0,
+    1, 0x1FD2, 0x03CA, 0x0300, 0,
+    1, 0x1FD3, 0x0390, 0,
+    1, 0x1FD6, 0x03B9, 0x0342, 0,
+    1, 0x1FD7, 0x03CA, 0x0342, 0,
+    1, 0x1FD8, 0x0399, 0x0306, 0,
+    1, 0x1FD9, 0x0399, 0x0304, 0,
+    1, 0x1FDA, 0x0399, 0x0300, 0,
+    1, 0x1FDB, 0x038A, 0,
+    1, 0x1FDD, 0x1FFE, 0x0300, 0,
+    1, 0x1FDE, 0x1FFE, 0x0301, 0,
+    1, 0x1FDF, 0x1FFE, 0x0342, 0,
+    1, 0x1FE0, 0x03C5, 0x0306, 0,
+    1, 0x1FE1, 0x03C5, 0x0304, 0,
+    1, 0x1FE2, 0x03CB, 0x0300, 0,
+    1, 0x1FE3, 0x03B0, 0,
+    1, 0x1FE4, 0x03C1, 0x0313, 0,
+    1, 0x1FE5, 0x03C1, 0x0314, 0,
+    1, 0x1FE6, 0x03C5, 0x0342, 0,
+    1, 0x1FE7, 0x03CB, 0x0342, 0,
+    1, 0x1FE8, 0x03A5, 0x0306, 0,
+    1, 0x1FE9, 0x03A5, 0x0304, 0,
+    1, 0x1FEA, 0x03A5, 0x0300, 0,
+    1, 0x1FEB, 0x038E, 0,
+    1, 0x1FEC, 0x03A1, 0x0314, 0,
+    1, 0x1FED, 0x00A8, 0x0300, 0,
+    1, 0x1FEE, 0x0385, 0,
+    1, 0x1FEF, 0x0060, 0,
+    1, 0x1FF2, 0x1F7C, 0x0345, 0,
+    1, 0x1FF3, 0x03C9, 0x0345, 0,
+    1, 0x1FF4, 0x03CE, 0x0345, 0,
+    1, 0x1FF6, 0x03C9, 0x0342, 0,
+    1, 0x1FF7, 0x1FF6, 0x0345, 0,
+    1, 0x1FF8, 0x039F, 0x0300, 0,
+    1, 0x1FF9, 0x038C, 0,
+    1, 0x1FFA, 0x03A9, 0x0300, 0,
+    1, 0x1FFB, 0x038F, 0,
+    1, 0x1FFC, 0x03A9, 0x0345, 0,
+    1, 0x1FFD, 0x00B4, 0,
+    16, 0x1FFE, 0x0020, 0x0314, 0,
+    1, 0x2000, 0x2002, 0,
+    1, 0x2001, 0x2003, 0,
+    16, 0x2002, 0x0020, 0,
+    16, 0x2003, 0x0020, 0,
+    16, 0x2004, 0x0020, 0,
+    16, 0x2005, 0x0020, 0,
+    16, 0x2006, 0x0020, 0,
+    3, 0x2007, 0x0020, 0,
+    16, 0x2008, 0x0020, 0,
+    16, 0x2009, 0x0020, 0,
+    16, 0x200A, 0x0020, 0,
+    3, 0x2011, 0x2010, 0,
+    16, 0x2017, 0x0020, 0x0333, 0,
+    16, 0x2024, 0x002E, 0,
+    16, 0x2025, 0x002E, 0x002E, 0,
+    16, 0x2026, 0x002E, 0x002E, 0x002E, 0,
+    3, 0x202F, 0x0020, 0,
+    16, 0x2033, 0x2032, 0x2032, 0,
+    16, 0x2034, 0x2032, 0x2032, 0x2032, 0,
+    16, 0x2036, 0x2035, 0x2035, 0,
+    16, 0x2037, 0x2035, 0x2035, 0x2035, 0,
+    16, 0x203C, 0x0021, 0x0021, 0,
+    16, 0x203E, 0x0020, 0x0305, 0,
+    16, 0x2047, 0x003F, 0x003F, 0,
+    16, 0x2048, 0x003F, 0x0021, 0,
+    16, 0x2049, 0x0021, 0x003F, 0,
+    16, 0x2057, 0x2032, 0x2032, 0x2032, 0x2032, 0,
+    16, 0x205F, 0x0020, 0,
+    9, 0x2070, 0x0030, 0,
+    9, 0x2071, 0x0069, 0,
+    9, 0x2074, 0x0034, 0,
+    9, 0x2075, 0x0035, 0,
+    9, 0x2076, 0x0036, 0,
+    9, 0x2077, 0x0037, 0,
+    9, 0x2078, 0x0038, 0,
+    9, 0x2079, 0x0039, 0,
+    9, 0x207A, 0x002B, 0,
+    9, 0x207B, 0x2212, 0,
+    9, 0x207C, 0x003D, 0,
+    9, 0x207D, 0x0028, 0,
+    9, 0x207E, 0x0029, 0,
+    9, 0x207F, 0x006E, 0,
+    10, 0x2080, 0x0030, 0,
+    10, 0x2081, 0x0031, 0,
+    10, 0x2082, 0x0032, 0,
+    10, 0x2083, 0x0033, 0,
+    10, 0x2084, 0x0034, 0,
+    10, 0x2085, 0x0035, 0,
+    10, 0x2086, 0x0036, 0,
+    10, 0x2087, 0x0037, 0,
+    10, 0x2088, 0x0038, 0,
+    10, 0x2089, 0x0039, 0,
+    10, 0x208A, 0x002B, 0,
+    10, 0x208B, 0x2212, 0,
+    10, 0x208C, 0x003D, 0,
+    10, 0x208D, 0x0028, 0,
+    10, 0x208E, 0x0029, 0,
+    16, 0x20A8, 0x0052, 0x0073, 0,
+    16, 0x2100, 0x0061, 0x002F, 0x0063, 0,
+    16, 0x2101, 0x0061, 0x002F, 0x0073, 0,
+    2, 0x2102, 0x0043, 0,
+    16, 0x2103, 0x00B0, 0x0043, 0,
+    16, 0x2105, 0x0063, 0x002F, 0x006F, 0,
+    16, 0x2106, 0x0063, 0x002F, 0x0075, 0,
+    16, 0x2107, 0x0190, 0,
+    16, 0x2109, 0x00B0, 0x0046, 0,
+    2, 0x210A, 0x0067, 0,
+    2, 0x210B, 0x0048, 0,
+    2, 0x210C, 0x0048, 0,
+    2, 0x210D, 0x0048, 0,
+    2, 0x210E, 0x0068, 0,
+    2, 0x210F, 0x0127, 0,
+    2, 0x2110, 0x0049, 0,
+    2, 0x2111, 0x0049, 0,
+    2, 0x2112, 0x004C, 0,
+    2, 0x2113, 0x006C, 0,
+    2, 0x2115, 0x004E, 0,
+    16, 0x2116, 0x004E, 0x006F, 0,
+    2, 0x2119, 0x0050, 0,
+    2, 0x211A, 0x0051, 0,
+    2, 0x211B, 0x0052, 0,
+    2, 0x211C, 0x0052, 0,
+    2, 0x211D, 0x0052, 0,
+    9, 0x2120, 0x0053, 0x004D, 0,
+    16, 0x2121, 0x0054, 0x0045, 0x004C, 0,
+    9, 0x2122, 0x0054, 0x004D, 0,
+    2, 0x2124, 0x005A, 0,
+    1, 0x2126, 0x03A9, 0,
+    2, 0x2128, 0x005A, 0,
+    1, 0x212A, 0x004B, 0,
+    1, 0x212B, 0x00C5, 0,
+    2, 0x212C, 0x0042, 0,
+    2, 0x212D, 0x0043, 0,
+    2, 0x212F, 0x0065, 0,
+    2, 0x2130, 0x0045, 0,
+    2, 0x2131, 0x0046, 0,
+    2, 0x2133, 0x004D, 0,
+    2, 0x2134, 0x006F, 0,
+    16, 0x2135, 0x05D0, 0,
+    16, 0x2136, 0x05D1, 0,
+    16, 0x2137, 0x05D2, 0,
+    16, 0x2138, 0x05D3, 0,
+    2, 0x2139, 0x0069, 0,
+    2, 0x213D, 0x03B3, 0,
+    2, 0x213E, 0x0393, 0,
+    2, 0x213F, 0x03A0, 0,
+    2, 0x2140, 0x2211, 0,
+    2, 0x2145, 0x0044, 0,
+    2, 0x2146, 0x0064, 0,
+    2, 0x2147, 0x0065, 0,
+    2, 0x2148, 0x0069, 0,
+    2, 0x2149, 0x006A, 0,
+    17, 0x2153, 0x0031, 0x2044, 0x0033, 0,
+    17, 0x2154, 0x0032, 0x2044, 0x0033, 0,
+    17, 0x2155, 0x0031, 0x2044, 0x0035, 0,
+    17, 0x2156, 0x0032, 0x2044, 0x0035, 0,
+    17, 0x2157, 0x0033, 0x2044, 0x0035, 0,
+    17, 0x2158, 0x0034, 0x2044, 0x0035, 0,
+    17, 0x2159, 0x0031, 0x2044, 0x0036, 0,
+    17, 0x215A, 0x0035, 0x2044, 0x0036, 0,
+    17, 0x215B, 0x0031, 0x2044, 0x0038, 0,
+    17, 0x215C, 0x0033, 0x2044, 0x0038, 0,
+    17, 0x215D, 0x0035, 0x2044, 0x0038, 0,
+    17, 0x215E, 0x0037, 0x2044, 0x0038, 0,
+    17, 0x215F, 0x0031, 0x2044, 0,
+    16, 0x2160, 0x0049, 0,
+    16, 0x2161, 0x0049, 0x0049, 0,
+    16, 0x2162, 0x0049, 0x0049, 0x0049, 0,
+    16, 0x2163, 0x0049, 0x0056, 0,
+    16, 0x2164, 0x0056, 0,
+    16, 0x2165, 0x0056, 0x0049, 0,
+    16, 0x2166, 0x0056, 0x0049, 0x0049, 0,
+    16, 0x2167, 0x0056, 0x0049, 0x0049, 0x0049, 0,
+    16, 0x2168, 0x0049, 0x0058, 0,
+    16, 0x2169, 0x0058, 0,
+    16, 0x216A, 0x0058, 0x0049, 0,
+    16, 0x216B, 0x0058, 0x0049, 0x0049, 0,
+    16, 0x216C, 0x004C, 0,
+    16, 0x216D, 0x0043, 0,
+    16, 0x216E, 0x0044, 0,
+    16, 0x216F, 0x004D, 0,
+    16, 0x2170, 0x0069, 0,
+    16, 0x2171, 0x0069, 0x0069, 0,
+    16, 0x2172, 0x0069, 0x0069, 0x0069, 0,
+    16, 0x2173, 0x0069, 0x0076, 0,
+    16, 0x2174, 0x0076, 0,
+    16, 0x2175, 0x0076, 0x0069, 0,
+    16, 0x2176, 0x0076, 0x0069, 0x0069, 0,
+    16, 0x2177, 0x0076, 0x0069, 0x0069, 0x0069, 0,
+    16, 0x2178, 0x0069, 0x0078, 0,
+    16, 0x2179, 0x0078, 0,
+    16, 0x217A, 0x0078, 0x0069, 0,
+    16, 0x217B, 0x0078, 0x0069, 0x0069, 0,
+    16, 0x217C, 0x006C, 0,
+    16, 0x217D, 0x0063, 0,
+    16, 0x217E, 0x0064, 0,
+    16, 0x217F, 0x006D, 0,
+    1, 0x219A, 0x2190, 0x0338, 0,
+    1, 0x219B, 0x2192, 0x0338, 0,
+    1, 0x21AE, 0x2194, 0x0338, 0,
+    1, 0x21CD, 0x21D0, 0x0338, 0,
+    1, 0x21CE, 0x21D4, 0x0338, 0,
+    1, 0x21CF, 0x21D2, 0x0338, 0,
+    1, 0x2204, 0x2203, 0x0338, 0,
+    1, 0x2209, 0x2208, 0x0338, 0,
+    1, 0x220C, 0x220B, 0x0338, 0,
+    1, 0x2224, 0x2223, 0x0338, 0,
+    1, 0x2226, 0x2225, 0x0338, 0,
+    16, 0x222C, 0x222B, 0x222B, 0,
+    16, 0x222D, 0x222B, 0x222B, 0x222B, 0,
+    16, 0x222F, 0x222E, 0x222E, 0,
+    16, 0x2230, 0x222E, 0x222E, 0x222E, 0,
+    1, 0x2241, 0x223C, 0x0338, 0,
+    1, 0x2244, 0x2243, 0x0338, 0,
+    1, 0x2247, 0x2245, 0x0338, 0,
+    1, 0x2249, 0x2248, 0x0338, 0,
+    1, 0x2260, 0x003D, 0x0338, 0,
+    1, 0x2262, 0x2261, 0x0338, 0,
+    1, 0x226D, 0x224D, 0x0338, 0,
+    1, 0x226E, 0x003C, 0x0338, 0,
+    1, 0x226F, 0x003E, 0x0338, 0,
+    1, 0x2270, 0x2264, 0x0338, 0,
+    1, 0x2271, 0x2265, 0x0338, 0,
+    1, 0x2274, 0x2272, 0x0338, 0,
+    1, 0x2275, 0x2273, 0x0338, 0,
+    1, 0x2278, 0x2276, 0x0338, 0,
+    1, 0x2279, 0x2277, 0x0338, 0,
+    1, 0x2280, 0x227A, 0x0338, 0,
+    1, 0x2281, 0x227B, 0x0338, 0,
+    1, 0x2284, 0x2282, 0x0338, 0,
+    1, 0x2285, 0x2283, 0x0338, 0,
+    1, 0x2288, 0x2286, 0x0338, 0,
+    1, 0x2289, 0x2287, 0x0338, 0,
+    1, 0x22AC, 0x22A2, 0x0338, 0,
+    1, 0x22AD, 0x22A8, 0x0338, 0,
+    1, 0x22AE, 0x22A9, 0x0338, 0,
+    1, 0x22AF, 0x22AB, 0x0338, 0,
+    1, 0x22E0, 0x227C, 0x0338, 0,
+    1, 0x22E1, 0x227D, 0x0338, 0,
+    1, 0x22E2, 0x2291, 0x0338, 0,
+    1, 0x22E3, 0x2292, 0x0338, 0,
+    1, 0x22EA, 0x22B2, 0x0338, 0,
+    1, 0x22EB, 0x22B3, 0x0338, 0,
+    1, 0x22EC, 0x22B4, 0x0338, 0,
+    1, 0x22ED, 0x22B5, 0x0338, 0,
+    1, 0x2329, 0x3008, 0,
+    1, 0x232A, 0x3009, 0,
+    8, 0x2460, 0x0031, 0,
+    8, 0x2461, 0x0032, 0,
+    8, 0x2462, 0x0033, 0,
+    8, 0x2463, 0x0034, 0,
+    8, 0x2464, 0x0035, 0,
+    8, 0x2465, 0x0036, 0,
+    8, 0x2466, 0x0037, 0,
+    8, 0x2467, 0x0038, 0,
+    8, 0x2468, 0x0039, 0,
+    8, 0x2469, 0x0031, 0x0030, 0,
+    8, 0x246A, 0x0031, 0x0031, 0,
+    8, 0x246B, 0x0031, 0x0032, 0,
+    8, 0x246C, 0x0031, 0x0033, 0,
+    8, 0x246D, 0x0031, 0x0034, 0,
+    8, 0x246E, 0x0031, 0x0035, 0,
+    8, 0x246F, 0x0031, 0x0036, 0,
+    8, 0x2470, 0x0031, 0x0037, 0,
+    8, 0x2471, 0x0031, 0x0038, 0,
+    8, 0x2472, 0x0031, 0x0039, 0,
+    8, 0x2473, 0x0032, 0x0030, 0,
+    16, 0x2474, 0x0028, 0x0031, 0x0029, 0,
+    16, 0x2475, 0x0028, 0x0032, 0x0029, 0,
+    16, 0x2476, 0x0028, 0x0033, 0x0029, 0,
+    16, 0x2477, 0x0028, 0x0034, 0x0029, 0,
+    16, 0x2478, 0x0028, 0x0035, 0x0029, 0,
+    16, 0x2479, 0x0028, 0x0036, 0x0029, 0,
+    16, 0x247A, 0x0028, 0x0037, 0x0029, 0,
+    16, 0x247B, 0x0028, 0x0038, 0x0029, 0,
+    16, 0x247C, 0x0028, 0x0039, 0x0029, 0,
+    16, 0x247D, 0x0028, 0x0031, 0x0030, 0x0029, 0,
+    16, 0x247E, 0x0028, 0x0031, 0x0031, 0x0029, 0,
+    16, 0x247F, 0x0028, 0x0031, 0x0032, 0x0029, 0,
+    16, 0x2480, 0x0028, 0x0031, 0x0033, 0x0029, 0,
+    16, 0x2481, 0x0028, 0x0031, 0x0034, 0x0029, 0,
+    16, 0x2482, 0x0028, 0x0031, 0x0035, 0x0029, 0,
+    16, 0x2483, 0x0028, 0x0031, 0x0036, 0x0029, 0,
+    16, 0x2484, 0x0028, 0x0031, 0x0037, 0x0029, 0,
+    16, 0x2485, 0x0028, 0x0031, 0x0038, 0x0029, 0,
+    16, 0x2486, 0x0028, 0x0031, 0x0039, 0x0029, 0,
+    16, 0x2487, 0x0028, 0x0032, 0x0030, 0x0029, 0,
+    16, 0x2488, 0x0031, 0x002E, 0,
+    16, 0x2489, 0x0032, 0x002E, 0,
+    16, 0x248A, 0x0033, 0x002E, 0,
+    16, 0x248B, 0x0034, 0x002E, 0,
+    16, 0x248C, 0x0035, 0x002E, 0,
+    16, 0x248D, 0x0036, 0x002E, 0,
+    16, 0x248E, 0x0037, 0x002E, 0,
+    16, 0x248F, 0x0038, 0x002E, 0,
+    16, 0x2490, 0x0039, 0x002E, 0,
+    16, 0x2491, 0x0031, 0x0030, 0x002E, 0,
+    16, 0x2492, 0x0031, 0x0031, 0x002E, 0,
+    16, 0x2493, 0x0031, 0x0032, 0x002E, 0,
+    16, 0x2494, 0x0031, 0x0033, 0x002E, 0,
+    16, 0x2495, 0x0031, 0x0034, 0x002E, 0,
+    16, 0x2496, 0x0031, 0x0035, 0x002E, 0,
+    16, 0x2497, 0x0031, 0x0036, 0x002E, 0,
+    16, 0x2498, 0x0031, 0x0037, 0x002E, 0,
+    16, 0x2499, 0x0031, 0x0038, 0x002E, 0,
+    16, 0x249A, 0x0031, 0x0039, 0x002E, 0,
+    16, 0x249B, 0x0032, 0x0030, 0x002E, 0,
+    16, 0x249C, 0x0028, 0x0061, 0x0029, 0,
+    16, 0x249D, 0x0028, 0x0062, 0x0029, 0,
+    16, 0x249E, 0x0028, 0x0063, 0x0029, 0,
+    16, 0x249F, 0x0028, 0x0064, 0x0029, 0,
+    16, 0x24A0, 0x0028, 0x0065, 0x0029, 0,
+    16, 0x24A1, 0x0028, 0x0066, 0x0029, 0,
+    16, 0x24A2, 0x0028, 0x0067, 0x0029, 0,
+    16, 0x24A3, 0x0028, 0x0068, 0x0029, 0,
+    16, 0x24A4, 0x0028, 0x0069, 0x0029, 0,
+    16, 0x24A5, 0x0028, 0x006A, 0x0029, 0,
+    16, 0x24A6, 0x0028, 0x006B, 0x0029, 0,
+    16, 0x24A7, 0x0028, 0x006C, 0x0029, 0,
+    16, 0x24A8, 0x0028, 0x006D, 0x0029, 0,
+    16, 0x24A9, 0x0028, 0x006E, 0x0029, 0,
+    16, 0x24AA, 0x0028, 0x006F, 0x0029, 0,
+    16, 0x24AB, 0x0028, 0x0070, 0x0029, 0,
+    16, 0x24AC, 0x0028, 0x0071, 0x0029, 0,
+    16, 0x24AD, 0x0028, 0x0072, 0x0029, 0,
+    16, 0x24AE, 0x0028, 0x0073, 0x0029, 0,
+    16, 0x24AF, 0x0028, 0x0074, 0x0029, 0,
+    16, 0x24B0, 0x0028, 0x0075, 0x0029, 0,
+    16, 0x24B1, 0x0028, 0x0076, 0x0029, 0,
+    16, 0x24B2, 0x0028, 0x0077, 0x0029, 0,
+    16, 0x24B3, 0x0028, 0x0078, 0x0029, 0,
+    16, 0x24B4, 0x0028, 0x0079, 0x0029, 0,
+    16, 0x24B5, 0x0028, 0x007A, 0x0029, 0,
+    8, 0x24B6, 0x0041, 0,
+    8, 0x24B7, 0x0042, 0,
+    8, 0x24B8, 0x0043, 0,
+    8, 0x24B9, 0x0044, 0,
+    8, 0x24BA, 0x0045, 0,
+    8, 0x24BB, 0x0046, 0,
+    8, 0x24BC, 0x0047, 0,
+    8, 0x24BD, 0x0048, 0,
+    8, 0x24BE, 0x0049, 0,
+    8, 0x24BF, 0x004A, 0,
+    8, 0x24C0, 0x004B, 0,
+    8, 0x24C1, 0x004C, 0,
+    8, 0x24C2, 0x004D, 0,
+    8, 0x24C3, 0x004E, 0,
+    8, 0x24C4, 0x004F, 0,
+    8, 0x24C5, 0x0050, 0,
+    8, 0x24C6, 0x0051, 0,
+    8, 0x24C7, 0x0052, 0,
+    8, 0x24C8, 0x0053, 0,
+    8, 0x24C9, 0x0054, 0,
+    8, 0x24CA, 0x0055, 0,
+    8, 0x24CB, 0x0056, 0,
+    8, 0x24CC, 0x0057, 0,
+    8, 0x24CD, 0x0058, 0,
+    8, 0x24CE, 0x0059, 0,
+    8, 0x24CF, 0x005A, 0,
+    8, 0x24D0, 0x0061, 0,
+    8, 0x24D1, 0x0062, 0,
+    8, 0x24D2, 0x0063, 0,
+    8, 0x24D3, 0x0064, 0,
+    8, 0x24D4, 0x0065, 0,
+    8, 0x24D5, 0x0066, 0,
+    8, 0x24D6, 0x0067, 0,
+    8, 0x24D7, 0x0068, 0,
+    8, 0x24D8, 0x0069, 0,
+    8, 0x24D9, 0x006A, 0,
+    8, 0x24DA, 0x006B, 0,
+    8, 0x24DB, 0x006C, 0,
+    8, 0x24DC, 0x006D, 0,
+    8, 0x24DD, 0x006E, 0,
+    8, 0x24DE, 0x006F, 0,
+    8, 0x24DF, 0x0070, 0,
+    8, 0x24E0, 0x0071, 0,
+    8, 0x24E1, 0x0072, 0,
+    8, 0x24E2, 0x0073, 0,
+    8, 0x24E3, 0x0074, 0,
+    8, 0x24E4, 0x0075, 0,
+    8, 0x24E5, 0x0076, 0,
+    8, 0x24E6, 0x0077, 0,
+    8, 0x24E7, 0x0078, 0,
+    8, 0x24E8, 0x0079, 0,
+    8, 0x24E9, 0x007A, 0,
+    8, 0x24EA, 0x0030, 0,
+    16, 0x2A0C, 0x222B, 0x222B, 0x222B, 0x222B, 0,
+    16, 0x2A74, 0x003A, 0x003A, 0x003D, 0,
+    16, 0x2A75, 0x003D, 0x003D, 0,
+    16, 0x2A76, 0x003D, 0x003D, 0x003D, 0,
+    1, 0x2ADC, 0x2ADD, 0x0338, 0,
+    16, 0x2E9F, 0x6BCD, 0,
+    16, 0x2EF3, 0x9F9F, 0,
+    16, 0x2F00, 0x4E00, 0,
+    16, 0x2F01, 0x4E28, 0,
+    16, 0x2F02, 0x4E36, 0,
+    16, 0x2F03, 0x4E3F, 0,
+    16, 0x2F04, 0x4E59, 0,
+    16, 0x2F05, 0x4E85, 0,
+    16, 0x2F06, 0x4E8C, 0,
+    16, 0x2F07, 0x4EA0, 0,
+    16, 0x2F08, 0x4EBA, 0,
+    16, 0x2F09, 0x513F, 0,
+    16, 0x2F0A, 0x5165, 0,
+    16, 0x2F0B, 0x516B, 0,
+    16, 0x2F0C, 0x5182, 0,
+    16, 0x2F0D, 0x5196, 0,
+    16, 0x2F0E, 0x51AB, 0,
+    16, 0x2F0F, 0x51E0, 0,
+    16, 0x2F10, 0x51F5, 0,
+    16, 0x2F11, 0x5200, 0,
+    16, 0x2F12, 0x529B, 0,
+    16, 0x2F13, 0x52F9, 0,
+    16, 0x2F14, 0x5315, 0,
+    16, 0x2F15, 0x531A, 0,
+    16, 0x2F16, 0x5338, 0,
+    16, 0x2F17, 0x5341, 0,
+    16, 0x2F18, 0x535C, 0,
+    16, 0x2F19, 0x5369, 0,
+    16, 0x2F1A, 0x5382, 0,
+    16, 0x2F1B, 0x53B6, 0,
+    16, 0x2F1C, 0x53C8, 0,
+    16, 0x2F1D, 0x53E3, 0,
+    16, 0x2F1E, 0x56D7, 0,
+    16, 0x2F1F, 0x571F, 0,
+    16, 0x2F20, 0x58EB, 0,
+    16, 0x2F21, 0x5902, 0,
+    16, 0x2F22, 0x590A, 0,
+    16, 0x2F23, 0x5915, 0,
+    16, 0x2F24, 0x5927, 0,
+    16, 0x2F25, 0x5973, 0,
+    16, 0x2F26, 0x5B50, 0,
+    16, 0x2F27, 0x5B80, 0,
+    16, 0x2F28, 0x5BF8, 0,
+    16, 0x2F29, 0x5C0F, 0,
+    16, 0x2F2A, 0x5C22, 0,
+    16, 0x2F2B, 0x5C38, 0,
+    16, 0x2F2C, 0x5C6E, 0,
+    16, 0x2F2D, 0x5C71, 0,
+    16, 0x2F2E, 0x5DDB, 0,
+    16, 0x2F2F, 0x5DE5, 0,
+    16, 0x2F30, 0x5DF1, 0,
+    16, 0x2F31, 0x5DFE, 0,
+    16, 0x2F32, 0x5E72, 0,
+    16, 0x2F33, 0x5E7A, 0,
+    16, 0x2F34, 0x5E7F, 0,
+    16, 0x2F35, 0x5EF4, 0,
+    16, 0x2F36, 0x5EFE, 0,
+    16, 0x2F37, 0x5F0B, 0,
+    16, 0x2F38, 0x5F13, 0,
+    16, 0x2F39, 0x5F50, 0,
+    16, 0x2F3A, 0x5F61, 0,
+    16, 0x2F3B, 0x5F73, 0,
+    16, 0x2F3C, 0x5FC3, 0,
+    16, 0x2F3D, 0x6208, 0,
+    16, 0x2F3E, 0x6236, 0,
+    16, 0x2F3F, 0x624B, 0,
+    16, 0x2F40, 0x652F, 0,
+    16, 0x2F41, 0x6534, 0,
+    16, 0x2F42, 0x6587, 0,
+    16, 0x2F43, 0x6597, 0,
+    16, 0x2F44, 0x65A4, 0,
+    16, 0x2F45, 0x65B9, 0,
+    16, 0x2F46, 0x65E0, 0,
+    16, 0x2F47, 0x65E5, 0,
+    16, 0x2F48, 0x66F0, 0,
+    16, 0x2F49, 0x6708, 0,
+    16, 0x2F4A, 0x6728, 0,
+    16, 0x2F4B, 0x6B20, 0,
+    16, 0x2F4C, 0x6B62, 0,
+    16, 0x2F4D, 0x6B79, 0,
+    16, 0x2F4E, 0x6BB3, 0,
+    16, 0x2F4F, 0x6BCB, 0,
+    16, 0x2F50, 0x6BD4, 0,
+    16, 0x2F51, 0x6BDB, 0,
+    16, 0x2F52, 0x6C0F, 0,
+    16, 0x2F53, 0x6C14, 0,
+    16, 0x2F54, 0x6C34, 0,
+    16, 0x2F55, 0x706B, 0,
+    16, 0x2F56, 0x722A, 0,
+    16, 0x2F57, 0x7236, 0,
+    16, 0x2F58, 0x723B, 0,
+    16, 0x2F59, 0x723F, 0,
+    16, 0x2F5A, 0x7247, 0,
+    16, 0x2F5B, 0x7259, 0,
+    16, 0x2F5C, 0x725B, 0,
+    16, 0x2F5D, 0x72AC, 0,
+    16, 0x2F5E, 0x7384, 0,
+    16, 0x2F5F, 0x7389, 0,
+    16, 0x2F60, 0x74DC, 0,
+    16, 0x2F61, 0x74E6, 0,
+    16, 0x2F62, 0x7518, 0,
+    16, 0x2F63, 0x751F, 0,
+    16, 0x2F64, 0x7528, 0,
+    16, 0x2F65, 0x7530, 0,
+    16, 0x2F66, 0x758B, 0,
+    16, 0x2F67, 0x7592, 0,
+    16, 0x2F68, 0x7676, 0,
+    16, 0x2F69, 0x767D, 0,
+    16, 0x2F6A, 0x76AE, 0,
+    16, 0x2F6B, 0x76BF, 0,
+    16, 0x2F6C, 0x76EE, 0,
+    16, 0x2F6D, 0x77DB, 0,
+    16, 0x2F6E, 0x77E2, 0,
+    16, 0x2F6F, 0x77F3, 0,
+    16, 0x2F70, 0x793A, 0,
+    16, 0x2F71, 0x79B8, 0,
+    16, 0x2F72, 0x79BE, 0,
+    16, 0x2F73, 0x7A74, 0,
+    16, 0x2F74, 0x7ACB, 0,
+    16, 0x2F75, 0x7AF9, 0,
+    16, 0x2F76, 0x7C73, 0,
+    16, 0x2F77, 0x7CF8, 0,
+    16, 0x2F78, 0x7F36, 0,
+    16, 0x2F79, 0x7F51, 0,
+    16, 0x2F7A, 0x7F8A, 0,
+    16, 0x2F7B, 0x7FBD, 0,
+    16, 0x2F7C, 0x8001, 0,
+    16, 0x2F7D, 0x800C, 0,
+    16, 0x2F7E, 0x8012, 0,
+    16, 0x2F7F, 0x8033, 0,
+    16, 0x2F80, 0x807F, 0,
+    16, 0x2F81, 0x8089, 0,
+    16, 0x2F82, 0x81E3, 0,
+    16, 0x2F83, 0x81EA, 0,
+    16, 0x2F84, 0x81F3, 0,
+    16, 0x2F85, 0x81FC, 0,
+    16, 0x2F86, 0x820C, 0,
+    16, 0x2F87, 0x821B, 0,
+    16, 0x2F88, 0x821F, 0,
+    16, 0x2F89, 0x826E, 0,
+    16, 0x2F8A, 0x8272, 0,
+    16, 0x2F8B, 0x8278, 0,
+    16, 0x2F8C, 0x864D, 0,
+    16, 0x2F8D, 0x866B, 0,
+    16, 0x2F8E, 0x8840, 0,
+    16, 0x2F8F, 0x884C, 0,
+    16, 0x2F90, 0x8863, 0,
+    16, 0x2F91, 0x897E, 0,
+    16, 0x2F92, 0x898B, 0,
+    16, 0x2F93, 0x89D2, 0,
+    16, 0x2F94, 0x8A00, 0,
+    16, 0x2F95, 0x8C37, 0,
+    16, 0x2F96, 0x8C46, 0,
+    16, 0x2F97, 0x8C55, 0,
+    16, 0x2F98, 0x8C78, 0,
+    16, 0x2F99, 0x8C9D, 0,
+    16, 0x2F9A, 0x8D64, 0,
+    16, 0x2F9B, 0x8D70, 0,
+    16, 0x2F9C, 0x8DB3, 0,
+    16, 0x2F9D, 0x8EAB, 0,
+    16, 0x2F9E, 0x8ECA, 0,
+    16, 0x2F9F, 0x8F9B, 0,
+    16, 0x2FA0, 0x8FB0, 0,
+    16, 0x2FA1, 0x8FB5, 0,
+    16, 0x2FA2, 0x9091, 0,
+    16, 0x2FA3, 0x9149, 0,
+    16, 0x2FA4, 0x91C6, 0,
+    16, 0x2FA5, 0x91CC, 0,
+    16, 0x2FA6, 0x91D1, 0,
+    16, 0x2FA7, 0x9577, 0,
+    16, 0x2FA8, 0x9580, 0,
+    16, 0x2FA9, 0x961C, 0,
+    16, 0x2FAA, 0x96B6, 0,
+    16, 0x2FAB, 0x96B9, 0,
+    16, 0x2FAC, 0x96E8, 0,
+    16, 0x2FAD, 0x9751, 0,
+    16, 0x2FAE, 0x975E, 0,
+    16, 0x2FAF, 0x9762, 0,
+    16, 0x2FB0, 0x9769, 0,
+    16, 0x2FB1, 0x97CB, 0,
+    16, 0x2FB2, 0x97ED, 0,
+    16, 0x2FB3, 0x97F3, 0,
+    16, 0x2FB4, 0x9801, 0,
+    16, 0x2FB5, 0x98A8, 0,
+    16, 0x2FB6, 0x98DB, 0,
+    16, 0x2FB7, 0x98DF, 0,
+    16, 0x2FB8, 0x9996, 0,
+    16, 0x2FB9, 0x9999, 0,
+    16, 0x2FBA, 0x99AC, 0,
+    16, 0x2FBB, 0x9AA8, 0,
+    16, 0x2FBC, 0x9AD8, 0,
+    16, 0x2FBD, 0x9ADF, 0,
+    16, 0x2FBE, 0x9B25, 0,
+    16, 0x2FBF, 0x9B2F, 0,
+    16, 0x2FC0, 0x9B32, 0,
+    16, 0x2FC1, 0x9B3C, 0,
+    16, 0x2FC2, 0x9B5A, 0,
+    16, 0x2FC3, 0x9CE5, 0,
+    16, 0x2FC4, 0x9E75, 0,
+    16, 0x2FC5, 0x9E7F, 0,
+    16, 0x2FC6, 0x9EA5, 0,
+    16, 0x2FC7, 0x9EBB, 0,
+    16, 0x2FC8, 0x9EC3, 0,
+    16, 0x2FC9, 0x9ECD, 0,
+    16, 0x2FCA, 0x9ED1, 0,
+    16, 0x2FCB, 0x9EF9, 0,
+    16, 0x2FCC, 0x9EFD, 0,
+    16, 0x2FCD, 0x9F0E, 0,
+    16, 0x2FCE, 0x9F13, 0,
+    16, 0x2FCF, 0x9F20, 0,
+    16, 0x2FD0, 0x9F3B, 0,
+    16, 0x2FD1, 0x9F4A, 0,
+    16, 0x2FD2, 0x9F52, 0,
+    16, 0x2FD3, 0x9F8D, 0,
+    16, 0x2FD4, 0x9F9C, 0,
+    16, 0x2FD5, 0x9FA0, 0,
+    12, 0x3000, 0x0020, 0,
+    16, 0x3036, 0x3012, 0,
+    16, 0x3038, 0x5341, 0,
+    16, 0x3039, 0x5344, 0,
+    16, 0x303A, 0x5345, 0,
+    1, 0x304C, 0x304B, 0x3099, 0,
+    1, 0x304E, 0x304D, 0x3099, 0,
+    1, 0x3050, 0x304F, 0x3099, 0,
+    1, 0x3052, 0x3051, 0x3099, 0,
+    1, 0x3054, 0x3053, 0x3099, 0,
+    1, 0x3056, 0x3055, 0x3099, 0,
+    1, 0x3058, 0x3057, 0x3099, 0,
+    1, 0x305A, 0x3059, 0x3099, 0,
+    1, 0x305C, 0x305B, 0x3099, 0,
+    1, 0x305E, 0x305D, 0x3099, 0,
+    1, 0x3060, 0x305F, 0x3099, 0,
+    1, 0x3062, 0x3061, 0x3099, 0,
+    1, 0x3065, 0x3064, 0x3099, 0,
+    1, 0x3067, 0x3066, 0x3099, 0,
+    1, 0x3069, 0x3068, 0x3099, 0,
+    1, 0x3070, 0x306F, 0x3099, 0,
+    1, 0x3071, 0x306F, 0x309A, 0,
+    1, 0x3073, 0x3072, 0x3099, 0,
+    1, 0x3074, 0x3072, 0x309A, 0,
+    1, 0x3076, 0x3075, 0x3099, 0,
+    1, 0x3077, 0x3075, 0x309A, 0,
+    1, 0x3079, 0x3078, 0x3099, 0,
+    1, 0x307A, 0x3078, 0x309A, 0,
+    1, 0x307C, 0x307B, 0x3099, 0,
+    1, 0x307D, 0x307B, 0x309A, 0,
+    1, 0x3094, 0x3046, 0x3099, 0,
+    16, 0x309B, 0x0020, 0x3099, 0,
+    16, 0x309C, 0x0020, 0x309A, 0,
+    1, 0x309E, 0x309D, 0x3099, 0,
+    11, 0x309F, 0x3088, 0x308A, 0,
+    1, 0x30AC, 0x30AB, 0x3099, 0,
+    1, 0x30AE, 0x30AD, 0x3099, 0,
+    1, 0x30B0, 0x30AF, 0x3099, 0,
+    1, 0x30B2, 0x30B1, 0x3099, 0,
+    1, 0x30B4, 0x30B3, 0x3099, 0,
+    1, 0x30B6, 0x30B5, 0x3099, 0,
+    1, 0x30B8, 0x30B7, 0x3099, 0,
+    1, 0x30BA, 0x30B9, 0x3099, 0,
+    1, 0x30BC, 0x30BB, 0x3099, 0,
+    1, 0x30BE, 0x30BD, 0x3099, 0,
+    1, 0x30C0, 0x30BF, 0x3099, 0,
+    1, 0x30C2, 0x30C1, 0x3099, 0,
+    1, 0x30C5, 0x30C4, 0x3099, 0,
+    1, 0x30C7, 0x30C6, 0x3099, 0,
+    1, 0x30C9, 0x30C8, 0x3099, 0,
+    1, 0x30D0, 0x30CF, 0x3099, 0,
+    1, 0x30D1, 0x30CF, 0x309A, 0,
+    1, 0x30D3, 0x30D2, 0x3099, 0,
+    1, 0x30D4, 0x30D2, 0x309A, 0,
+    1, 0x30D6, 0x30D5, 0x3099, 0,
+    1, 0x30D7, 0x30D5, 0x309A, 0,
+    1, 0x30D9, 0x30D8, 0x3099, 0,
+    1, 0x30DA, 0x30D8, 0x309A, 0,
+    1, 0x30DC, 0x30DB, 0x3099, 0,
+    1, 0x30DD, 0x30DB, 0x309A, 0,
+    1, 0x30F4, 0x30A6, 0x3099, 0,
+    1, 0x30F7, 0x30EF, 0x3099, 0,
+    1, 0x30F8, 0x30F0, 0x3099, 0,
+    1, 0x30F9, 0x30F1, 0x3099, 0,
+    1, 0x30FA, 0x30F2, 0x3099, 0,
+    1, 0x30FE, 0x30FD, 0x3099, 0,
+    11, 0x30FF, 0x30B3, 0x30C8, 0,
+    16, 0x3131, 0x1100, 0,
+    16, 0x3132, 0x1101, 0,
+    16, 0x3133, 0x11AA, 0,
+    16, 0x3134, 0x1102, 0,
+    16, 0x3135, 0x11AC, 0,
+    16, 0x3136, 0x11AD, 0,
+    16, 0x3137, 0x1103, 0,
+    16, 0x3138, 0x1104, 0,
+    16, 0x3139, 0x1105, 0,
+    16, 0x313A, 0x11B0, 0,
+    16, 0x313B, 0x11B1, 0,
+    16, 0x313C, 0x11B2, 0,
+    16, 0x313D, 0x11B3, 0,
+    16, 0x313E, 0x11B4, 0,
+    16, 0x313F, 0x11B5, 0,
+    16, 0x3140, 0x111A, 0,
+    16, 0x3141, 0x1106, 0,
+    16, 0x3142, 0x1107, 0,
+    16, 0x3143, 0x1108, 0,
+    16, 0x3144, 0x1121, 0,
+    16, 0x3145, 0x1109, 0,
+    16, 0x3146, 0x110A, 0,
+    16, 0x3147, 0x110B, 0,
+    16, 0x3148, 0x110C, 0,
+    16, 0x3149, 0x110D, 0,
+    16, 0x314A, 0x110E, 0,
+    16, 0x314B, 0x110F, 0,
+    16, 0x314C, 0x1110, 0,
+    16, 0x314D, 0x1111, 0,
+    16, 0x314E, 0x1112, 0,
+    16, 0x314F, 0x1161, 0,
+    16, 0x3150, 0x1162, 0,
+    16, 0x3151, 0x1163, 0,
+    16, 0x3152, 0x1164, 0,
+    16, 0x3153, 0x1165, 0,
+    16, 0x3154, 0x1166, 0,
+    16, 0x3155, 0x1167, 0,
+    16, 0x3156, 0x1168, 0,
+    16, 0x3157, 0x1169, 0,
+    16, 0x3158, 0x116A, 0,
+    16, 0x3159, 0x116B, 0,
+    16, 0x315A, 0x116C, 0,
+    16, 0x315B, 0x116D, 0,
+    16, 0x315C, 0x116E, 0,
+    16, 0x315D, 0x116F, 0,
+    16, 0x315E, 0x1170, 0,
+    16, 0x315F, 0x1171, 0,
+    16, 0x3160, 0x1172, 0,
+    16, 0x3161, 0x1173, 0,
+    16, 0x3162, 0x1174, 0,
+    16, 0x3163, 0x1175, 0,
+    16, 0x3164, 0x1160, 0,
+    16, 0x3165, 0x1114, 0,
+    16, 0x3166, 0x1115, 0,
+    16, 0x3167, 0x11C7, 0,
+    16, 0x3168, 0x11C8, 0,
+    16, 0x3169, 0x11CC, 0,
+    16, 0x316A, 0x11CE, 0,
+    16, 0x316B, 0x11D3, 0,
+    16, 0x316C, 0x11D7, 0,
+    16, 0x316D, 0x11D9, 0,
+    16, 0x316E, 0x111C, 0,
+    16, 0x316F, 0x11DD, 0,
+    16, 0x3170, 0x11DF, 0,
+    16, 0x3171, 0x111D, 0,
+    16, 0x3172, 0x111E, 0,
+    16, 0x3173, 0x1120, 0,
+    16, 0x3174, 0x1122, 0,
+    16, 0x3175, 0x1123, 0,
+    16, 0x3176, 0x1127, 0,
+    16, 0x3177, 0x1129, 0,
+    16, 0x3178, 0x112B, 0,
+    16, 0x3179, 0x112C, 0,
+    16, 0x317A, 0x112D, 0,
+    16, 0x317B, 0x112E, 0,
+    16, 0x317C, 0x112F, 0,
+    16, 0x317D, 0x1132, 0,
+    16, 0x317E, 0x1136, 0,
+    16, 0x317F, 0x1140, 0,
+    16, 0x3180, 0x1147, 0,
+    16, 0x3181, 0x114C, 0,
+    16, 0x3182, 0x11F1, 0,
+    16, 0x3183, 0x11F2, 0,
+    16, 0x3184, 0x1157, 0,
+    16, 0x3185, 0x1158, 0,
+    16, 0x3186, 0x1159, 0,
+    16, 0x3187, 0x1184, 0,
+    16, 0x3188, 0x1185, 0,
+    16, 0x3189, 0x1188, 0,
+    16, 0x318A, 0x1191, 0,
+    16, 0x318B, 0x1192, 0,
+    16, 0x318C, 0x1194, 0,
+    16, 0x318D, 0x119E, 0,
+    16, 0x318E, 0x11A1, 0,
+    9, 0x3192, 0x4E00, 0,
+    9, 0x3193, 0x4E8C, 0,
+    9, 0x3194, 0x4E09, 0,
+    9, 0x3195, 0x56DB, 0,
+    9, 0x3196, 0x4E0A, 0,
+    9, 0x3197, 0x4E2D, 0,
+    9, 0x3198, 0x4E0B, 0,
+    9, 0x3199, 0x7532, 0,
+    9, 0x319A, 0x4E59, 0,
+    9, 0x319B, 0x4E19, 0,
+    9, 0x319C, 0x4E01, 0,
+    9, 0x319D, 0x5929, 0,
+    9, 0x319E, 0x5730, 0,
+    9, 0x319F, 0x4EBA, 0,
+    16, 0x3200, 0x0028, 0x1100, 0x0029, 0,
+    16, 0x3201, 0x0028, 0x1102, 0x0029, 0,
+    16, 0x3202, 0x0028, 0x1103, 0x0029, 0,
+    16, 0x3203, 0x0028, 0x1105, 0x0029, 0,
+    16, 0x3204, 0x0028, 0x1106, 0x0029, 0,
+    16, 0x3205, 0x0028, 0x1107, 0x0029, 0,
+    16, 0x3206, 0x0028, 0x1109, 0x0029, 0,
+    16, 0x3207, 0x0028, 0x110B, 0x0029, 0,
+    16, 0x3208, 0x0028, 0x110C, 0x0029, 0,
+    16, 0x3209, 0x0028, 0x110E, 0x0029, 0,
+    16, 0x320A, 0x0028, 0x110F, 0x0029, 0,
+    16, 0x320B, 0x0028, 0x1110, 0x0029, 0,
+    16, 0x320C, 0x0028, 0x1111, 0x0029, 0,
+    16, 0x320D, 0x0028, 0x1112, 0x0029, 0,
+    16, 0x320E, 0x0028, 0x1100, 0x1161, 0x0029, 0,
+    16, 0x320F, 0x0028, 0x1102, 0x1161, 0x0029, 0,
+    16, 0x3210, 0x0028, 0x1103, 0x1161, 0x0029, 0,
+    16, 0x3211, 0x0028, 0x1105, 0x1161, 0x0029, 0,
+    16, 0x3212, 0x0028, 0x1106, 0x1161, 0x0029, 0,
+    16, 0x3213, 0x0028, 0x1107, 0x1161, 0x0029, 0,
+    16, 0x3214, 0x0028, 0x1109, 0x1161, 0x0029, 0,
+    16, 0x3215, 0x0028, 0x110B, 0x1161, 0x0029, 0,
+    16, 0x3216, 0x0028, 0x110C, 0x1161, 0x0029, 0,
+    16, 0x3217, 0x0028, 0x110E, 0x1161, 0x0029, 0,
+    16, 0x3218, 0x0028, 0x110F, 0x1161, 0x0029, 0,
+    16, 0x3219, 0x0028, 0x1110, 0x1161, 0x0029, 0,
+    16, 0x321A, 0x0028, 0x1111, 0x1161, 0x0029, 0,
+    16, 0x321B, 0x0028, 0x1112, 0x1161, 0x0029, 0,
+    16, 0x321C, 0x0028, 0x110C, 0x116E, 0x0029, 0,
+    16, 0x3220, 0x0028, 0x4E00, 0x0029, 0,
+    16, 0x3221, 0x0028, 0x4E8C, 0x0029, 0,
+    16, 0x3222, 0x0028, 0x4E09, 0x0029, 0,
+    16, 0x3223, 0x0028, 0x56DB, 0x0029, 0,
+    16, 0x3224, 0x0028, 0x4E94, 0x0029, 0,
+    16, 0x3225, 0x0028, 0x516D, 0x0029, 0,
+    16, 0x3226, 0x0028, 0x4E03, 0x0029, 0,
+    16, 0x3227, 0x0028, 0x516B, 0x0029, 0,
+    16, 0x3228, 0x0028, 0x4E5D, 0x0029, 0,
+    16, 0x3229, 0x0028, 0x5341, 0x0029, 0,
+    16, 0x322A, 0x0028, 0x6708, 0x0029, 0,
+    16, 0x322B, 0x0028, 0x706B, 0x0029, 0,
+    16, 0x322C, 0x0028, 0x6C34, 0x0029, 0,
+    16, 0x322D, 0x0028, 0x6728, 0x0029, 0,
+    16, 0x322E, 0x0028, 0x91D1, 0x0029, 0,
+    16, 0x322F, 0x0028, 0x571F, 0x0029, 0,
+    16, 0x3230, 0x0028, 0x65E5, 0x0029, 0,
+    16, 0x3231, 0x0028, 0x682A, 0x0029, 0,
+    16, 0x3232, 0x0028, 0x6709, 0x0029, 0,
+    16, 0x3233, 0x0028, 0x793E, 0x0029, 0,
+    16, 0x3234, 0x0028, 0x540D, 0x0029, 0,
+    16, 0x3235, 0x0028, 0x7279, 0x0029, 0,
+    16, 0x3236, 0x0028, 0x8CA1, 0x0029, 0,
+    16, 0x3237, 0x0028, 0x795D, 0x0029, 0,
+    16, 0x3238, 0x0028, 0x52B4, 0x0029, 0,
+    16, 0x3239, 0x0028, 0x4EE3, 0x0029, 0,
+    16, 0x323A, 0x0028, 0x547C, 0x0029, 0,
+    16, 0x323B, 0x0028, 0x5B66, 0x0029, 0,
+    16, 0x323C, 0x0028, 0x76E3, 0x0029, 0,
+    16, 0x323D, 0x0028, 0x4F01, 0x0029, 0,
+    16, 0x323E, 0x0028, 0x8CC7, 0x0029, 0,
+    16, 0x323F, 0x0028, 0x5354, 0x0029, 0,
+    16, 0x3240, 0x0028, 0x796D, 0x0029, 0,
+    16, 0x3241, 0x0028, 0x4F11, 0x0029, 0,
+    16, 0x3242, 0x0028, 0x81EA, 0x0029, 0,
+    16, 0x3243, 0x0028, 0x81F3, 0x0029, 0,
+    8, 0x3251, 0x0032, 0x0031, 0,
+    8, 0x3252, 0x0032, 0x0032, 0,
+    8, 0x3253, 0x0032, 0x0033, 0,
+    8, 0x3254, 0x0032, 0x0034, 0,
+    8, 0x3255, 0x0032, 0x0035, 0,
+    8, 0x3256, 0x0032, 0x0036, 0,
+    8, 0x3257, 0x0032, 0x0037, 0,
+    8, 0x3258, 0x0032, 0x0038, 0,
+    8, 0x3259, 0x0032, 0x0039, 0,
+    8, 0x325A, 0x0033, 0x0030, 0,
+    8, 0x325B, 0x0033, 0x0031, 0,
+    8, 0x325C, 0x0033, 0x0032, 0,
+    8, 0x325D, 0x0033, 0x0033, 0,
+    8, 0x325E, 0x0033, 0x0034, 0,
+    8, 0x325F, 0x0033, 0x0035, 0,
+    8, 0x3260, 0x1100, 0,
+    8, 0x3261, 0x1102, 0,
+    8, 0x3262, 0x1103, 0,
+    8, 0x3263, 0x1105, 0,
+    8, 0x3264, 0x1106, 0,
+    8, 0x3265, 0x1107, 0,
+    8, 0x3266, 0x1109, 0,
+    8, 0x3267, 0x110B, 0,
+    8, 0x3268, 0x110C, 0,
+    8, 0x3269, 0x110E, 0,
+    8, 0x326A, 0x110F, 0,
+    8, 0x326B, 0x1110, 0,
+    8, 0x326C, 0x1111, 0,
+    8, 0x326D, 0x1112, 0,
+    8, 0x326E, 0x1100, 0x1161, 0,
+    8, 0x326F, 0x1102, 0x1161, 0,
+    8, 0x3270, 0x1103, 0x1161, 0,
+    8, 0x3271, 0x1105, 0x1161, 0,
+    8, 0x3272, 0x1106, 0x1161, 0,
+    8, 0x3273, 0x1107, 0x1161, 0,
+    8, 0x3274, 0x1109, 0x1161, 0,
+    8, 0x3275, 0x110B, 0x1161, 0,
+    8, 0x3276, 0x110C, 0x1161, 0,
+    8, 0x3277, 0x110E, 0x1161, 0,
+    8, 0x3278, 0x110F, 0x1161, 0,
+    8, 0x3279, 0x1110, 0x1161, 0,
+    8, 0x327A, 0x1111, 0x1161, 0,
+    8, 0x327B, 0x1112, 0x1161, 0,
+    8, 0x3280, 0x4E00, 0,
+    8, 0x3281, 0x4E8C, 0,
+    8, 0x3282, 0x4E09, 0,
+    8, 0x3283, 0x56DB, 0,
+    8, 0x3284, 0x4E94, 0,
+    8, 0x3285, 0x516D, 0,
+    8, 0x3286, 0x4E03, 0,
+    8, 0x3287, 0x516B, 0,
+    8, 0x3288, 0x4E5D, 0,
+    8, 0x3289, 0x5341, 0,
+    8, 0x328A, 0x6708, 0,
+    8, 0x328B, 0x706B, 0,
+    8, 0x328C, 0x6C34, 0,
+    8, 0x328D, 0x6728, 0,
+    8, 0x328E, 0x91D1, 0,
+    8, 0x328F, 0x571F, 0,
+    8, 0x3290, 0x65E5, 0,
+    8, 0x3291, 0x682A, 0,
+    8, 0x3292, 0x6709, 0,
+    8, 0x3293, 0x793E, 0,
+    8, 0x3294, 0x540D, 0,
+    8, 0x3295, 0x7279, 0,
+    8, 0x3296, 0x8CA1, 0,
+    8, 0x3297, 0x795D, 0,
+    8, 0x3298, 0x52B4, 0,
+    8, 0x3299, 0x79D8, 0,
+    8, 0x329A, 0x7537, 0,
+    8, 0x329B, 0x5973, 0,
+    8, 0x329C, 0x9069, 0,
+    8, 0x329D, 0x512A, 0,
+    8, 0x329E, 0x5370, 0,
+    8, 0x329F, 0x6CE8, 0,
+    8, 0x32A0, 0x9805, 0,
+    8, 0x32A1, 0x4F11, 0,
+    8, 0x32A2, 0x5199, 0,
+    8, 0x32A3, 0x6B63, 0,
+    8, 0x32A4, 0x4E0A, 0,
+    8, 0x32A5, 0x4E2D, 0,
+    8, 0x32A6, 0x4E0B, 0,
+    8, 0x32A7, 0x5DE6, 0,
+    8, 0x32A8, 0x53F3, 0,
+    8, 0x32A9, 0x533B, 0,
+    8, 0x32AA, 0x5B97, 0,
+    8, 0x32AB, 0x5B66, 0,
+    8, 0x32AC, 0x76E3, 0,
+    8, 0x32AD, 0x4F01, 0,
+    8, 0x32AE, 0x8CC7, 0,
+    8, 0x32AF, 0x5354, 0,
+    8, 0x32B0, 0x591C, 0,
+    8, 0x32B1, 0x0033, 0x0036, 0,
+    8, 0x32B2, 0x0033, 0x0037, 0,
+    8, 0x32B3, 0x0033, 0x0038, 0,
+    8, 0x32B4, 0x0033, 0x0039, 0,
+    8, 0x32B5, 0x0034, 0x0030, 0,
+    8, 0x32B6, 0x0034, 0x0031, 0,
+    8, 0x32B7, 0x0034, 0x0032, 0,
+    8, 0x32B8, 0x0034, 0x0033, 0,
+    8, 0x32B9, 0x0034, 0x0034, 0,
+    8, 0x32BA, 0x0034, 0x0035, 0,
+    8, 0x32BB, 0x0034, 0x0036, 0,
+    8, 0x32BC, 0x0034, 0x0037, 0,
+    8, 0x32BD, 0x0034, 0x0038, 0,
+    8, 0x32BE, 0x0034, 0x0039, 0,
+    8, 0x32BF, 0x0035, 0x0030, 0,
+    16, 0x32C0, 0x0031, 0x6708, 0,
+    16, 0x32C1, 0x0032, 0x6708, 0,
+    16, 0x32C2, 0x0033, 0x6708, 0,
+    16, 0x32C3, 0x0034, 0x6708, 0,
+    16, 0x32C4, 0x0035, 0x6708, 0,
+    16, 0x32C5, 0x0036, 0x6708, 0,
+    16, 0x32C6, 0x0037, 0x6708, 0,
+    16, 0x32C7, 0x0038, 0x6708, 0,
+    16, 0x32C8, 0x0039, 0x6708, 0,
+    16, 0x32C9, 0x0031, 0x0030, 0x6708, 0,
+    16, 0x32CA, 0x0031, 0x0031, 0x6708, 0,
+    16, 0x32CB, 0x0031, 0x0032, 0x6708, 0,
+    8, 0x32D0, 0x30A2, 0,
+    8, 0x32D1, 0x30A4, 0,
+    8, 0x32D2, 0x30A6, 0,
+    8, 0x32D3, 0x30A8, 0,
+    8, 0x32D4, 0x30AA, 0,
+    8, 0x32D5, 0x30AB, 0,
+    8, 0x32D6, 0x30AD, 0,
+    8, 0x32D7, 0x30AF, 0,
+    8, 0x32D8, 0x30B1, 0,
+    8, 0x32D9, 0x30B3, 0,
+    8, 0x32DA, 0x30B5, 0,
+    8, 0x32DB, 0x30B7, 0,
+    8, 0x32DC, 0x30B9, 0,
+    8, 0x32DD, 0x30BB, 0,
+    8, 0x32DE, 0x30BD, 0,
+    8, 0x32DF, 0x30BF, 0,
+    8, 0x32E0, 0x30C1, 0,
+    8, 0x32E1, 0x30C4, 0,
+    8, 0x32E2, 0x30C6, 0,
+    8, 0x32E3, 0x30C8, 0,
+    8, 0x32E4, 0x30CA, 0,
+    8, 0x32E5, 0x30CB, 0,
+    8, 0x32E6, 0x30CC, 0,
+    8, 0x32E7, 0x30CD, 0,
+    8, 0x32E8, 0x30CE, 0,
+    8, 0x32E9, 0x30CF, 0,
+    8, 0x32EA, 0x30D2, 0,
+    8, 0x32EB, 0x30D5, 0,
+    8, 0x32EC, 0x30D8, 0,
+    8, 0x32ED, 0x30DB, 0,
+    8, 0x32EE, 0x30DE, 0,
+    8, 0x32EF, 0x30DF, 0,
+    8, 0x32F0, 0x30E0, 0,
+    8, 0x32F1, 0x30E1, 0,
+    8, 0x32F2, 0x30E2, 0,
+    8, 0x32F3, 0x30E4, 0,
+    8, 0x32F4, 0x30E6, 0,
+    8, 0x32F5, 0x30E8, 0,
+    8, 0x32F6, 0x30E9, 0,
+    8, 0x32F7, 0x30EA, 0,
+    8, 0x32F8, 0x30EB, 0,
+    8, 0x32F9, 0x30EC, 0,
+    8, 0x32FA, 0x30ED, 0,
+    8, 0x32FB, 0x30EF, 0,
+    8, 0x32FC, 0x30F0, 0,
+    8, 0x32FD, 0x30F1, 0,
+    8, 0x32FE, 0x30F2, 0,
+    15, 0x3300, 0x30A2, 0x30D1, 0x30FC, 0x30C8, 0,
+    15, 0x3301, 0x30A2, 0x30EB, 0x30D5, 0x30A1, 0,
+    15, 0x3302, 0x30A2, 0x30F3, 0x30DA, 0x30A2, 0,
+    15, 0x3303, 0x30A2, 0x30FC, 0x30EB, 0,
+    15, 0x3304, 0x30A4, 0x30CB, 0x30F3, 0x30B0, 0,
+    15, 0x3305, 0x30A4, 0x30F3, 0x30C1, 0,
+    15, 0x3306, 0x30A6, 0x30A9, 0x30F3, 0,
+    15, 0x3307, 0x30A8, 0x30B9, 0x30AF, 0x30FC, 0x30C9, 0,
+    15, 0x3308, 0x30A8, 0x30FC, 0x30AB, 0x30FC, 0,
+    15, 0x3309, 0x30AA, 0x30F3, 0x30B9, 0,
+    15, 0x330A, 0x30AA, 0x30FC, 0x30E0, 0,
+    15, 0x330B, 0x30AB, 0x30A4, 0x30EA, 0,
+    15, 0x330C, 0x30AB, 0x30E9, 0x30C3, 0x30C8, 0,
+    15, 0x330D, 0x30AB, 0x30ED, 0x30EA, 0x30FC, 0,
+    15, 0x330E, 0x30AC, 0x30ED, 0x30F3, 0,
+    15, 0x330F, 0x30AC, 0x30F3, 0x30DE, 0,
+    15, 0x3310, 0x30AE, 0x30AC, 0,
+    15, 0x3311, 0x30AE, 0x30CB, 0x30FC, 0,
+    15, 0x3312, 0x30AD, 0x30E5, 0x30EA, 0x30FC, 0,
+    15, 0x3313, 0x30AE, 0x30EB, 0x30C0, 0x30FC, 0,
+    15, 0x3314, 0x30AD, 0x30ED, 0,
+    15, 0x3315, 0x30AD, 0x30ED, 0x30B0, 0x30E9, 0x30E0, 0,
+    15, 0x3316, 0x30AD, 0x30ED, 0x30E1, 0x30FC, 0x30C8, 0x30EB, 0,
+    15, 0x3317, 0x30AD, 0x30ED, 0x30EF, 0x30C3, 0x30C8, 0,
+    15, 0x3318, 0x30B0, 0x30E9, 0x30E0, 0,
+    15, 0x3319, 0x30B0, 0x30E9, 0x30E0, 0x30C8, 0x30F3, 0,
+    15, 0x331A, 0x30AF, 0x30EB, 0x30BC, 0x30A4, 0x30ED, 0,
+    15, 0x331B, 0x30AF, 0x30ED, 0x30FC, 0x30CD, 0,
+    15, 0x331C, 0x30B1, 0x30FC, 0x30B9, 0,
+    15, 0x331D, 0x30B3, 0x30EB, 0x30CA, 0,
+    15, 0x331E, 0x30B3, 0x30FC, 0x30DD, 0,
+    15, 0x331F, 0x30B5, 0x30A4, 0x30AF, 0x30EB, 0,
+    15, 0x3320, 0x30B5, 0x30F3, 0x30C1, 0x30FC, 0x30E0, 0,
+    15, 0x3321, 0x30B7, 0x30EA, 0x30F3, 0x30B0, 0,
+    15, 0x3322, 0x30BB, 0x30F3, 0x30C1, 0,
+    15, 0x3323, 0x30BB, 0x30F3, 0x30C8, 0,
+    15, 0x3324, 0x30C0, 0x30FC, 0x30B9, 0,
+    15, 0x3325, 0x30C7, 0x30B7, 0,
+    15, 0x3326, 0x30C9, 0x30EB, 0,
+    15, 0x3327, 0x30C8, 0x30F3, 0,
+    15, 0x3328, 0x30CA, 0x30CE, 0,
+    15, 0x3329, 0x30CE, 0x30C3, 0x30C8, 0,
+    15, 0x332A, 0x30CF, 0x30A4, 0x30C4, 0,
+    15, 0x332B, 0x30D1, 0x30FC, 0x30BB, 0x30F3, 0x30C8, 0,
+    15, 0x332C, 0x30D1, 0x30FC, 0x30C4, 0,
+    15, 0x332D, 0x30D0, 0x30FC, 0x30EC, 0x30EB, 0,
+    15, 0x332E, 0x30D4, 0x30A2, 0x30B9, 0x30C8, 0x30EB, 0,
+    15, 0x332F, 0x30D4, 0x30AF, 0x30EB, 0,
+    15, 0x3330, 0x30D4, 0x30B3, 0,
+    15, 0x3331, 0x30D3, 0x30EB, 0,
+    15, 0x3332, 0x30D5, 0x30A1, 0x30E9, 0x30C3, 0x30C9, 0,
+    15, 0x3333, 0x30D5, 0x30A3, 0x30FC, 0x30C8, 0,
+    15, 0x3334, 0x30D6, 0x30C3, 0x30B7, 0x30A7, 0x30EB, 0,
+    15, 0x3335, 0x30D5, 0x30E9, 0x30F3, 0,
+    15, 0x3336, 0x30D8, 0x30AF, 0x30BF, 0x30FC, 0x30EB, 0,
+    15, 0x3337, 0x30DA, 0x30BD, 0,
+    15, 0x3338, 0x30DA, 0x30CB, 0x30D2, 0,
+    15, 0x3339, 0x30D8, 0x30EB, 0x30C4, 0,
+    15, 0x333A, 0x30DA, 0x30F3, 0x30B9, 0,
+    15, 0x333B, 0x30DA, 0x30FC, 0x30B8, 0,
+    15, 0x333C, 0x30D9, 0x30FC, 0x30BF, 0,
+    15, 0x333D, 0x30DD, 0x30A4, 0x30F3, 0x30C8, 0,
+    15, 0x333E, 0x30DC, 0x30EB, 0x30C8, 0,
+    15, 0x333F, 0x30DB, 0x30F3, 0,
+    15, 0x3340, 0x30DD, 0x30F3, 0x30C9, 0,
+    15, 0x3341, 0x30DB, 0x30FC, 0x30EB, 0,
+    15, 0x3342, 0x30DB, 0x30FC, 0x30F3, 0,
+    15, 0x3343, 0x30DE, 0x30A4, 0x30AF, 0x30ED, 0,
+    15, 0x3344, 0x30DE, 0x30A4, 0x30EB, 0,
+    15, 0x3345, 0x30DE, 0x30C3, 0x30CF, 0,
+    15, 0x3346, 0x30DE, 0x30EB, 0x30AF, 0,
+    15, 0x3347, 0x30DE, 0x30F3, 0x30B7, 0x30E7, 0x30F3, 0,
+    15, 0x3348, 0x30DF, 0x30AF, 0x30ED, 0x30F3, 0,
+    15, 0x3349, 0x30DF, 0x30EA, 0,
+    15, 0x334A, 0x30DF, 0x30EA, 0x30D0, 0x30FC, 0x30EB, 0,
+    15, 0x334B, 0x30E1, 0x30AC, 0,
+    15, 0x334C, 0x30E1, 0x30AC, 0x30C8, 0x30F3, 0,
+    15, 0x334D, 0x30E1, 0x30FC, 0x30C8, 0x30EB, 0,
+    15, 0x334E, 0x30E4, 0x30FC, 0x30C9, 0,
+    15, 0x334F, 0x30E4, 0x30FC, 0x30EB, 0,
+    15, 0x3350, 0x30E6, 0x30A2, 0x30F3, 0,
+    15, 0x3351, 0x30EA, 0x30C3, 0x30C8, 0x30EB, 0,
+    15, 0x3352, 0x30EA, 0x30E9, 0,
+    15, 0x3353, 0x30EB, 0x30D4, 0x30FC, 0,
+    15, 0x3354, 0x30EB, 0x30FC, 0x30D6, 0x30EB, 0,
+    15, 0x3355, 0x30EC, 0x30E0, 0,
+    15, 0x3356, 0x30EC, 0x30F3, 0x30C8, 0x30B2, 0x30F3, 0,
+    15, 0x3357, 0x30EF, 0x30C3, 0x30C8, 0,
+    16, 0x3358, 0x0030, 0x70B9, 0,
+    16, 0x3359, 0x0031, 0x70B9, 0,
+    16, 0x335A, 0x0032, 0x70B9, 0,
+    16, 0x335B, 0x0033, 0x70B9, 0,
+    16, 0x335C, 0x0034, 0x70B9, 0,
+    16, 0x335D, 0x0035, 0x70B9, 0,
+    16, 0x335E, 0x0036, 0x70B9, 0,
+    16, 0x335F, 0x0037, 0x70B9, 0,
+    16, 0x3360, 0x0038, 0x70B9, 0,
+    16, 0x3361, 0x0039, 0x70B9, 0,
+    16, 0x3362, 0x0031, 0x0030, 0x70B9, 0,
+    16, 0x3363, 0x0031, 0x0031, 0x70B9, 0,
+    16, 0x3364, 0x0031, 0x0032, 0x70B9, 0,
+    16, 0x3365, 0x0031, 0x0033, 0x70B9, 0,
+    16, 0x3366, 0x0031, 0x0034, 0x70B9, 0,
+    16, 0x3367, 0x0031, 0x0035, 0x70B9, 0,
+    16, 0x3368, 0x0031, 0x0036, 0x70B9, 0,
+    16, 0x3369, 0x0031, 0x0037, 0x70B9, 0,
+    16, 0x336A, 0x0031, 0x0038, 0x70B9, 0,
+    16, 0x336B, 0x0031, 0x0039, 0x70B9, 0,
+    16, 0x336C, 0x0032, 0x0030, 0x70B9, 0,
+    16, 0x336D, 0x0032, 0x0031, 0x70B9, 0,
+    16, 0x336E, 0x0032, 0x0032, 0x70B9, 0,
+    16, 0x336F, 0x0032, 0x0033, 0x70B9, 0,
+    16, 0x3370, 0x0032, 0x0034, 0x70B9, 0,
+    15, 0x3371, 0x0068, 0x0050, 0x0061, 0,
+    15, 0x3372, 0x0064, 0x0061, 0,
+    15, 0x3373, 0x0041, 0x0055, 0,
+    15, 0x3374, 0x0062, 0x0061, 0x0072, 0,
+    15, 0x3375, 0x006F, 0x0056, 0,
+    15, 0x3376, 0x0070, 0x0063, 0,
+    15, 0x337B, 0x5E73, 0x6210, 0,
+    15, 0x337C, 0x662D, 0x548C, 0,
+    15, 0x337D, 0x5927, 0x6B63, 0,
+    15, 0x337E, 0x660E, 0x6CBB, 0,
+    15, 0x337F, 0x682A, 0x5F0F, 0x4F1A, 0x793E, 0,
+    15, 0x3380, 0x0070, 0x0041, 0,
+    15, 0x3381, 0x006E, 0x0041, 0,
+    15, 0x3382, 0x03BC, 0x0041, 0,
+    15, 0x3383, 0x006D, 0x0041, 0,
+    15, 0x3384, 0x006B, 0x0041, 0,
+    15, 0x3385, 0x004B, 0x0042, 0,
+    15, 0x3386, 0x004D, 0x0042, 0,
+    15, 0x3387, 0x0047, 0x0042, 0,
+    15, 0x3388, 0x0063, 0x0061, 0x006C, 0,
+    15, 0x3389, 0x006B, 0x0063, 0x0061, 0x006C, 0,
+    15, 0x338A, 0x0070, 0x0046, 0,
+    15, 0x338B, 0x006E, 0x0046, 0,
+    15, 0x338C, 0x03BC, 0x0046, 0,
+    15, 0x338D, 0x03BC, 0x0067, 0,
+    15, 0x338E, 0x006D, 0x0067, 0,
+    15, 0x338F, 0x006B, 0x0067, 0,
+    15, 0x3390, 0x0048, 0x007A, 0,
+    15, 0x3391, 0x006B, 0x0048, 0x007A, 0,
+    15, 0x3392, 0x004D, 0x0048, 0x007A, 0,
+    15, 0x3393, 0x0047, 0x0048, 0x007A, 0,
+    15, 0x3394, 0x0054, 0x0048, 0x007A, 0,
+    15, 0x3395, 0x03BC, 0x2113, 0,
+    15, 0x3396, 0x006D, 0x2113, 0,
+    15, 0x3397, 0x0064, 0x2113, 0,
+    15, 0x3398, 0x006B, 0x2113, 0,
+    15, 0x3399, 0x0066, 0x006D, 0,
+    15, 0x339A, 0x006E, 0x006D, 0,
+    15, 0x339B, 0x03BC, 0x006D, 0,
+    15, 0x339C, 0x006D, 0x006D, 0,
+    15, 0x339D, 0x0063, 0x006D, 0,
+    15, 0x339E, 0x006B, 0x006D, 0,
+    15, 0x339F, 0x006D, 0x006D, 0x00B2, 0,
+    15, 0x33A0, 0x0063, 0x006D, 0x00B2, 0,
+    15, 0x33A1, 0x006D, 0x00B2, 0,
+    15, 0x33A2, 0x006B, 0x006D, 0x00B2, 0,
+    15, 0x33A3, 0x006D, 0x006D, 0x00B3, 0,
+    15, 0x33A4, 0x0063, 0x006D, 0x00B3, 0,
+    15, 0x33A5, 0x006D, 0x00B3, 0,
+    15, 0x33A6, 0x006B, 0x006D, 0x00B3, 0,
+    15, 0x33A7, 0x006D, 0x2215, 0x0073, 0,
+    15, 0x33A8, 0x006D, 0x2215, 0x0073, 0x00B2, 0,
+    15, 0x33A9, 0x0050, 0x0061, 0,
+    15, 0x33AA, 0x006B, 0x0050, 0x0061, 0,
+    15, 0x33AB, 0x004D, 0x0050, 0x0061, 0,
+    15, 0x33AC, 0x0047, 0x0050, 0x0061, 0,
+    15, 0x33AD, 0x0072, 0x0061, 0x0064, 0,
+    15, 0x33AE, 0x0072, 0x0061, 0x0064, 0x2215, 0x0073, 0,
+    15, 0x33AF, 0x0072, 0x0061, 0x0064, 0x2215, 0x0073, 0x00B2, 0,
+    15, 0x33B0, 0x0070, 0x0073, 0,
+    15, 0x33B1, 0x006E, 0x0073, 0,
+    15, 0x33B2, 0x03BC, 0x0073, 0,
+    15, 0x33B3, 0x006D, 0x0073, 0,
+    15, 0x33B4, 0x0070, 0x0056, 0,
+    15, 0x33B5, 0x006E, 0x0056, 0,
+    15, 0x33B6, 0x03BC, 0x0056, 0,
+    15, 0x33B7, 0x006D, 0x0056, 0,
+    15, 0x33B8, 0x006B, 0x0056, 0,
+    15, 0x33B9, 0x004D, 0x0056, 0,
+    15, 0x33BA, 0x0070, 0x0057, 0,
+    15, 0x33BB, 0x006E, 0x0057, 0,
+    15, 0x33BC, 0x03BC, 0x0057, 0,
+    15, 0x33BD, 0x006D, 0x0057, 0,
+    15, 0x33BE, 0x006B, 0x0057, 0,
+    15, 0x33BF, 0x004D, 0x0057, 0,
+    15, 0x33C0, 0x006B, 0x03A9, 0,
+    15, 0x33C1, 0x004D, 0x03A9, 0,
+    15, 0x33C2, 0x0061, 0x002E, 0x006D, 0x002E, 0,
+    15, 0x33C3, 0x0042, 0x0071, 0,
+    15, 0x33C4, 0x0063, 0x0063, 0,
+    15, 0x33C5, 0x0063, 0x0064, 0,
+    15, 0x33C6, 0x0043, 0x2215, 0x006B, 0x0067, 0,
+    15, 0x33C7, 0x0043, 0x006F, 0x002E, 0,
+    15, 0x33C8, 0x0064, 0x0042, 0,
+    15, 0x33C9, 0x0047, 0x0079, 0,
+    15, 0x33CA, 0x0068, 0x0061, 0,
+    15, 0x33CB, 0x0048, 0x0050, 0,
+    15, 0x33CC, 0x0069, 0x006E, 0,
+    15, 0x33CD, 0x004B, 0x004B, 0,
+    15, 0x33CE, 0x004B, 0x004D, 0,
+    15, 0x33CF, 0x006B, 0x0074, 0,
+    15, 0x33D0, 0x006C, 0x006D, 0,
+    15, 0x33D1, 0x006C, 0x006E, 0,
+    15, 0x33D2, 0x006C, 0x006F, 0x0067, 0,
+    15, 0x33D3, 0x006C, 0x0078, 0,
+    15, 0x33D4, 0x006D, 0x0062, 0,
+    15, 0x33D5, 0x006D, 0x0069, 0x006C, 0,
+    15, 0x33D6, 0x006D, 0x006F, 0x006C, 0,
+    15, 0x33D7, 0x0050, 0x0048, 0,
+    15, 0x33D8, 0x0070, 0x002E, 0x006D, 0x002E, 0,
+    15, 0x33D9, 0x0050, 0x0050, 0x004D, 0,
+    15, 0x33DA, 0x0050, 0x0052, 0,
+    15, 0x33DB, 0x0073, 0x0072, 0,
+    15, 0x33DC, 0x0053, 0x0076, 0,
+    15, 0x33DD, 0x0057, 0x0062, 0,
+    16, 0x33E0, 0x0031, 0x65E5, 0,
+    16, 0x33E1, 0x0032, 0x65E5, 0,
+    16, 0x33E2, 0x0033, 0x65E5, 0,
+    16, 0x33E3, 0x0034, 0x65E5, 0,
+    16, 0x33E4, 0x0035, 0x65E5, 0,
+    16, 0x33E5, 0x0036, 0x65E5, 0,
+    16, 0x33E6, 0x0037, 0x65E5, 0,
+    16, 0x33E7, 0x0038, 0x65E5, 0,
+    16, 0x33E8, 0x0039, 0x65E5, 0,
+    16, 0x33E9, 0x0031, 0x0030, 0x65E5, 0,
+    16, 0x33EA, 0x0031, 0x0031, 0x65E5, 0,
+    16, 0x33EB, 0x0031, 0x0032, 0x65E5, 0,
+    16, 0x33EC, 0x0031, 0x0033, 0x65E5, 0,
+    16, 0x33ED, 0x0031, 0x0034, 0x65E5, 0,
+    16, 0x33EE, 0x0031, 0x0035, 0x65E5, 0,
+    16, 0x33EF, 0x0031, 0x0036, 0x65E5, 0,
+    16, 0x33F0, 0x0031, 0x0037, 0x65E5, 0,
+    16, 0x33F1, 0x0031, 0x0038, 0x65E5, 0,
+    16, 0x33F2, 0x0031, 0x0039, 0x65E5, 0,
+    16, 0x33F3, 0x0032, 0x0030, 0x65E5, 0,
+    16, 0x33F4, 0x0032, 0x0031, 0x65E5, 0,
+    16, 0x33F5, 0x0032, 0x0032, 0x65E5, 0,
+    16, 0x33F6, 0x0032, 0x0033, 0x65E5, 0,
+    16, 0x33F7, 0x0032, 0x0034, 0x65E5, 0,
+    16, 0x33F8, 0x0032, 0x0035, 0x65E5, 0,
+    16, 0x33F9, 0x0032, 0x0036, 0x65E5, 0,
+    16, 0x33FA, 0x0032, 0x0037, 0x65E5, 0,
+    16, 0x33FB, 0x0032, 0x0038, 0x65E5, 0,
+    16, 0x33FC, 0x0032, 0x0039, 0x65E5, 0,
+    16, 0x33FD, 0x0033, 0x0030, 0x65E5, 0,
+    16, 0x33FE, 0x0033, 0x0031, 0x65E5, 0,
+    1, 0xF900, 0x8C48, 0,
+    1, 0xF901, 0x66F4, 0,
+    1, 0xF902, 0x8ECA, 0,
+    1, 0xF903, 0x8CC8, 0,
+    1, 0xF904, 0x6ED1, 0,
+    1, 0xF905, 0x4E32, 0,
+    1, 0xF906, 0x53E5, 0,
+    1, 0xF907, 0x9F9C, 0,
+    1, 0xF908, 0x9F9C, 0,
+    1, 0xF909, 0x5951, 0,
+    1, 0xF90A, 0x91D1, 0,
+    1, 0xF90B, 0x5587, 0,
+    1, 0xF90C, 0x5948, 0,
+    1, 0xF90D, 0x61F6, 0,
+    1, 0xF90E, 0x7669, 0,
+    1, 0xF90F, 0x7F85, 0,
+    1, 0xF910, 0x863F, 0,
+    1, 0xF911, 0x87BA, 0,
+    1, 0xF912, 0x88F8, 0,
+    1, 0xF913, 0x908F, 0,
+    1, 0xF914, 0x6A02, 0,
+    1, 0xF915, 0x6D1B, 0,
+    1, 0xF916, 0x70D9, 0,
+    1, 0xF917, 0x73DE, 0,
+    1, 0xF918, 0x843D, 0,
+    1, 0xF919, 0x916A, 0,
+    1, 0xF91A, 0x99F1, 0,
+    1, 0xF91B, 0x4E82, 0,
+    1, 0xF91C, 0x5375, 0,
+    1, 0xF91D, 0x6B04, 0,
+    1, 0xF91E, 0x721B, 0,
+    1, 0xF91F, 0x862D, 0,
+    1, 0xF920, 0x9E1E, 0,
+    1, 0xF921, 0x5D50, 0,
+    1, 0xF922, 0x6FEB, 0,
+    1, 0xF923, 0x85CD, 0,
+    1, 0xF924, 0x8964, 0,
+    1, 0xF925, 0x62C9, 0,
+    1, 0xF926, 0x81D8, 0,
+    1, 0xF927, 0x881F, 0,
+    1, 0xF928, 0x5ECA, 0,
+    1, 0xF929, 0x6717, 0,
+    1, 0xF92A, 0x6D6A, 0,
+    1, 0xF92B, 0x72FC, 0,
+    1, 0xF92C, 0x90CE, 0,
+    1, 0xF92D, 0x4F86, 0,
+    1, 0xF92E, 0x51B7, 0,
+    1, 0xF92F, 0x52DE, 0,
+    1, 0xF930, 0x64C4, 0,
+    1, 0xF931, 0x6AD3, 0,
+    1, 0xF932, 0x7210, 0,
+    1, 0xF933, 0x76E7, 0,
+    1, 0xF934, 0x8001, 0,
+    1, 0xF935, 0x8606, 0,
+    1, 0xF936, 0x865C, 0,
+    1, 0xF937, 0x8DEF, 0,
+    1, 0xF938, 0x9732, 0,
+    1, 0xF939, 0x9B6F, 0,
+    1, 0xF93A, 0x9DFA, 0,
+    1, 0xF93B, 0x788C, 0,
+    1, 0xF93C, 0x797F, 0,
+    1, 0xF93D, 0x7DA0, 0,
+    1, 0xF93E, 0x83C9, 0,
+    1, 0xF93F, 0x9304, 0,
+    1, 0xF940, 0x9E7F, 0,
+    1, 0xF941, 0x8AD6, 0,
+    1, 0xF942, 0x58DF, 0,
+    1, 0xF943, 0x5F04, 0,
+    1, 0xF944, 0x7C60, 0,
+    1, 0xF945, 0x807E, 0,
+    1, 0xF946, 0x7262, 0,
+    1, 0xF947, 0x78CA, 0,
+    1, 0xF948, 0x8CC2, 0,
+    1, 0xF949, 0x96F7, 0,
+    1, 0xF94A, 0x58D8, 0,
+    1, 0xF94B, 0x5C62, 0,
+    1, 0xF94C, 0x6A13, 0,
+    1, 0xF94D, 0x6DDA, 0,
+    1, 0xF94E, 0x6F0F, 0,
+    1, 0xF94F, 0x7D2F, 0,
+    1, 0xF950, 0x7E37, 0,
+    1, 0xF951, 0x964B, 0,
+    1, 0xF952, 0x52D2, 0,
+    1, 0xF953, 0x808B, 0,
+    1, 0xF954, 0x51DC, 0,
+    1, 0xF955, 0x51CC, 0,
+    1, 0xF956, 0x7A1C, 0,
+    1, 0xF957, 0x7DBE, 0,
+    1, 0xF958, 0x83F1, 0,
+    1, 0xF959, 0x9675, 0,
+    1, 0xF95A, 0x8B80, 0,
+    1, 0xF95B, 0x62CF, 0,
+    1, 0xF95C, 0x6A02, 0,
+    1, 0xF95D, 0x8AFE, 0,
+    1, 0xF95E, 0x4E39, 0,
+    1, 0xF95F, 0x5BE7, 0,
+    1, 0xF960, 0x6012, 0,
+    1, 0xF961, 0x7387, 0,
+    1, 0xF962, 0x7570, 0,
+    1, 0xF963, 0x5317, 0,
+    1, 0xF964, 0x78FB, 0,
+    1, 0xF965, 0x4FBF, 0,
+    1, 0xF966, 0x5FA9, 0,
+    1, 0xF967, 0x4E0D, 0,
+    1, 0xF968, 0x6CCC, 0,
+    1, 0xF969, 0x6578, 0,
+    1, 0xF96A, 0x7D22, 0,
+    1, 0xF96B, 0x53C3, 0,
+    1, 0xF96C, 0x585E, 0,
+    1, 0xF96D, 0x7701, 0,
+    1, 0xF96E, 0x8449, 0,
+    1, 0xF96F, 0x8AAA, 0,
+    1, 0xF970, 0x6BBA, 0,
+    1, 0xF971, 0x8FB0, 0,
+    1, 0xF972, 0x6C88, 0,
+    1, 0xF973, 0x62FE, 0,
+    1, 0xF974, 0x82E5, 0,
+    1, 0xF975, 0x63A0, 0,
+    1, 0xF976, 0x7565, 0,
+    1, 0xF977, 0x4EAE, 0,
+    1, 0xF978, 0x5169, 0,
+    1, 0xF979, 0x51C9, 0,
+    1, 0xF97A, 0x6881, 0,
+    1, 0xF97B, 0x7CE7, 0,
+    1, 0xF97C, 0x826F, 0,
+    1, 0xF97D, 0x8AD2, 0,
+    1, 0xF97E, 0x91CF, 0,
+    1, 0xF97F, 0x52F5, 0,
+    1, 0xF980, 0x5442, 0,
+    1, 0xF981, 0x5973, 0,
+    1, 0xF982, 0x5EEC, 0,
+    1, 0xF983, 0x65C5, 0,
+    1, 0xF984, 0x6FFE, 0,
+    1, 0xF985, 0x792A, 0,
+    1, 0xF986, 0x95AD, 0,
+    1, 0xF987, 0x9A6A, 0,
+    1, 0xF988, 0x9E97, 0,
+    1, 0xF989, 0x9ECE, 0,
+    1, 0xF98A, 0x529B, 0,
+    1, 0xF98B, 0x66C6, 0,
+    1, 0xF98C, 0x6B77, 0,
+    1, 0xF98D, 0x8F62, 0,
+    1, 0xF98E, 0x5E74, 0,
+    1, 0xF98F, 0x6190, 0,
+    1, 0xF990, 0x6200, 0,
+    1, 0xF991, 0x649A, 0,
+    1, 0xF992, 0x6F23, 0,
+    1, 0xF993, 0x7149, 0,
+    1, 0xF994, 0x7489, 0,
+    1, 0xF995, 0x79CA, 0,
+    1, 0xF996, 0x7DF4, 0,
+    1, 0xF997, 0x806F, 0,
+    1, 0xF998, 0x8F26, 0,
+    1, 0xF999, 0x84EE, 0,
+    1, 0xF99A, 0x9023, 0,
+    1, 0xF99B, 0x934A, 0,
+    1, 0xF99C, 0x5217, 0,
+    1, 0xF99D, 0x52A3, 0,
+    1, 0xF99E, 0x54BD, 0,
+    1, 0xF99F, 0x70C8, 0,
+    1, 0xF9A0, 0x88C2, 0,
+    1, 0xF9A1, 0x8AAA, 0,
+    1, 0xF9A2, 0x5EC9, 0,
+    1, 0xF9A3, 0x5FF5, 0,
+    1, 0xF9A4, 0x637B, 0,
+    1, 0xF9A5, 0x6BAE, 0,
+    1, 0xF9A6, 0x7C3E, 0,
+    1, 0xF9A7, 0x7375, 0,
+    1, 0xF9A8, 0x4EE4, 0,
+    1, 0xF9A9, 0x56F9, 0,
+    1, 0xF9AA, 0x5BE7, 0,
+    1, 0xF9AB, 0x5DBA, 0,
+    1, 0xF9AC, 0x601C, 0,
+    1, 0xF9AD, 0x73B2, 0,
+    1, 0xF9AE, 0x7469, 0,
+    1, 0xF9AF, 0x7F9A, 0,
+    1, 0xF9B0, 0x8046, 0,
+    1, 0xF9B1, 0x9234, 0,
+    1, 0xF9B2, 0x96F6, 0,
+    1, 0xF9B3, 0x9748, 0,
+    1, 0xF9B4, 0x9818, 0,
+    1, 0xF9B5, 0x4F8B, 0,
+    1, 0xF9B6, 0x79AE, 0,
+    1, 0xF9B7, 0x91B4, 0,
+    1, 0xF9B8, 0x96B8, 0,
+    1, 0xF9B9, 0x60E1, 0,
+    1, 0xF9BA, 0x4E86, 0,
+    1, 0xF9BB, 0x50DA, 0,
+    1, 0xF9BC, 0x5BEE, 0,
+    1, 0xF9BD, 0x5C3F, 0,
+    1, 0xF9BE, 0x6599, 0,
+    1, 0xF9BF, 0x6A02, 0,
+    1, 0xF9C0, 0x71CE, 0,
+    1, 0xF9C1, 0x7642, 0,
+    1, 0xF9C2, 0x84FC, 0,
+    1, 0xF9C3, 0x907C, 0,
+    1, 0xF9C4, 0x9F8D, 0,
+    1, 0xF9C5, 0x6688, 0,
+    1, 0xF9C6, 0x962E, 0,
+    1, 0xF9C7, 0x5289, 0,
+    1, 0xF9C8, 0x677B, 0,
+    1, 0xF9C9, 0x67F3, 0,
+    1, 0xF9CA, 0x6D41, 0,
+    1, 0xF9CB, 0x6E9C, 0,
+    1, 0xF9CC, 0x7409, 0,
+    1, 0xF9CD, 0x7559, 0,
+    1, 0xF9CE, 0x786B, 0,
+    1, 0xF9CF, 0x7D10, 0,
+    1, 0xF9D0, 0x985E, 0,
+    1, 0xF9D1, 0x516D, 0,
+    1, 0xF9D2, 0x622E, 0,
+    1, 0xF9D3, 0x9678, 0,
+    1, 0xF9D4, 0x502B, 0,
+    1, 0xF9D5, 0x5D19, 0,
+    1, 0xF9D6, 0x6DEA, 0,
+    1, 0xF9D7, 0x8F2A, 0,
+    1, 0xF9D8, 0x5F8B, 0,
+    1, 0xF9D9, 0x6144, 0,
+    1, 0xF9DA, 0x6817, 0,
+    1, 0xF9DB, 0x7387, 0,
+    1, 0xF9DC, 0x9686, 0,
+    1, 0xF9DD, 0x5229, 0,
+    1, 0xF9DE, 0x540F, 0,
+    1, 0xF9DF, 0x5C65, 0,
+    1, 0xF9E0, 0x6613, 0,
+    1, 0xF9E1, 0x674E, 0,
+    1, 0xF9E2, 0x68A8, 0,
+    1, 0xF9E3, 0x6CE5, 0,
+    1, 0xF9E4, 0x7406, 0,
+    1, 0xF9E5, 0x75E2, 0,
+    1, 0xF9E6, 0x7F79, 0,
+    1, 0xF9E7, 0x88CF, 0,
+    1, 0xF9E8, 0x88E1, 0,
+    1, 0xF9E9, 0x91CC, 0,
+    1, 0xF9EA, 0x96E2, 0,
+    1, 0xF9EB, 0x533F, 0,
+    1, 0xF9EC, 0x6EBA, 0,
+    1, 0xF9ED, 0x541D, 0,
+    1, 0xF9EE, 0x71D0, 0,
+    1, 0xF9EF, 0x7498, 0,
+    1, 0xF9F0, 0x85FA, 0,
+    1, 0xF9F1, 0x96A3, 0,
+    1, 0xF9F2, 0x9C57, 0,
+    1, 0xF9F3, 0x9E9F, 0,
+    1, 0xF9F4, 0x6797, 0,
+    1, 0xF9F5, 0x6DCB, 0,
+    1, 0xF9F6, 0x81E8, 0,
+    1, 0xF9F7, 0x7ACB, 0,
+    1, 0xF9F8, 0x7B20, 0,
+    1, 0xF9F9, 0x7C92, 0,
+    1, 0xF9FA, 0x72C0, 0,
+    1, 0xF9FB, 0x7099, 0,
+    1, 0xF9FC, 0x8B58, 0,
+    1, 0xF9FD, 0x4EC0, 0,
+    1, 0xF9FE, 0x8336, 0,
+    1, 0xF9FF, 0x523A, 0,
+    1, 0xFA00, 0x5207, 0,
+    1, 0xFA01, 0x5EA6, 0,
+    1, 0xFA02, 0x62D3, 0,
+    1, 0xFA03, 0x7CD6, 0,
+    1, 0xFA04, 0x5B85, 0,
+    1, 0xFA05, 0x6D1E, 0,
+    1, 0xFA06, 0x66B4, 0,
+    1, 0xFA07, 0x8F3B, 0,
+    1, 0xFA08, 0x884C, 0,
+    1, 0xFA09, 0x964D, 0,
+    1, 0xFA0A, 0x898B, 0,
+    1, 0xFA0B, 0x5ED3, 0,
+    1, 0xFA0C, 0x5140, 0,
+    1, 0xFA0D, 0x55C0, 0,
+    1, 0xFA10, 0x585A, 0,
+    1, 0xFA12, 0x6674, 0,
+    1, 0xFA15, 0x51DE, 0,
+    1, 0xFA16, 0x732A, 0,
+    1, 0xFA17, 0x76CA, 0,
+    1, 0xFA18, 0x793C, 0,
+    1, 0xFA19, 0x795E, 0,
+    1, 0xFA1A, 0x7965, 0,
+    1, 0xFA1B, 0x798F, 0,
+    1, 0xFA1C, 0x9756, 0,
+    1, 0xFA1D, 0x7CBE, 0,
+    1, 0xFA1E, 0x7FBD, 0,
+    1, 0xFA20, 0x8612, 0,
+    1, 0xFA22, 0x8AF8, 0,
+    1, 0xFA25, 0x9038, 0,
+    1, 0xFA26, 0x90FD, 0,
+    1, 0xFA2A, 0x98EF, 0,
+    1, 0xFA2B, 0x98FC, 0,
+    1, 0xFA2C, 0x9928, 0,
+    1, 0xFA2D, 0x9DB4, 0,
+    1, 0xFA30, 0x4FAE, 0,
+    1, 0xFA31, 0x50E7, 0,
+    1, 0xFA32, 0x514D, 0,
+    1, 0xFA33, 0x52C9, 0,
+    1, 0xFA34, 0x52E4, 0,
+    1, 0xFA35, 0x5351, 0,
+    1, 0xFA36, 0x559D, 0,
+    1, 0xFA37, 0x5606, 0,
+    1, 0xFA38, 0x5668, 0,
+    1, 0xFA39, 0x5840, 0,
+    1, 0xFA3A, 0x58A8, 0,
+    1, 0xFA3B, 0x5C64, 0,
+    1, 0xFA3C, 0x5C6E, 0,
+    1, 0xFA3D, 0x6094, 0,
+    1, 0xFA3E, 0x6168, 0,
+    1, 0xFA3F, 0x618E, 0,
+    1, 0xFA40, 0x61F2, 0,
+    1, 0xFA41, 0x654F, 0,
+    1, 0xFA42, 0x65E2, 0,
+    1, 0xFA43, 0x6691, 0,
+    1, 0xFA44, 0x6885, 0,
+    1, 0xFA45, 0x6D77, 0,
+    1, 0xFA46, 0x6E1A, 0,
+    1, 0xFA47, 0x6F22, 0,
+    1, 0xFA48, 0x716E, 0,
+    1, 0xFA49, 0x722B, 0,
+    1, 0xFA4A, 0x7422, 0,
+    1, 0xFA4B, 0x7891, 0,
+    1, 0xFA4C, 0x793E, 0,
+    1, 0xFA4D, 0x7949, 0,
+    1, 0xFA4E, 0x7948, 0,
+    1, 0xFA4F, 0x7950, 0,
+    1, 0xFA50, 0x7956, 0,
+    1, 0xFA51, 0x795D, 0,
+    1, 0xFA52, 0x798D, 0,
+    1, 0xFA53, 0x798E, 0,
+    1, 0xFA54, 0x7A40, 0,
+    1, 0xFA55, 0x7A81, 0,
+    1, 0xFA56, 0x7BC0, 0,
+    1, 0xFA57, 0x7DF4, 0,
+    1, 0xFA58, 0x7E09, 0,
+    1, 0xFA59, 0x7E41, 0,
+    1, 0xFA5A, 0x7F72, 0,
+    1, 0xFA5B, 0x8005, 0,
+    1, 0xFA5C, 0x81ED, 0,
+    1, 0xFA5D, 0x8279, 0,
+    1, 0xFA5E, 0x8279, 0,
+    1, 0xFA5F, 0x8457, 0,
+    1, 0xFA60, 0x8910, 0,
+    1, 0xFA61, 0x8996, 0,
+    1, 0xFA62, 0x8B01, 0,
+    1, 0xFA63, 0x8B39, 0,
+    1, 0xFA64, 0x8CD3, 0,
+    1, 0xFA65, 0x8D08, 0,
+    1, 0xFA66, 0x8FB6, 0,
+    1, 0xFA67, 0x9038, 0,
+    1, 0xFA68, 0x96E3, 0,
+    1, 0xFA69, 0x97FF, 0,
+    1, 0xFA6A, 0x983B, 0,
+    16, 0xFB00, 0x0066, 0x0066, 0,
+    16, 0xFB01, 0x0066, 0x0069, 0,
+    16, 0xFB02, 0x0066, 0x006C, 0,
+    16, 0xFB03, 0x0066, 0x0066, 0x0069, 0,
+    16, 0xFB04, 0x0066, 0x0066, 0x006C, 0,
+    16, 0xFB05, 0x017F, 0x0074, 0,
+    16, 0xFB06, 0x0073, 0x0074, 0,
+    16, 0xFB13, 0x0574, 0x0576, 0,
+    16, 0xFB14, 0x0574, 0x0565, 0,
+    16, 0xFB15, 0x0574, 0x056B, 0,
+    16, 0xFB16, 0x057E, 0x0576, 0,
+    16, 0xFB17, 0x0574, 0x056D, 0,
+    1, 0xFB1D, 0x05D9, 0x05B4, 0,
+    1, 0xFB1F, 0x05F2, 0x05B7, 0,
+    2, 0xFB20, 0x05E2, 0,
+    2, 0xFB21, 0x05D0, 0,
+    2, 0xFB22, 0x05D3, 0,
+    2, 0xFB23, 0x05D4, 0,
+    2, 0xFB24, 0x05DB, 0,
+    2, 0xFB25, 0x05DC, 0,
+    2, 0xFB26, 0x05DD, 0,
+    2, 0xFB27, 0x05E8, 0,
+    2, 0xFB28, 0x05EA, 0,
+    2, 0xFB29, 0x002B, 0,
+    1, 0xFB2A, 0x05E9, 0x05C1, 0,
+    1, 0xFB2B, 0x05E9, 0x05C2, 0,
+    1, 0xFB2C, 0xFB49, 0x05C1, 0,
+    1, 0xFB2D, 0xFB49, 0x05C2, 0,
+    1, 0xFB2E, 0x05D0, 0x05B7, 0,
+    1, 0xFB2F, 0x05D0, 0x05B8, 0,
+    1, 0xFB30, 0x05D0, 0x05BC, 0,
+    1, 0xFB31, 0x05D1, 0x05BC, 0,
+    1, 0xFB32, 0x05D2, 0x05BC, 0,
+    1, 0xFB33, 0x05D3, 0x05BC, 0,
+    1, 0xFB34, 0x05D4, 0x05BC, 0,
+    1, 0xFB35, 0x05D5, 0x05BC, 0,
+    1, 0xFB36, 0x05D6, 0x05BC, 0,
+    1, 0xFB38, 0x05D8, 0x05BC, 0,
+    1, 0xFB39, 0x05D9, 0x05BC, 0,
+    1, 0xFB3A, 0x05DA, 0x05BC, 0,
+    1, 0xFB3B, 0x05DB, 0x05BC, 0,
+    1, 0xFB3C, 0x05DC, 0x05BC, 0,
+    1, 0xFB3E, 0x05DE, 0x05BC, 0,
+    1, 0xFB40, 0x05E0, 0x05BC, 0,
+    1, 0xFB41, 0x05E1, 0x05BC, 0,
+    1, 0xFB43, 0x05E3, 0x05BC, 0,
+    1, 0xFB44, 0x05E4, 0x05BC, 0,
+    1, 0xFB46, 0x05E6, 0x05BC, 0,
+    1, 0xFB47, 0x05E7, 0x05BC, 0,
+    1, 0xFB48, 0x05E8, 0x05BC, 0,
+    1, 0xFB49, 0x05E9, 0x05BC, 0,
+    1, 0xFB4A, 0x05EA, 0x05BC, 0,
+    1, 0xFB4B, 0x05D5, 0x05B9, 0,
+    1, 0xFB4C, 0x05D1, 0x05BF, 0,
+    1, 0xFB4D, 0x05DB, 0x05BF, 0,
+    1, 0xFB4E, 0x05E4, 0x05BF, 0,
+    16, 0xFB4F, 0x05D0, 0x05DC, 0,
+    7, 0xFB50, 0x0671, 0,
+    6, 0xFB51, 0x0671, 0,
+    7, 0xFB52, 0x067B, 0,
+    6, 0xFB53, 0x067B, 0,
+    4, 0xFB54, 0x067B, 0,
+    5, 0xFB55, 0x067B, 0,
+    7, 0xFB56, 0x067E, 0,
+    6, 0xFB57, 0x067E, 0,
+    4, 0xFB58, 0x067E, 0,
+    5, 0xFB59, 0x067E, 0,
+    7, 0xFB5A, 0x0680, 0,
+    6, 0xFB5B, 0x0680, 0,
+    4, 0xFB5C, 0x0680, 0,
+    5, 0xFB5D, 0x0680, 0,
+    7, 0xFB5E, 0x067A, 0,
+    6, 0xFB5F, 0x067A, 0,
+    4, 0xFB60, 0x067A, 0,
+    5, 0xFB61, 0x067A, 0,
+    7, 0xFB62, 0x067F, 0,
+    6, 0xFB63, 0x067F, 0,
+    4, 0xFB64, 0x067F, 0,
+    5, 0xFB65, 0x067F, 0,
+    7, 0xFB66, 0x0679, 0,
+    6, 0xFB67, 0x0679, 0,
+    4, 0xFB68, 0x0679, 0,
+    5, 0xFB69, 0x0679, 0,
+    7, 0xFB6A, 0x06A4, 0,
+    6, 0xFB6B, 0x06A4, 0,
+    4, 0xFB6C, 0x06A4, 0,
+    5, 0xFB6D, 0x06A4, 0,
+    7, 0xFB6E, 0x06A6, 0,
+    6, 0xFB6F, 0x06A6, 0,
+    4, 0xFB70, 0x06A6, 0,
+    5, 0xFB71, 0x06A6, 0,
+    7, 0xFB72, 0x0684, 0,
+    6, 0xFB73, 0x0684, 0,
+    4, 0xFB74, 0x0684, 0,
+    5, 0xFB75, 0x0684, 0,
+    7, 0xFB76, 0x0683, 0,
+    6, 0xFB77, 0x0683, 0,
+    4, 0xFB78, 0x0683, 0,
+    5, 0xFB79, 0x0683, 0,
+    7, 0xFB7A, 0x0686, 0,
+    6, 0xFB7B, 0x0686, 0,
+    4, 0xFB7C, 0x0686, 0,
+    5, 0xFB7D, 0x0686, 0,
+    7, 0xFB7E, 0x0687, 0,
+    6, 0xFB7F, 0x0687, 0,
+    4, 0xFB80, 0x0687, 0,
+    5, 0xFB81, 0x0687, 0,
+    7, 0xFB82, 0x068D, 0,
+    6, 0xFB83, 0x068D, 0,
+    7, 0xFB84, 0x068C, 0,
+    6, 0xFB85, 0x068C, 0,
+    7, 0xFB86, 0x068E, 0,
+    6, 0xFB87, 0x068E, 0,
+    7, 0xFB88, 0x0688, 0,
+    6, 0xFB89, 0x0688, 0,
+    7, 0xFB8A, 0x0698, 0,
+    6, 0xFB8B, 0x0698, 0,
+    7, 0xFB8C, 0x0691, 0,
+    6, 0xFB8D, 0x0691, 0,
+    7, 0xFB8E, 0x06A9, 0,
+    6, 0xFB8F, 0x06A9, 0,
+    4, 0xFB90, 0x06A9, 0,
+    5, 0xFB91, 0x06A9, 0,
+    7, 0xFB92, 0x06AF, 0,
+    6, 0xFB93, 0x06AF, 0,
+    4, 0xFB94, 0x06AF, 0,
+    5, 0xFB95, 0x06AF, 0,
+    7, 0xFB96, 0x06B3, 0,
+    6, 0xFB97, 0x06B3, 0,
+    4, 0xFB98, 0x06B3, 0,
+    5, 0xFB99, 0x06B3, 0,
+    7, 0xFB9A, 0x06B1, 0,
+    6, 0xFB9B, 0x06B1, 0,
+    4, 0xFB9C, 0x06B1, 0,
+    5, 0xFB9D, 0x06B1, 0,
+    7, 0xFB9E, 0x06BA, 0,
+    6, 0xFB9F, 0x06BA, 0,
+    7, 0xFBA0, 0x06BB, 0,
+    6, 0xFBA1, 0x06BB, 0,
+    4, 0xFBA2, 0x06BB, 0,
+    5, 0xFBA3, 0x06BB, 0,
+    7, 0xFBA4, 0x06C0, 0,
+    6, 0xFBA5, 0x06C0, 0,
+    7, 0xFBA6, 0x06C1, 0,
+    6, 0xFBA7, 0x06C1, 0,
+    4, 0xFBA8, 0x06C1, 0,
+    5, 0xFBA9, 0x06C1, 0,
+    7, 0xFBAA, 0x06BE, 0,
+    6, 0xFBAB, 0x06BE, 0,
+    4, 0xFBAC, 0x06BE, 0,
+    5, 0xFBAD, 0x06BE, 0,
+    7, 0xFBAE, 0x06D2, 0,
+    6, 0xFBAF, 0x06D2, 0,
+    7, 0xFBB0, 0x06D3, 0,
+    6, 0xFBB1, 0x06D3, 0,
+    7, 0xFBD3, 0x06AD, 0,
+    6, 0xFBD4, 0x06AD, 0,
+    4, 0xFBD5, 0x06AD, 0,
+    5, 0xFBD6, 0x06AD, 0,
+    7, 0xFBD7, 0x06C7, 0,
+    6, 0xFBD8, 0x06C7, 0,
+    7, 0xFBD9, 0x06C6, 0,
+    6, 0xFBDA, 0x06C6, 0,
+    7, 0xFBDB, 0x06C8, 0,
+    6, 0xFBDC, 0x06C8, 0,
+    7, 0xFBDD, 0x0677, 0,
+    7, 0xFBDE, 0x06CB, 0,
+    6, 0xFBDF, 0x06CB, 0,
+    7, 0xFBE0, 0x06C5, 0,
+    6, 0xFBE1, 0x06C5, 0,
+    7, 0xFBE2, 0x06C9, 0,
+    6, 0xFBE3, 0x06C9, 0,
+    7, 0xFBE4, 0x06D0, 0,
+    6, 0xFBE5, 0x06D0, 0,
+    4, 0xFBE6, 0x06D0, 0,
+    5, 0xFBE7, 0x06D0, 0,
+    4, 0xFBE8, 0x0649, 0,
+    5, 0xFBE9, 0x0649, 0,
+    7, 0xFBEA, 0x0626, 0x0627, 0,
+    6, 0xFBEB, 0x0626, 0x0627, 0,
+    7, 0xFBEC, 0x0626, 0x06D5, 0,
+    6, 0xFBED, 0x0626, 0x06D5, 0,
+    7, 0xFBEE, 0x0626, 0x0648, 0,
+    6, 0xFBEF, 0x0626, 0x0648, 0,
+    7, 0xFBF0, 0x0626, 0x06C7, 0,
+    6, 0xFBF1, 0x0626, 0x06C7, 0,
+    7, 0xFBF2, 0x0626, 0x06C6, 0,
+    6, 0xFBF3, 0x0626, 0x06C6, 0,
+    7, 0xFBF4, 0x0626, 0x06C8, 0,
+    6, 0xFBF5, 0x0626, 0x06C8, 0,
+    7, 0xFBF6, 0x0626, 0x06D0, 0,
+    6, 0xFBF7, 0x0626, 0x06D0, 0,
+    4, 0xFBF8, 0x0626, 0x06D0, 0,
+    7, 0xFBF9, 0x0626, 0x0649, 0,
+    6, 0xFBFA, 0x0626, 0x0649, 0,
+    4, 0xFBFB, 0x0626, 0x0649, 0,
+    7, 0xFBFC, 0x06CC, 0,
+    6, 0xFBFD, 0x06CC, 0,
+    4, 0xFBFE, 0x06CC, 0,
+    5, 0xFBFF, 0x06CC, 0,
+    7, 0xFC00, 0x0626, 0x062C, 0,
+    7, 0xFC01, 0x0626, 0x062D, 0,
+    7, 0xFC02, 0x0626, 0x0645, 0,
+    7, 0xFC03, 0x0626, 0x0649, 0,
+    7, 0xFC04, 0x0626, 0x064A, 0,
+    7, 0xFC05, 0x0628, 0x062C, 0,
+    7, 0xFC06, 0x0628, 0x062D, 0,
+    7, 0xFC07, 0x0628, 0x062E, 0,
+    7, 0xFC08, 0x0628, 0x0645, 0,
+    7, 0xFC09, 0x0628, 0x0649, 0,
+    7, 0xFC0A, 0x0628, 0x064A, 0,
+    7, 0xFC0B, 0x062A, 0x062C, 0,
+    7, 0xFC0C, 0x062A, 0x062D, 0,
+    7, 0xFC0D, 0x062A, 0x062E, 0,
+    7, 0xFC0E, 0x062A, 0x0645, 0,
+    7, 0xFC0F, 0x062A, 0x0649, 0,
+    7, 0xFC10, 0x062A, 0x064A, 0,
+    7, 0xFC11, 0x062B, 0x062C, 0,
+    7, 0xFC12, 0x062B, 0x0645, 0,
+    7, 0xFC13, 0x062B, 0x0649, 0,
+    7, 0xFC14, 0x062B, 0x064A, 0,
+    7, 0xFC15, 0x062C, 0x062D, 0,
+    7, 0xFC16, 0x062C, 0x0645, 0,
+    7, 0xFC17, 0x062D, 0x062C, 0,
+    7, 0xFC18, 0x062D, 0x0645, 0,
+    7, 0xFC19, 0x062E, 0x062C, 0,
+    7, 0xFC1A, 0x062E, 0x062D, 0,
+    7, 0xFC1B, 0x062E, 0x0645, 0,
+    7, 0xFC1C, 0x0633, 0x062C, 0,
+    7, 0xFC1D, 0x0633, 0x062D, 0,
+    7, 0xFC1E, 0x0633, 0x062E, 0,
+    7, 0xFC1F, 0x0633, 0x0645, 0,
+    7, 0xFC20, 0x0635, 0x062D, 0,
+    7, 0xFC21, 0x0635, 0x0645, 0,
+    7, 0xFC22, 0x0636, 0x062C, 0,
+    7, 0xFC23, 0x0636, 0x062D, 0,
+    7, 0xFC24, 0x0636, 0x062E, 0,
+    7, 0xFC25, 0x0636, 0x0645, 0,
+    7, 0xFC26, 0x0637, 0x062D, 0,
+    7, 0xFC27, 0x0637, 0x0645, 0,
+    7, 0xFC28, 0x0638, 0x0645, 0,
+    7, 0xFC29, 0x0639, 0x062C, 0,
+    7, 0xFC2A, 0x0639, 0x0645, 0,
+    7, 0xFC2B, 0x063A, 0x062C, 0,
+    7, 0xFC2C, 0x063A, 0x0645, 0,
+    7, 0xFC2D, 0x0641, 0x062C, 0,
+    7, 0xFC2E, 0x0641, 0x062D, 0,
+    7, 0xFC2F, 0x0641, 0x062E, 0,
+    7, 0xFC30, 0x0641, 0x0645, 0,
+    7, 0xFC31, 0x0641, 0x0649, 0,
+    7, 0xFC32, 0x0641, 0x064A, 0,
+    7, 0xFC33, 0x0642, 0x062D, 0,
+    7, 0xFC34, 0x0642, 0x0645, 0,
+    7, 0xFC35, 0x0642, 0x0649, 0,
+    7, 0xFC36, 0x0642, 0x064A, 0,
+    7, 0xFC37, 0x0643, 0x0627, 0,
+    7, 0xFC38, 0x0643, 0x062C, 0,
+    7, 0xFC39, 0x0643, 0x062D, 0,
+    7, 0xFC3A, 0x0643, 0x062E, 0,
+    7, 0xFC3B, 0x0643, 0x0644, 0,
+    7, 0xFC3C, 0x0643, 0x0645, 0,
+    7, 0xFC3D, 0x0643, 0x0649, 0,
+    7, 0xFC3E, 0x0643, 0x064A, 0,
+    7, 0xFC3F, 0x0644, 0x062C, 0,
+    7, 0xFC40, 0x0644, 0x062D, 0,
+    7, 0xFC41, 0x0644, 0x062E, 0,
+    7, 0xFC42, 0x0644, 0x0645, 0,
+    7, 0xFC43, 0x0644, 0x0649, 0,
+    7, 0xFC44, 0x0644, 0x064A, 0,
+    7, 0xFC45, 0x0645, 0x062C, 0,
+    7, 0xFC46, 0x0645, 0x062D, 0,
+    7, 0xFC47, 0x0645, 0x062E, 0,
+    7, 0xFC48, 0x0645, 0x0645, 0,
+    7, 0xFC49, 0x0645, 0x0649, 0,
+    7, 0xFC4A, 0x0645, 0x064A, 0,
+    7, 0xFC4B, 0x0646, 0x062C, 0,
+    7, 0xFC4C, 0x0646, 0x062D, 0,
+    7, 0xFC4D, 0x0646, 0x062E, 0,
+    7, 0xFC4E, 0x0646, 0x0645, 0,
+    7, 0xFC4F, 0x0646, 0x0649, 0,
+    7, 0xFC50, 0x0646, 0x064A, 0,
+    7, 0xFC51, 0x0647, 0x062C, 0,
+    7, 0xFC52, 0x0647, 0x0645, 0,
+    7, 0xFC53, 0x0647, 0x0649, 0,
+    7, 0xFC54, 0x0647, 0x064A, 0,
+    7, 0xFC55, 0x064A, 0x062C, 0,
+    7, 0xFC56, 0x064A, 0x062D, 0,
+    7, 0xFC57, 0x064A, 0x062E, 0,
+    7, 0xFC58, 0x064A, 0x0645, 0,
+    7, 0xFC59, 0x064A, 0x0649, 0,
+    7, 0xFC5A, 0x064A, 0x064A, 0,
+    7, 0xFC5B, 0x0630, 0x0670, 0,
+    7, 0xFC5C, 0x0631, 0x0670, 0,
+    7, 0xFC5D, 0x0649, 0x0670, 0,
+    7, 0xFC5E, 0x0020, 0x064C, 0x0651, 0,
+    7, 0xFC5F, 0x0020, 0x064D, 0x0651, 0,
+    7, 0xFC60, 0x0020, 0x064E, 0x0651, 0,
+    7, 0xFC61, 0x0020, 0x064F, 0x0651, 0,
+    7, 0xFC62, 0x0020, 0x0650, 0x0651, 0,
+    7, 0xFC63, 0x0020, 0x0651, 0x0670, 0,
+    6, 0xFC64, 0x0626, 0x0631, 0,
+    6, 0xFC65, 0x0626, 0x0632, 0,
+    6, 0xFC66, 0x0626, 0x0645, 0,
+    6, 0xFC67, 0x0626, 0x0646, 0,
+    6, 0xFC68, 0x0626, 0x0649, 0,
+    6, 0xFC69, 0x0626, 0x064A, 0,
+    6, 0xFC6A, 0x0628, 0x0631, 0,
+    6, 0xFC6B, 0x0628, 0x0632, 0,
+    6, 0xFC6C, 0x0628, 0x0645, 0,
+    6, 0xFC6D, 0x0628, 0x0646, 0,
+    6, 0xFC6E, 0x0628, 0x0649, 0,
+    6, 0xFC6F, 0x0628, 0x064A, 0,
+    6, 0xFC70, 0x062A, 0x0631, 0,
+    6, 0xFC71, 0x062A, 0x0632, 0,
+    6, 0xFC72, 0x062A, 0x0645, 0,
+    6, 0xFC73, 0x062A, 0x0646, 0,
+    6, 0xFC74, 0x062A, 0x0649, 0,
+    6, 0xFC75, 0x062A, 0x064A, 0,
+    6, 0xFC76, 0x062B, 0x0631, 0,
+    6, 0xFC77, 0x062B, 0x0632, 0,
+    6, 0xFC78, 0x062B, 0x0645, 0,
+    6, 0xFC79, 0x062B, 0x0646, 0,
+    6, 0xFC7A, 0x062B, 0x0649, 0,
+    6, 0xFC7B, 0x062B, 0x064A, 0,
+    6, 0xFC7C, 0x0641, 0x0649, 0,
+    6, 0xFC7D, 0x0641, 0x064A, 0,
+    6, 0xFC7E, 0x0642, 0x0649, 0,
+    6, 0xFC7F, 0x0642, 0x064A, 0,
+    6, 0xFC80, 0x0643, 0x0627, 0,
+    6, 0xFC81, 0x0643, 0x0644, 0,
+    6, 0xFC82, 0x0643, 0x0645, 0,
+    6, 0xFC83, 0x0643, 0x0649, 0,
+    6, 0xFC84, 0x0643, 0x064A, 0,
+    6, 0xFC85, 0x0644, 0x0645, 0,
+    6, 0xFC86, 0x0644, 0x0649, 0,
+    6, 0xFC87, 0x0644, 0x064A, 0,
+    6, 0xFC88, 0x0645, 0x0627, 0,
+    6, 0xFC89, 0x0645, 0x0645, 0,
+    6, 0xFC8A, 0x0646, 0x0631, 0,
+    6, 0xFC8B, 0x0646, 0x0632, 0,
+    6, 0xFC8C, 0x0646, 0x0645, 0,
+    6, 0xFC8D, 0x0646, 0x0646, 0,
+    6, 0xFC8E, 0x0646, 0x0649, 0,
+    6, 0xFC8F, 0x0646, 0x064A, 0,
+    6, 0xFC90, 0x0649, 0x0670, 0,
+    6, 0xFC91, 0x064A, 0x0631, 0,
+    6, 0xFC92, 0x064A, 0x0632, 0,
+    6, 0xFC93, 0x064A, 0x0645, 0,
+    6, 0xFC94, 0x064A, 0x0646, 0,
+    6, 0xFC95, 0x064A, 0x0649, 0,
+    6, 0xFC96, 0x064A, 0x064A, 0,
+    4, 0xFC97, 0x0626, 0x062C, 0,
+    4, 0xFC98, 0x0626, 0x062D, 0,
+    4, 0xFC99, 0x0626, 0x062E, 0,
+    4, 0xFC9A, 0x0626, 0x0645, 0,
+    4, 0xFC9B, 0x0626, 0x0647, 0,
+    4, 0xFC9C, 0x0628, 0x062C, 0,
+    4, 0xFC9D, 0x0628, 0x062D, 0,
+    4, 0xFC9E, 0x0628, 0x062E, 0,
+    4, 0xFC9F, 0x0628, 0x0645, 0,
+    4, 0xFCA0, 0x0628, 0x0647, 0,
+    4, 0xFCA1, 0x062A, 0x062C, 0,
+    4, 0xFCA2, 0x062A, 0x062D, 0,
+    4, 0xFCA3, 0x062A, 0x062E, 0,
+    4, 0xFCA4, 0x062A, 0x0645, 0,
+    4, 0xFCA5, 0x062A, 0x0647, 0,
+    4, 0xFCA6, 0x062B, 0x0645, 0,
+    4, 0xFCA7, 0x062C, 0x062D, 0,
+    4, 0xFCA8, 0x062C, 0x0645, 0,
+    4, 0xFCA9, 0x062D, 0x062C, 0,
+    4, 0xFCAA, 0x062D, 0x0645, 0,
+    4, 0xFCAB, 0x062E, 0x062C, 0,
+    4, 0xFCAC, 0x062E, 0x0645, 0,
+    4, 0xFCAD, 0x0633, 0x062C, 0,
+    4, 0xFCAE, 0x0633, 0x062D, 0,
+    4, 0xFCAF, 0x0633, 0x062E, 0,
+    4, 0xFCB0, 0x0633, 0x0645, 0,
+    4, 0xFCB1, 0x0635, 0x062D, 0,
+    4, 0xFCB2, 0x0635, 0x062E, 0,
+    4, 0xFCB3, 0x0635, 0x0645, 0,
+    4, 0xFCB4, 0x0636, 0x062C, 0,
+    4, 0xFCB5, 0x0636, 0x062D, 0,
+    4, 0xFCB6, 0x0636, 0x062E, 0,
+    4, 0xFCB7, 0x0636, 0x0645, 0,
+    4, 0xFCB8, 0x0637, 0x062D, 0,
+    4, 0xFCB9, 0x0638, 0x0645, 0,
+    4, 0xFCBA, 0x0639, 0x062C, 0,
+    4, 0xFCBB, 0x0639, 0x0645, 0,
+    4, 0xFCBC, 0x063A, 0x062C, 0,
+    4, 0xFCBD, 0x063A, 0x0645, 0,
+    4, 0xFCBE, 0x0641, 0x062C, 0,
+    4, 0xFCBF, 0x0641, 0x062D, 0,
+    4, 0xFCC0, 0x0641, 0x062E, 0,
+    4, 0xFCC1, 0x0641, 0x0645, 0,
+    4, 0xFCC2, 0x0642, 0x062D, 0,
+    4, 0xFCC3, 0x0642, 0x0645, 0,
+    4, 0xFCC4, 0x0643, 0x062C, 0,
+    4, 0xFCC5, 0x0643, 0x062D, 0,
+    4, 0xFCC6, 0x0643, 0x062E, 0,
+    4, 0xFCC7, 0x0643, 0x0644, 0,
+    4, 0xFCC8, 0x0643, 0x0645, 0,
+    4, 0xFCC9, 0x0644, 0x062C, 0,
+    4, 0xFCCA, 0x0644, 0x062D, 0,
+    4, 0xFCCB, 0x0644, 0x062E, 0,
+    4, 0xFCCC, 0x0644, 0x0645, 0,
+    4, 0xFCCD, 0x0644, 0x0647, 0,
+    4, 0xFCCE, 0x0645, 0x062C, 0,
+    4, 0xFCCF, 0x0645, 0x062D, 0,
+    4, 0xFCD0, 0x0645, 0x062E, 0,
+    4, 0xFCD1, 0x0645, 0x0645, 0,
+    4, 0xFCD2, 0x0646, 0x062C, 0,
+    4, 0xFCD3, 0x0646, 0x062D, 0,
+    4, 0xFCD4, 0x0646, 0x062E, 0,
+    4, 0xFCD5, 0x0646, 0x0645, 0,
+    4, 0xFCD6, 0x0646, 0x0647, 0,
+    4, 0xFCD7, 0x0647, 0x062C, 0,
+    4, 0xFCD8, 0x0647, 0x0645, 0,
+    4, 0xFCD9, 0x0647, 0x0670, 0,
+    4, 0xFCDA, 0x064A, 0x062C, 0,
+    4, 0xFCDB, 0x064A, 0x062D, 0,
+    4, 0xFCDC, 0x064A, 0x062E, 0,
+    4, 0xFCDD, 0x064A, 0x0645, 0,
+    4, 0xFCDE, 0x064A, 0x0647, 0,
+    5, 0xFCDF, 0x0626, 0x0645, 0,
+    5, 0xFCE0, 0x0626, 0x0647, 0,
+    5, 0xFCE1, 0x0628, 0x0645, 0,
+    5, 0xFCE2, 0x0628, 0x0647, 0,
+    5, 0xFCE3, 0x062A, 0x0645, 0,
+    5, 0xFCE4, 0x062A, 0x0647, 0,
+    5, 0xFCE5, 0x062B, 0x0645, 0,
+    5, 0xFCE6, 0x062B, 0x0647, 0,
+    5, 0xFCE7, 0x0633, 0x0645, 0,
+    5, 0xFCE8, 0x0633, 0x0647, 0,
+    5, 0xFCE9, 0x0634, 0x0645, 0,
+    5, 0xFCEA, 0x0634, 0x0647, 0,
+    5, 0xFCEB, 0x0643, 0x0644, 0,
+    5, 0xFCEC, 0x0643, 0x0645, 0,
+    5, 0xFCED, 0x0644, 0x0645, 0,
+    5, 0xFCEE, 0x0646, 0x0645, 0,
+    5, 0xFCEF, 0x0646, 0x0647, 0,
+    5, 0xFCF0, 0x064A, 0x0645, 0,
+    5, 0xFCF1, 0x064A, 0x0647, 0,
+    5, 0xFCF2, 0x0640, 0x064E, 0x0651, 0,
+    5, 0xFCF3, 0x0640, 0x064F, 0x0651, 0,
+    5, 0xFCF4, 0x0640, 0x0650, 0x0651, 0,
+    7, 0xFCF5, 0x0637, 0x0649, 0,
+    7, 0xFCF6, 0x0637, 0x064A, 0,
+    7, 0xFCF7, 0x0639, 0x0649, 0,
+    7, 0xFCF8, 0x0639, 0x064A, 0,
+    7, 0xFCF9, 0x063A, 0x0649, 0,
+    7, 0xFCFA, 0x063A, 0x064A, 0,
+    7, 0xFCFB, 0x0633, 0x0649, 0,
+    7, 0xFCFC, 0x0633, 0x064A, 0,
+    7, 0xFCFD, 0x0634, 0x0649, 0,
+    7, 0xFCFE, 0x0634, 0x064A, 0,
+    7, 0xFCFF, 0x062D, 0x0649, 0,
+    7, 0xFD00, 0x062D, 0x064A, 0,
+    7, 0xFD01, 0x062C, 0x0649, 0,
+    7, 0xFD02, 0x062C, 0x064A, 0,
+    7, 0xFD03, 0x062E, 0x0649, 0,
+    7, 0xFD04, 0x062E, 0x064A, 0,
+    7, 0xFD05, 0x0635, 0x0649, 0,
+    7, 0xFD06, 0x0635, 0x064A, 0,
+    7, 0xFD07, 0x0636, 0x0649, 0,
+    7, 0xFD08, 0x0636, 0x064A, 0,
+    7, 0xFD09, 0x0634, 0x062C, 0,
+    7, 0xFD0A, 0x0634, 0x062D, 0,
+    7, 0xFD0B, 0x0634, 0x062E, 0,
+    7, 0xFD0C, 0x0634, 0x0645, 0,
+    7, 0xFD0D, 0x0634, 0x0631, 0,
+    7, 0xFD0E, 0x0633, 0x0631, 0,
+    7, 0xFD0F, 0x0635, 0x0631, 0,
+    7, 0xFD10, 0x0636, 0x0631, 0,
+    6, 0xFD11, 0x0637, 0x0649, 0,
+    6, 0xFD12, 0x0637, 0x064A, 0,
+    6, 0xFD13, 0x0639, 0x0649, 0,
+    6, 0xFD14, 0x0639, 0x064A, 0,
+    6, 0xFD15, 0x063A, 0x0649, 0,
+    6, 0xFD16, 0x063A, 0x064A, 0,
+    6, 0xFD17, 0x0633, 0x0649, 0,
+    6, 0xFD18, 0x0633, 0x064A, 0,
+    6, 0xFD19, 0x0634, 0x0649, 0,
+    6, 0xFD1A, 0x0634, 0x064A, 0,
+    6, 0xFD1B, 0x062D, 0x0649, 0,
+    6, 0xFD1C, 0x062D, 0x064A, 0,
+    6, 0xFD1D, 0x062C, 0x0649, 0,
+    6, 0xFD1E, 0x062C, 0x064A, 0,
+    6, 0xFD1F, 0x062E, 0x0649, 0,
+    6, 0xFD20, 0x062E, 0x064A, 0,
+    6, 0xFD21, 0x0635, 0x0649, 0,
+    6, 0xFD22, 0x0635, 0x064A, 0,
+    6, 0xFD23, 0x0636, 0x0649, 0,
+    6, 0xFD24, 0x0636, 0x064A, 0,
+    6, 0xFD25, 0x0634, 0x062C, 0,
+    6, 0xFD26, 0x0634, 0x062D, 0,
+    6, 0xFD27, 0x0634, 0x062E, 0,
+    6, 0xFD28, 0x0634, 0x0645, 0,
+    6, 0xFD29, 0x0634, 0x0631, 0,
+    6, 0xFD2A, 0x0633, 0x0631, 0,
+    6, 0xFD2B, 0x0635, 0x0631, 0,
+    6, 0xFD2C, 0x0636, 0x0631, 0,
+    4, 0xFD2D, 0x0634, 0x062C, 0,
+    4, 0xFD2E, 0x0634, 0x062D, 0,
+    4, 0xFD2F, 0x0634, 0x062E, 0,
+    4, 0xFD30, 0x0634, 0x0645, 0,
+    4, 0xFD31, 0x0633, 0x0647, 0,
+    4, 0xFD32, 0x0634, 0x0647, 0,
+    4, 0xFD33, 0x0637, 0x0645, 0,
+    5, 0xFD34, 0x0633, 0x062C, 0,
+    5, 0xFD35, 0x0633, 0x062D, 0,
+    5, 0xFD36, 0x0633, 0x062E, 0,
+    5, 0xFD37, 0x0634, 0x062C, 0,
+    5, 0xFD38, 0x0634, 0x062D, 0,
+    5, 0xFD39, 0x0634, 0x062E, 0,
+    5, 0xFD3A, 0x0637, 0x0645, 0,
+    5, 0xFD3B, 0x0638, 0x0645, 0,
+    6, 0xFD3C, 0x0627, 0x064B, 0,
+    7, 0xFD3D, 0x0627, 0x064B, 0,
+    4, 0xFD50, 0x062A, 0x062C, 0x0645, 0,
+    6, 0xFD51, 0x062A, 0x062D, 0x062C, 0,
+    4, 0xFD52, 0x062A, 0x062D, 0x062C, 0,
+    4, 0xFD53, 0x062A, 0x062D, 0x0645, 0,
+    4, 0xFD54, 0x062A, 0x062E, 0x0645, 0,
+    4, 0xFD55, 0x062A, 0x0645, 0x062C, 0,
+    4, 0xFD56, 0x062A, 0x0645, 0x062D, 0,
+    4, 0xFD57, 0x062A, 0x0645, 0x062E, 0,
+    6, 0xFD58, 0x062C, 0x0645, 0x062D, 0,
+    4, 0xFD59, 0x062C, 0x0645, 0x062D, 0,
+    6, 0xFD5A, 0x062D, 0x0645, 0x064A, 0,
+    6, 0xFD5B, 0x062D, 0x0645, 0x0649, 0,
+    4, 0xFD5C, 0x0633, 0x062D, 0x062C, 0,
+    4, 0xFD5D, 0x0633, 0x062C, 0x062D, 0,
+    6, 0xFD5E, 0x0633, 0x062C, 0x0649, 0,
+    6, 0xFD5F, 0x0633, 0x0645, 0x062D, 0,
+    4, 0xFD60, 0x0633, 0x0645, 0x062D, 0,
+    4, 0xFD61, 0x0633, 0x0645, 0x062C, 0,
+    6, 0xFD62, 0x0633, 0x0645, 0x0645, 0,
+    4, 0xFD63, 0x0633, 0x0645, 0x0645, 0,
+    6, 0xFD64, 0x0635, 0x062D, 0x062D, 0,
+    4, 0xFD65, 0x0635, 0x062D, 0x062D, 0,
+    6, 0xFD66, 0x0635, 0x0645, 0x0645, 0,
+    6, 0xFD67, 0x0634, 0x062D, 0x0645, 0,
+    4, 0xFD68, 0x0634, 0x062D, 0x0645, 0,
+    6, 0xFD69, 0x0634, 0x062C, 0x064A, 0,
+    6, 0xFD6A, 0x0634, 0x0645, 0x062E, 0,
+    4, 0xFD6B, 0x0634, 0x0645, 0x062E, 0,
+    6, 0xFD6C, 0x0634, 0x0645, 0x0645, 0,
+    4, 0xFD6D, 0x0634, 0x0645, 0x0645, 0,
+    6, 0xFD6E, 0x0636, 0x062D, 0x0649, 0,
+    6, 0xFD6F, 0x0636, 0x062E, 0x0645, 0,
+    4, 0xFD70, 0x0636, 0x062E, 0x0645, 0,
+    6, 0xFD71, 0x0637, 0x0645, 0x062D, 0,
+    4, 0xFD72, 0x0637, 0x0645, 0x062D, 0,
+    4, 0xFD73, 0x0637, 0x0645, 0x0645, 0,
+    6, 0xFD74, 0x0637, 0x0645, 0x064A, 0,
+    6, 0xFD75, 0x0639, 0x062C, 0x0645, 0,
+    6, 0xFD76, 0x0639, 0x0645, 0x0645, 0,
+    4, 0xFD77, 0x0639, 0x0645, 0x0645, 0,
+    6, 0xFD78, 0x0639, 0x0645, 0x0649, 0,
+    6, 0xFD79, 0x063A, 0x0645, 0x0645, 0,
+    6, 0xFD7A, 0x063A, 0x0645, 0x064A, 0,
+    6, 0xFD7B, 0x063A, 0x0645, 0x0649, 0,
+    6, 0xFD7C, 0x0641, 0x062E, 0x0645, 0,
+    4, 0xFD7D, 0x0641, 0x062E, 0x0645, 0,
+    6, 0xFD7E, 0x0642, 0x0645, 0x062D, 0,
+    6, 0xFD7F, 0x0642, 0x0645, 0x0645, 0,
+    6, 0xFD80, 0x0644, 0x062D, 0x0645, 0,
+    6, 0xFD81, 0x0644, 0x062D, 0x064A, 0,
+    6, 0xFD82, 0x0644, 0x062D, 0x0649, 0,
+    4, 0xFD83, 0x0644, 0x062C, 0x062C, 0,
+    6, 0xFD84, 0x0644, 0x062C, 0x062C, 0,
+    6, 0xFD85, 0x0644, 0x062E, 0x0645, 0,
+    4, 0xFD86, 0x0644, 0x062E, 0x0645, 0,
+    6, 0xFD87, 0x0644, 0x0645, 0x062D, 0,
+    4, 0xFD88, 0x0644, 0x0645, 0x062D, 0,
+    4, 0xFD89, 0x0645, 0x062D, 0x062C, 0,
+    4, 0xFD8A, 0x0645, 0x062D, 0x0645, 0,
+    6, 0xFD8B, 0x0645, 0x062D, 0x064A, 0,
+    4, 0xFD8C, 0x0645, 0x062C, 0x062D, 0,
+    4, 0xFD8D, 0x0645, 0x062C, 0x0645, 0,
+    4, 0xFD8E, 0x0645, 0x062E, 0x062C, 0,
+    4, 0xFD8F, 0x0645, 0x062E, 0x0645, 0,
+    4, 0xFD92, 0x0645, 0x062C, 0x062E, 0,
+    4, 0xFD93, 0x0647, 0x0645, 0x062C, 0,
+    4, 0xFD94, 0x0647, 0x0645, 0x0645, 0,
+    4, 0xFD95, 0x0646, 0x062D, 0x0645, 0,
+    6, 0xFD96, 0x0646, 0x062D, 0x0649, 0,
+    6, 0xFD97, 0x0646, 0x062C, 0x0645, 0,
+    4, 0xFD98, 0x0646, 0x062C, 0x0645, 0,
+    6, 0xFD99, 0x0646, 0x062C, 0x0649, 0,
+    6, 0xFD9A, 0x0646, 0x0645, 0x064A, 0,
+    6, 0xFD9B, 0x0646, 0x0645, 0x0649, 0,
+    6, 0xFD9C, 0x064A, 0x0645, 0x0645, 0,
+    4, 0xFD9D, 0x064A, 0x0645, 0x0645, 0,
+    6, 0xFD9E, 0x0628, 0x062E, 0x064A, 0,
+    6, 0xFD9F, 0x062A, 0x062C, 0x064A, 0,
+    6, 0xFDA0, 0x062A, 0x062C, 0x0649, 0,
+    6, 0xFDA1, 0x062A, 0x062E, 0x064A, 0,
+    6, 0xFDA2, 0x062A, 0x062E, 0x0649, 0,
+    6, 0xFDA3, 0x062A, 0x0645, 0x064A, 0,
+    6, 0xFDA4, 0x062A, 0x0645, 0x0649, 0,
+    6, 0xFDA5, 0x062C, 0x0645, 0x064A, 0,
+    6, 0xFDA6, 0x062C, 0x062D, 0x0649, 0,
+    6, 0xFDA7, 0x062C, 0x0645, 0x0649, 0,
+    6, 0xFDA8, 0x0633, 0x062E, 0x0649, 0,
+    6, 0xFDA9, 0x0635, 0x062D, 0x064A, 0,
+    6, 0xFDAA, 0x0634, 0x062D, 0x064A, 0,
+    6, 0xFDAB, 0x0636, 0x062D, 0x064A, 0,
+    6, 0xFDAC, 0x0644, 0x062C, 0x064A, 0,
+    6, 0xFDAD, 0x0644, 0x0645, 0x064A, 0,
+    6, 0xFDAE, 0x064A, 0x062D, 0x064A, 0,
+    6, 0xFDAF, 0x064A, 0x062C, 0x064A, 0,
+    6, 0xFDB0, 0x064A, 0x0645, 0x064A, 0,
+    6, 0xFDB1, 0x0645, 0x0645, 0x064A, 0,
+    6, 0xFDB2, 0x0642, 0x0645, 0x064A, 0,
+    6, 0xFDB3, 0x0646, 0x062D, 0x064A, 0,
+    4, 0xFDB4, 0x0642, 0x0645, 0x062D, 0,
+    4, 0xFDB5, 0x0644, 0x062D, 0x0645, 0,
+    6, 0xFDB6, 0x0639, 0x0645, 0x064A, 0,
+    6, 0xFDB7, 0x0643, 0x0645, 0x064A, 0,
+    4, 0xFDB8, 0x0646, 0x062C, 0x062D, 0,
+    6, 0xFDB9, 0x0645, 0x062E, 0x064A, 0,
+    4, 0xFDBA, 0x0644, 0x062C, 0x0645, 0,
+    6, 0xFDBB, 0x0643, 0x0645, 0x0645, 0,
+    6, 0xFDBC, 0x0644, 0x062C, 0x0645, 0,
+    6, 0xFDBD, 0x0646, 0x062C, 0x062D, 0,
+    6, 0xFDBE, 0x062C, 0x062D, 0x064A, 0,
+    6, 0xFDBF, 0x062D, 0x062C, 0x064A, 0,
+    6, 0xFDC0, 0x0645, 0x062C, 0x064A, 0,
+    6, 0xFDC1, 0x0641, 0x0645, 0x064A, 0,
+    6, 0xFDC2, 0x0628, 0x062D, 0x064A, 0,
+    4, 0xFDC3, 0x0643, 0x0645, 0x0645, 0,
+    4, 0xFDC4, 0x0639, 0x062C, 0x0645, 0,
+    4, 0xFDC5, 0x0635, 0x0645, 0x0645, 0,
+    6, 0xFDC6, 0x0633, 0x062E, 0x064A, 0,
+    6, 0xFDC7, 0x0646, 0x062C, 0x064A, 0,
+    7, 0xFDF0, 0x0635, 0x0644, 0x06D2, 0,
+    7, 0xFDF1, 0x0642, 0x0644, 0x06D2, 0,
+    7, 0xFDF2, 0x0627, 0x0644, 0x0644, 0x0647, 0,
+    7, 0xFDF3, 0x0627, 0x0643, 0x0628, 0x0631, 0,
+    7, 0xFDF4, 0x0645, 0x062D, 0x0645, 0x062F, 0,
+    7, 0xFDF5, 0x0635, 0x0644, 0x0639, 0x0645, 0,
+    7, 0xFDF6, 0x0631, 0x0633, 0x0648, 0x0644, 0,
+    7, 0xFDF7, 0x0639, 0x0644, 0x064A, 0x0647, 0,
+    7, 0xFDF8, 0x0648, 0x0633, 0x0644, 0x0645, 0,
+    7, 0xFDF9, 0x0635, 0x0644, 0x0649, 0,
+    7, 0xFDFA, 0x0635, 0x0644, 0x0649, 0x0020, 0x0627, 0x0644, 0x0644, 0x0647, 0x0020, 0x0639, 0x0644, 0x064A, 0x0647, 0x0020, 0x0648, 0x0633, 0x0644, 0x0645, 0,
+    7, 0xFDFB, 0x062C, 0x0644, 0x0020, 0x062C, 0x0644, 0x0627, 0x0644, 0x0647, 0,
+    7, 0xFDFC, 0x0631, 0x06CC, 0x0627, 0x0644, 0,
+    11, 0xFE30, 0x2025, 0,
+    11, 0xFE31, 0x2014, 0,
+    11, 0xFE32, 0x2013, 0,
+    11, 0xFE33, 0x005F, 0,
+    11, 0xFE34, 0x005F, 0,
+    11, 0xFE35, 0x0028, 0,
+    11, 0xFE36, 0x0029, 0,
+    11, 0xFE37, 0x007B, 0,
+    11, 0xFE38, 0x007D, 0,
+    11, 0xFE39, 0x3014, 0,
+    11, 0xFE3A, 0x3015, 0,
+    11, 0xFE3B, 0x3010, 0,
+    11, 0xFE3C, 0x3011, 0,
+    11, 0xFE3D, 0x300A, 0,
+    11, 0xFE3E, 0x300B, 0,
+    11, 0xFE3F, 0x3008, 0,
+    11, 0xFE40, 0x3009, 0,
+    11, 0xFE41, 0x300C, 0,
+    11, 0xFE42, 0x300D, 0,
+    11, 0xFE43, 0x300E, 0,
+    11, 0xFE44, 0x300F, 0,
+    16, 0xFE49, 0x203E, 0,
+    16, 0xFE4A, 0x203E, 0,
+    16, 0xFE4B, 0x203E, 0,
+    16, 0xFE4C, 0x203E, 0,
+    16, 0xFE4D, 0x005F, 0,
+    16, 0xFE4E, 0x005F, 0,
+    16, 0xFE4F, 0x005F, 0,
+    14, 0xFE50, 0x002C, 0,
+    14, 0xFE51, 0x3001, 0,
+    14, 0xFE52, 0x002E, 0,
+    14, 0xFE54, 0x003B, 0,
+    14, 0xFE55, 0x003A, 0,
+    14, 0xFE56, 0x003F, 0,
+    14, 0xFE57, 0x0021, 0,
+    14, 0xFE58, 0x2014, 0,
+    14, 0xFE59, 0x0028, 0,
+    14, 0xFE5A, 0x0029, 0,
+    14, 0xFE5B, 0x007B, 0,
+    14, 0xFE5C, 0x007D, 0,
+    14, 0xFE5D, 0x3014, 0,
+    14, 0xFE5E, 0x3015, 0,
+    14, 0xFE5F, 0x0023, 0,
+    14, 0xFE60, 0x0026, 0,
+    14, 0xFE61, 0x002A, 0,
+    14, 0xFE62, 0x002B, 0,
+    14, 0xFE63, 0x002D, 0,
+    14, 0xFE64, 0x003C, 0,
+    14, 0xFE65, 0x003E, 0,
+    14, 0xFE66, 0x003D, 0,
+    14, 0xFE68, 0x005C, 0,
+    14, 0xFE69, 0x0024, 0,
+    14, 0xFE6A, 0x0025, 0,
+    14, 0xFE6B, 0x0040, 0,
+    7, 0xFE70, 0x0020, 0x064B, 0,
+    5, 0xFE71, 0x0640, 0x064B, 0,
+    7, 0xFE72, 0x0020, 0x064C, 0,
+    7, 0xFE74, 0x0020, 0x064D, 0,
+    7, 0xFE76, 0x0020, 0x064E, 0,
+    5, 0xFE77, 0x0640, 0x064E, 0,
+    7, 0xFE78, 0x0020, 0x064F, 0,
+    5, 0xFE79, 0x0640, 0x064F, 0,
+    7, 0xFE7A, 0x0020, 0x0650, 0,
+    5, 0xFE7B, 0x0640, 0x0650, 0,
+    7, 0xFE7C, 0x0020, 0x0651, 0,
+    5, 0xFE7D, 0x0640, 0x0651, 0,
+    7, 0xFE7E, 0x0020, 0x0652, 0,
+    5, 0xFE7F, 0x0640, 0x0652, 0,
+    7, 0xFE80, 0x0621, 0,
+    7, 0xFE81, 0x0622, 0,
+    6, 0xFE82, 0x0622, 0,
+    7, 0xFE83, 0x0623, 0,
+    6, 0xFE84, 0x0623, 0,
+    7, 0xFE85, 0x0624, 0,
+    6, 0xFE86, 0x0624, 0,
+    7, 0xFE87, 0x0625, 0,
+    6, 0xFE88, 0x0625, 0,
+    7, 0xFE89, 0x0626, 0,
+    6, 0xFE8A, 0x0626, 0,
+    4, 0xFE8B, 0x0626, 0,
+    5, 0xFE8C, 0x0626, 0,
+    7, 0xFE8D, 0x0627, 0,
+    6, 0xFE8E, 0x0627, 0,
+    7, 0xFE8F, 0x0628, 0,
+    6, 0xFE90, 0x0628, 0,
+    4, 0xFE91, 0x0628, 0,
+    5, 0xFE92, 0x0628, 0,
+    7, 0xFE93, 0x0629, 0,
+    6, 0xFE94, 0x0629, 0,
+    7, 0xFE95, 0x062A, 0,
+    6, 0xFE96, 0x062A, 0,
+    4, 0xFE97, 0x062A, 0,
+    5, 0xFE98, 0x062A, 0,
+    7, 0xFE99, 0x062B, 0,
+    6, 0xFE9A, 0x062B, 0,
+    4, 0xFE9B, 0x062B, 0,
+    5, 0xFE9C, 0x062B, 0,
+    7, 0xFE9D, 0x062C, 0,
+    6, 0xFE9E, 0x062C, 0,
+    4, 0xFE9F, 0x062C, 0,
+    5, 0xFEA0, 0x062C, 0,
+    7, 0xFEA1, 0x062D, 0,
+    6, 0xFEA2, 0x062D, 0,
+    4, 0xFEA3, 0x062D, 0,
+    5, 0xFEA4, 0x062D, 0,
+    7, 0xFEA5, 0x062E, 0,
+    6, 0xFEA6, 0x062E, 0,
+    4, 0xFEA7, 0x062E, 0,
+    5, 0xFEA8, 0x062E, 0,
+    7, 0xFEA9, 0x062F, 0,
+    6, 0xFEAA, 0x062F, 0,
+    7, 0xFEAB, 0x0630, 0,
+    6, 0xFEAC, 0x0630, 0,
+    7, 0xFEAD, 0x0631, 0,
+    6, 0xFEAE, 0x0631, 0,
+    7, 0xFEAF, 0x0632, 0,
+    6, 0xFEB0, 0x0632, 0,
+    7, 0xFEB1, 0x0633, 0,
+    6, 0xFEB2, 0x0633, 0,
+    4, 0xFEB3, 0x0633, 0,
+    5, 0xFEB4, 0x0633, 0,
+    7, 0xFEB5, 0x0634, 0,
+    6, 0xFEB6, 0x0634, 0,
+    4, 0xFEB7, 0x0634, 0,
+    5, 0xFEB8, 0x0634, 0,
+    7, 0xFEB9, 0x0635, 0,
+    6, 0xFEBA, 0x0635, 0,
+    4, 0xFEBB, 0x0635, 0,
+    5, 0xFEBC, 0x0635, 0,
+    7, 0xFEBD, 0x0636, 0,
+    6, 0xFEBE, 0x0636, 0,
+    4, 0xFEBF, 0x0636, 0,
+    5, 0xFEC0, 0x0636, 0,
+    7, 0xFEC1, 0x0637, 0,
+    6, 0xFEC2, 0x0637, 0,
+    4, 0xFEC3, 0x0637, 0,
+    5, 0xFEC4, 0x0637, 0,
+    7, 0xFEC5, 0x0638, 0,
+    6, 0xFEC6, 0x0638, 0,
+    4, 0xFEC7, 0x0638, 0,
+    5, 0xFEC8, 0x0638, 0,
+    7, 0xFEC9, 0x0639, 0,
+    6, 0xFECA, 0x0639, 0,
+    4, 0xFECB, 0x0639, 0,
+    5, 0xFECC, 0x0639, 0,
+    7, 0xFECD, 0x063A, 0,
+    6, 0xFECE, 0x063A, 0,
+    4, 0xFECF, 0x063A, 0,
+    5, 0xFED0, 0x063A, 0,
+    7, 0xFED1, 0x0641, 0,
+    6, 0xFED2, 0x0641, 0,
+    4, 0xFED3, 0x0641, 0,
+    5, 0xFED4, 0x0641, 0,
+    7, 0xFED5, 0x0642, 0,
+    6, 0xFED6, 0x0642, 0,
+    4, 0xFED7, 0x0642, 0,
+    5, 0xFED8, 0x0642, 0,
+    7, 0xFED9, 0x0643, 0,
+    6, 0xFEDA, 0x0643, 0,
+    4, 0xFEDB, 0x0643, 0,
+    5, 0xFEDC, 0x0643, 0,
+    7, 0xFEDD, 0x0644, 0,
+    6, 0xFEDE, 0x0644, 0,
+    4, 0xFEDF, 0x0644, 0,
+    5, 0xFEE0, 0x0644, 0,
+    7, 0xFEE1, 0x0645, 0,
+    6, 0xFEE2, 0x0645, 0,
+    4, 0xFEE3, 0x0645, 0,
+    5, 0xFEE4, 0x0645, 0,
+    7, 0xFEE5, 0x0646, 0,
+    6, 0xFEE6, 0x0646, 0,
+    4, 0xFEE7, 0x0646, 0,
+    5, 0xFEE8, 0x0646, 0,
+    7, 0xFEE9, 0x0647, 0,
+    6, 0xFEEA, 0x0647, 0,
+    4, 0xFEEB, 0x0647, 0,
+    5, 0xFEEC, 0x0647, 0,
+    7, 0xFEED, 0x0648, 0,
+    6, 0xFEEE, 0x0648, 0,
+    7, 0xFEEF, 0x0649, 0,
+    6, 0xFEF0, 0x0649, 0,
+    7, 0xFEF1, 0x064A, 0,
+    6, 0xFEF2, 0x064A, 0,
+    4, 0xFEF3, 0x064A, 0,
+    5, 0xFEF4, 0x064A, 0,
+    7, 0xFEF5, 0x0644, 0x0622, 0,
+    6, 0xFEF6, 0x0644, 0x0622, 0,
+    7, 0xFEF7, 0x0644, 0x0623, 0,
+    6, 0xFEF8, 0x0644, 0x0623, 0,
+    7, 0xFEF9, 0x0644, 0x0625, 0,
+    6, 0xFEFA, 0x0644, 0x0625, 0,
+    7, 0xFEFB, 0x0644, 0x0627, 0,
+    6, 0xFEFC, 0x0644, 0x0627, 0,
+    12, 0xFF01, 0x0021, 0,
+    12, 0xFF02, 0x0022, 0,
+    12, 0xFF03, 0x0023, 0,
+    12, 0xFF04, 0x0024, 0,
+    12, 0xFF05, 0x0025, 0,
+    12, 0xFF06, 0x0026, 0,
+    12, 0xFF07, 0x0027, 0,
+    12, 0xFF08, 0x0028, 0,
+    12, 0xFF09, 0x0029, 0,
+    12, 0xFF0A, 0x002A, 0,
+    12, 0xFF0B, 0x002B, 0,
+    12, 0xFF0C, 0x002C, 0,
+    12, 0xFF0D, 0x002D, 0,
+    12, 0xFF0E, 0x002E, 0,
+    12, 0xFF0F, 0x002F, 0,
+    12, 0xFF10, 0x0030, 0,
+    12, 0xFF11, 0x0031, 0,
+    12, 0xFF12, 0x0032, 0,
+    12, 0xFF13, 0x0033, 0,
+    12, 0xFF14, 0x0034, 0,
+    12, 0xFF15, 0x0035, 0,
+    12, 0xFF16, 0x0036, 0,
+    12, 0xFF17, 0x0037, 0,
+    12, 0xFF18, 0x0038, 0,
+    12, 0xFF19, 0x0039, 0,
+    12, 0xFF1A, 0x003A, 0,
+    12, 0xFF1B, 0x003B, 0,
+    12, 0xFF1C, 0x003C, 0,
+    12, 0xFF1D, 0x003D, 0,
+    12, 0xFF1E, 0x003E, 0,
+    12, 0xFF1F, 0x003F, 0,
+    12, 0xFF20, 0x0040, 0,
+    12, 0xFF21, 0x0041, 0,
+    12, 0xFF22, 0x0042, 0,
+    12, 0xFF23, 0x0043, 0,
+    12, 0xFF24, 0x0044, 0,
+    12, 0xFF25, 0x0045, 0,
+    12, 0xFF26, 0x0046, 0,
+    12, 0xFF27, 0x0047, 0,
+    12, 0xFF28, 0x0048, 0,
+    12, 0xFF29, 0x0049, 0,
+    12, 0xFF2A, 0x004A, 0,
+    12, 0xFF2B, 0x004B, 0,
+    12, 0xFF2C, 0x004C, 0,
+    12, 0xFF2D, 0x004D, 0,
+    12, 0xFF2E, 0x004E, 0,
+    12, 0xFF2F, 0x004F, 0,
+    12, 0xFF30, 0x0050, 0,
+    12, 0xFF31, 0x0051, 0,
+    12, 0xFF32, 0x0052, 0,
+    12, 0xFF33, 0x0053, 0,
+    12, 0xFF34, 0x0054, 0,
+    12, 0xFF35, 0x0055, 0,
+    12, 0xFF36, 0x0056, 0,
+    12, 0xFF37, 0x0057, 0,
+    12, 0xFF38, 0x0058, 0,
+    12, 0xFF39, 0x0059, 0,
+    12, 0xFF3A, 0x005A, 0,
+    12, 0xFF3B, 0x005B, 0,
+    12, 0xFF3C, 0x005C, 0,
+    12, 0xFF3D, 0x005D, 0,
+    12, 0xFF3E, 0x005E, 0,
+    12, 0xFF3F, 0x005F, 0,
+    12, 0xFF40, 0x0060, 0,
+    12, 0xFF41, 0x0061, 0,
+    12, 0xFF42, 0x0062, 0,
+    12, 0xFF43, 0x0063, 0,
+    12, 0xFF44, 0x0064, 0,
+    12, 0xFF45, 0x0065, 0,
+    12, 0xFF46, 0x0066, 0,
+    12, 0xFF47, 0x0067, 0,
+    12, 0xFF48, 0x0068, 0,
+    12, 0xFF49, 0x0069, 0,
+    12, 0xFF4A, 0x006A, 0,
+    12, 0xFF4B, 0x006B, 0,
+    12, 0xFF4C, 0x006C, 0,
+    12, 0xFF4D, 0x006D, 0,
+    12, 0xFF4E, 0x006E, 0,
+    12, 0xFF4F, 0x006F, 0,
+    12, 0xFF50, 0x0070, 0,
+    12, 0xFF51, 0x0071, 0,
+    12, 0xFF52, 0x0072, 0,
+    12, 0xFF53, 0x0073, 0,
+    12, 0xFF54, 0x0074, 0,
+    12, 0xFF55, 0x0075, 0,
+    12, 0xFF56, 0x0076, 0,
+    12, 0xFF57, 0x0077, 0,
+    12, 0xFF58, 0x0078, 0,
+    12, 0xFF59, 0x0079, 0,
+    12, 0xFF5A, 0x007A, 0,
+    12, 0xFF5B, 0x007B, 0,
+    12, 0xFF5C, 0x007C, 0,
+    12, 0xFF5D, 0x007D, 0,
+    12, 0xFF5E, 0x007E, 0,
+    12, 0xFF5F, 0x2985, 0,
+    12, 0xFF60, 0x2986, 0,
+    13, 0xFF61, 0x3002, 0,
+    13, 0xFF62, 0x300C, 0,
+    13, 0xFF63, 0x300D, 0,
+    13, 0xFF64, 0x3001, 0,
+    13, 0xFF65, 0x30FB, 0,
+    13, 0xFF66, 0x30F2, 0,
+    13, 0xFF67, 0x30A1, 0,
+    13, 0xFF68, 0x30A3, 0,
+    13, 0xFF69, 0x30A5, 0,
+    13, 0xFF6A, 0x30A7, 0,
+    13, 0xFF6B, 0x30A9, 0,
+    13, 0xFF6C, 0x30E3, 0,
+    13, 0xFF6D, 0x30E5, 0,
+    13, 0xFF6E, 0x30E7, 0,
+    13, 0xFF6F, 0x30C3, 0,
+    13, 0xFF70, 0x30FC, 0,
+    13, 0xFF71, 0x30A2, 0,
+    13, 0xFF72, 0x30A4, 0,
+    13, 0xFF73, 0x30A6, 0,
+    13, 0xFF74, 0x30A8, 0,
+    13, 0xFF75, 0x30AA, 0,
+    13, 0xFF76, 0x30AB, 0,
+    13, 0xFF77, 0x30AD, 0,
+    13, 0xFF78, 0x30AF, 0,
+    13, 0xFF79, 0x30B1, 0,
+    13, 0xFF7A, 0x30B3, 0,
+    13, 0xFF7B, 0x30B5, 0,
+    13, 0xFF7C, 0x30B7, 0,
+    13, 0xFF7D, 0x30B9, 0,
+    13, 0xFF7E, 0x30BB, 0,
+    13, 0xFF7F, 0x30BD, 0,
+    13, 0xFF80, 0x30BF, 0,
+    13, 0xFF81, 0x30C1, 0,
+    13, 0xFF82, 0x30C4, 0,
+    13, 0xFF83, 0x30C6, 0,
+    13, 0xFF84, 0x30C8, 0,
+    13, 0xFF85, 0x30CA, 0,
+    13, 0xFF86, 0x30CB, 0,
+    13, 0xFF87, 0x30CC, 0,
+    13, 0xFF88, 0x30CD, 0,
+    13, 0xFF89, 0x30CE, 0,
+    13, 0xFF8A, 0x30CF, 0,
+    13, 0xFF8B, 0x30D2, 0,
+    13, 0xFF8C, 0x30D5, 0,
+    13, 0xFF8D, 0x30D8, 0,
+    13, 0xFF8E, 0x30DB, 0,
+    13, 0xFF8F, 0x30DE, 0,
+    13, 0xFF90, 0x30DF, 0,
+    13, 0xFF91, 0x30E0, 0,
+    13, 0xFF92, 0x30E1, 0,
+    13, 0xFF93, 0x30E2, 0,
+    13, 0xFF94, 0x30E4, 0,
+    13, 0xFF95, 0x30E6, 0,
+    13, 0xFF96, 0x30E8, 0,
+    13, 0xFF97, 0x30E9, 0,
+    13, 0xFF98, 0x30EA, 0,
+    13, 0xFF99, 0x30EB, 0,
+    13, 0xFF9A, 0x30EC, 0,
+    13, 0xFF9B, 0x30ED, 0,
+    13, 0xFF9C, 0x30EF, 0,
+    13, 0xFF9D, 0x30F3, 0,
+    13, 0xFF9E, 0x3099, 0,
+    13, 0xFF9F, 0x309A, 0,
+    13, 0xFFA0, 0x3164, 0,
+    13, 0xFFA1, 0x3131, 0,
+    13, 0xFFA2, 0x3132, 0,
+    13, 0xFFA3, 0x3133, 0,
+    13, 0xFFA4, 0x3134, 0,
+    13, 0xFFA5, 0x3135, 0,
+    13, 0xFFA6, 0x3136, 0,
+    13, 0xFFA7, 0x3137, 0,
+    13, 0xFFA8, 0x3138, 0,
+    13, 0xFFA9, 0x3139, 0,
+    13, 0xFFAA, 0x313A, 0,
+    13, 0xFFAB, 0x313B, 0,
+    13, 0xFFAC, 0x313C, 0,
+    13, 0xFFAD, 0x313D, 0,
+    13, 0xFFAE, 0x313E, 0,
+    13, 0xFFAF, 0x313F, 0,
+    13, 0xFFB0, 0x3140, 0,
+    13, 0xFFB1, 0x3141, 0,
+    13, 0xFFB2, 0x3142, 0,
+    13, 0xFFB3, 0x3143, 0,
+    13, 0xFFB4, 0x3144, 0,
+    13, 0xFFB5, 0x3145, 0,
+    13, 0xFFB6, 0x3146, 0,
+    13, 0xFFB7, 0x3147, 0,
+    13, 0xFFB8, 0x3148, 0,
+    13, 0xFFB9, 0x3149, 0,
+    13, 0xFFBA, 0x314A, 0,
+    13, 0xFFBB, 0x314B, 0,
+    13, 0xFFBC, 0x314C, 0,
+    13, 0xFFBD, 0x314D, 0,
+    13, 0xFFBE, 0x314E, 0,
+    13, 0xFFC2, 0x314F, 0,
+    13, 0xFFC3, 0x3150, 0,
+    13, 0xFFC4, 0x3151, 0,
+    13, 0xFFC5, 0x3152, 0,
+    13, 0xFFC6, 0x3153, 0,
+    13, 0xFFC7, 0x3154, 0,
+    13, 0xFFCA, 0x3155, 0,
+    13, 0xFFCB, 0x3156, 0,
+    13, 0xFFCC, 0x3157, 0,
+    13, 0xFFCD, 0x3158, 0,
+    13, 0xFFCE, 0x3159, 0,
+    13, 0xFFCF, 0x315A, 0,
+    13, 0xFFD2, 0x315B, 0,
+    13, 0xFFD3, 0x315C, 0,
+    13, 0xFFD4, 0x315D, 0,
+    13, 0xFFD5, 0x315E, 0,
+    13, 0xFFD6, 0x315F, 0,
+    13, 0xFFD7, 0x3160, 0,
+    13, 0xFFDA, 0x3161, 0,
+    13, 0xFFDB, 0x3162, 0,
+    13, 0xFFDC, 0x3163, 0,
+    12, 0xFFE0, 0x00A2, 0,
+    12, 0xFFE1, 0x00A3, 0,
+    12, 0xFFE2, 0x00AC, 0,
+    12, 0xFFE3, 0x00AF, 0,
+    12, 0xFFE4, 0x00A6, 0,
+    12, 0xFFE5, 0x00A5, 0,
+    12, 0xFFE6, 0x20A9, 0,
+    13, 0xFFE8, 0x2502, 0,
+    13, 0xFFE9, 0x2190, 0,
+    13, 0xFFEA, 0x2191, 0,
+    13, 0xFFEB, 0x2192, 0,
+    13, 0xFFEC, 0x2193, 0,
+    13, 0xFFED, 0x25A0, 0,
+    13, 0xFFEE, 0x25CB, 0,
+
+};
+
+const TQ_UINT16 TQUnicodeTables::decomposition_info[] = {
+    1, 2, 3, 4, 5, 6, 7, 8,
+    8, 9, 10, 11, 12, 13, 14, 15,
+    16, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 17, 18,
+    19, 20, 21, 22, 23, 8, 8, 8,
+    8, 8, 24, 8, 8, 8, 25, 26,
+    27, 28, 29, 30, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 31, 32, 33, 34, 35, 36, 37,
+
+    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, 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, 0, 0, 0, 0, 0, 0, 0,
+    5, 0, 10, 0, 0, 0, 0, 14,
+    0, 0, 19, 23, 27, 32, 0, 0,
+    36, 41, 45, 0, 49, 55, 61, 0,
+    67, 72, 77, 82, 87, 92, 0, 97,
+    102, 107, 112, 117, 122, 127, 132, 137,
+    0, 142, 147, 152, 157, 162, 167, 0,
+    0, 172, 177, 182, 187, 192, 0, 0,
+    197, 202, 207, 212, 217, 222, 0, 227,
+    232, 237, 242, 247, 252, 257, 262, 267,
+    0, 272, 277, 282, 287, 292, 297, 0,
+    0, 302, 307, 312, 317, 322, 0, 327,
+
+    332, 337, 342, 347, 352, 357, 362, 367,
+    372, 377, 382, 387, 392, 397, 402, 407,
+    0, 0, 412, 417, 422, 427, 432, 437,
+    442, 447, 452, 457, 462, 467, 472, 477,
+    482, 487, 492, 497, 502, 507, 0, 0,
+    512, 517, 522, 527, 532, 537, 542, 547,
+    552, 0, 557, 562, 567, 572, 577, 582,
+    0, 587, 592, 597, 602, 607, 612, 617,
+    622, 0, 0, 627, 632, 637, 642, 647,
+    652, 657, 0, 0, 662, 667, 672, 677,
+    682, 687, 0, 0, 692, 697, 702, 707,
+    712, 717, 722, 727, 732, 737, 742, 747,
+    752, 757, 762, 767, 772, 777, 0, 0,
+    782, 787, 792, 797, 802, 807, 812, 817,
+    822, 827, 832, 837, 842, 847, 852, 857,
+    862, 867, 872, 877, 882, 887, 892, 897,
+    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,
+    901, 906, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 911,
+    916, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 921, 926, 931, 936,
+    941, 946, 951, 956, 961, 966, 971, 976,
+    981, 986, 991, 996, 1001, 1006, 1011, 1016,
+    1021, 1026, 1031, 1036, 1041, 0, 1046, 1051,
+    1056, 1061, 1066, 1071, 0, 0, 1076, 1081,
+    1086, 1091, 1096, 1101, 1106, 1111, 1116, 1121,
+    1126, 1131, 1136, 1141, 1146, 1151, 0, 0,
+    1156, 1161, 1166, 1171, 1176, 1181, 1186, 1191,
+
+    1196, 1201, 1206, 1211, 1216, 1221, 1226, 1231,
+    1236, 1241, 1246, 1251, 1256, 1261, 1266, 1271,
+    1276, 1281, 1286, 1291, 1296, 1301, 1306, 1311,
+    1316, 1321, 1326, 1331, 0, 0, 1336, 1341,
+    0, 0, 0, 0, 0, 0, 1346, 1351,
+    1356, 1361, 1366, 1371, 1376, 1381, 1386, 1391,
+    1396, 1401, 1406, 1411, 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, 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,
+    1416, 1420, 1424, 1428, 1432, 1436, 1440, 1444,
+    1448, 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,
+    1452, 1457, 1462, 1467, 1472, 1477, 0, 0,
+    1482, 1486, 1490, 1494, 1498, 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, 0, 0, 0, 0,
+    1502, 1506, 0, 1510, 1514, 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, 1519, 0, 0, 0,
+    0, 0, 1523, 0, 0, 0, 1528, 0,
+    0, 0, 0, 0, 1532, 1537, 1542, 1547,
+    1551, 1556, 1561, 0, 1566, 0, 1571, 1576,
+    1581, 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, 1586, 1591, 1596, 1601, 1606, 1611,
+    1616, 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, 1621, 1626, 1631, 1636, 1641, 0,
+    1646, 1650, 1654, 1658, 1663, 1668, 1672, 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,
+    1676, 1680, 1684, 0, 1688, 1692, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+
+    1696, 1701, 0, 1706, 0, 0, 0, 1711,
+    0, 0, 0, 0, 1716, 1721, 1726, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 1731, 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, 1736, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    1741, 1746, 0, 1751, 0, 0, 0, 1756,
+    0, 0, 0, 0, 1761, 1766, 1771, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 1776, 1781,
+    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, 1786, 1791, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    1796, 1801, 1806, 1811, 0, 0, 1816, 1821,
+    0, 0, 1826, 1831, 1836, 1841, 1846, 1851,
+    0, 0, 1856, 1861, 1866, 1871, 1876, 1881,
+    0, 0, 1886, 1891, 1896, 1901, 1906, 1911,
+    1916, 1921, 1926, 1931, 1936, 1941, 0, 0,
+    1946, 1951, 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, 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, 1956,
+    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, 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, 1961, 1966, 1971, 1976, 1981, 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, 1986, 1991, 1996,
+    2001, 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,
+    2006, 0, 2011, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 2016, 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, 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, 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, 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, 2021, 0, 0, 0, 0, 0, 0,
+    0, 2026, 0, 0, 2031, 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,
+    2036, 2041, 2046, 2051, 2056, 2061, 2066, 2071,
+    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, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 2076, 2081, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 2086, 2091, 0, 2096,
+    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, 2101, 0, 0, 2106, 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, 2111, 2116, 2121, 0, 0, 2126, 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, 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, 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,
+    2131, 0, 0, 2136, 2141, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 2146, 2151, 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, 2156, 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, 2161, 2166, 2171, 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, 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,
+    2176, 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,
+    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,
+    2181, 0, 0, 0, 0, 0, 0, 2186,
+    2191, 0, 2196, 2201, 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, 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, 2206, 2211, 2216, 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, 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, 2221, 0, 2226, 2231, 2236, 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, 2241, 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, 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, 2246, 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, 2251, 2256, 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, 2261, 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, 2265, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 2270, 0, 0,
+    0, 0, 2275, 0, 0, 0, 0, 2280,
+    0, 0, 0, 0, 2285, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 2290, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 2295, 0, 2300, 2305, 2310,
+    2315, 2320, 0, 0, 0, 0, 0, 0,
+    0, 2325, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 2330, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 2335, 0, 0,
+    0, 0, 2340, 0, 0, 0, 0, 2345,
+    0, 0, 0, 0, 2350, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 2355, 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, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 2360, 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, 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, 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,
+
+    2365, 2370, 2375, 2380, 2385, 2390, 2395, 2400,
+    2405, 2410, 2415, 2420, 2425, 2430, 2435, 2440,
+    2445, 2450, 2455, 2460, 2465, 2470, 2475, 2480,
+    2485, 2490, 2495, 2500, 2505, 2510, 2515, 2520,
+    2525, 2530, 2535, 2540, 2545, 2550, 2555, 2560,
+    2565, 2570, 2575, 2580, 2585, 2590, 2595, 2600,
+    2605, 2610, 2615, 2620, 2625, 2630, 2635, 2640,
+    2645, 2650, 2655, 2660, 2665, 2670, 2675, 2680,
+    2685, 2690, 2695, 2700, 2705, 2710, 2715, 2720,
+    2725, 2730, 2735, 2740, 2745, 2750, 2755, 2760,
+    2765, 2770, 2775, 2780, 2785, 2790, 2795, 2800,
+    2805, 2810, 2815, 2820, 2825, 2830, 2835, 2840,
+    2845, 2850, 2855, 2860, 2865, 2870, 2875, 2880,
+    2885, 2890, 2895, 2900, 2905, 2910, 2915, 2920,
+    2925, 2930, 2935, 2940, 2945, 2950, 2955, 2960,
+    2965, 2970, 2975, 2980, 2985, 2990, 2995, 3000,
+    3005, 3010, 3015, 3020, 3025, 3030, 3035, 3040,
+    3045, 3050, 3055, 3060, 3065, 3070, 3075, 3080,
+    3085, 3090, 3095, 3100, 3105, 3110, 3115, 3120,
+    3125, 3130, 3135, 3140, 0, 0, 0, 0,
+    3145, 3150, 3155, 3160, 3165, 3170, 3175, 3180,
+    3185, 3190, 3195, 3200, 3205, 3210, 3215, 3220,
+    3225, 3230, 3235, 3240, 3245, 3250, 3255, 3260,
+    3265, 3270, 3275, 3280, 3285, 3290, 3295, 3300,
+    3305, 3310, 3315, 3320, 3325, 3330, 3335, 3340,
+    3345, 3350, 3355, 3360, 3365, 3370, 3375, 3380,
+    3385, 3390, 3395, 3400, 3405, 3410, 3415, 3420,
+    3425, 3430, 3435, 3440, 3445, 3450, 3455, 3460,
+    3465, 3470, 3475, 3480, 3485, 3490, 3495, 3500,
+    3505, 3510, 3515, 3520, 3525, 3530, 3535, 3540,
+    3545, 3550, 3555, 3560, 3565, 3570, 3575, 3580,
+    3585, 3590, 0, 0, 0, 0, 0, 0,
+
+    3595, 3600, 3605, 3610, 3615, 3620, 3625, 3630,
+    3635, 3640, 3645, 3650, 3655, 3660, 3665, 3670,
+    3675, 3680, 3685, 3690, 3695, 3700, 0, 0,
+    3705, 3710, 3715, 3720, 3725, 3730, 0, 0,
+    3735, 3740, 3745, 3750, 3755, 3760, 3765, 3770,
+    3775, 3780, 3785, 3790, 3795, 3800, 3805, 3810,
+    3815, 3820, 3825, 3830, 3835, 3840, 3845, 3850,
+    3855, 3860, 3865, 3870, 3875, 3880, 3885, 3890,
+    3895, 3900, 3905, 3910, 3915, 3920, 0, 0,
+    3925, 3930, 3935, 3940, 3945, 3950, 0, 0,
+    3955, 3960, 3965, 3970, 3975, 3980, 3985, 3990,
+    0, 3995, 0, 4000, 0, 4005, 0, 4010,
+    4015, 4020, 4025, 4030, 4035, 4040, 4045, 4050,
+    4055, 4060, 4065, 4070, 4075, 4080, 4085, 4090,
+    4095, 4100, 4104, 4109, 4113, 4118, 4122, 4127,
+    4131, 4136, 4140, 4145, 4149, 4154, 0, 0,
+    4158, 4163, 4168, 4173, 4178, 4183, 4188, 4193,
+    4198, 4203, 4208, 4213, 4218, 4223, 4228, 4233,
+    4238, 4243, 4248, 4253, 4258, 4263, 4268, 4273,
+    4278, 4283, 4288, 4293, 4298, 4303, 4308, 4313,
+    4318, 4323, 4328, 4333, 4338, 4343, 4348, 4353,
+    4358, 4363, 4368, 4373, 4378, 4383, 4388, 4393,
+    4398, 4403, 4408, 4413, 4418, 0, 4423, 4428,
+    4433, 4438, 4443, 4448, 4452, 4457, 4462, 4466,
+    4471, 4476, 4481, 4486, 4491, 0, 4496, 4501,
+    4506, 4511, 4515, 4520, 4524, 4529, 4534, 4539,
+    4544, 4549, 4554, 4559, 0, 0, 4563, 4568,
+    4573, 4578, 4583, 4588, 0, 4592, 4597, 4602,
+    4607, 4612, 4617, 4622, 4626, 4631, 4636, 4641,
+    4646, 4651, 4656, 4661, 4665, 4670, 4675, 4679,
+    0, 0, 4683, 4688, 4693, 0, 4698, 4703,
+    4708, 4713, 4717, 4722, 4726, 4731, 4735, 0,
+
+    4740, 4744, 4748, 4752, 4756, 4760, 4764, 4768,
+    4772, 4776, 4780, 0, 0, 0, 0, 0,
+    0, 4784, 0, 0, 0, 0, 0, 4788,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 4793, 4797, 4802, 0,
+    0, 0, 0, 0, 0, 0, 0, 4808,
+    0, 0, 0, 4812, 4817, 0, 4823, 4828,
+    0, 0, 0, 0, 4834, 0, 4839, 0,
+    0, 0, 0, 0, 0, 0, 0, 4844,
+    4849, 4854, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 4859,
+    0, 0, 0, 0, 0, 0, 0, 4866,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    4870, 4874, 0, 0, 4878, 4882, 4886, 4890,
+    4894, 4898, 4902, 4906, 4910, 4914, 4918, 4922,
+    4926, 4930, 4934, 4938, 4942, 4946, 4950, 4954,
+    4958, 4962, 4966, 4970, 4974, 4978, 4982, 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,
+    4986, 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,
+
+    4991, 4997, 5003, 5007, 0, 5012, 5018, 5024,
+    0, 5028, 5033, 5037, 5041, 5045, 5049, 5053,
+    5057, 5061, 5065, 5069, 0, 5073, 5077, 0,
+    0, 5082, 5086, 5090, 5094, 5098, 0, 0,
+    5102, 5107, 5113, 0, 5118, 0, 5122, 0,
+    5126, 0, 5130, 5134, 5138, 5142, 0, 5146,
+    5150, 5154, 0, 5158, 5162, 5166, 5170, 5174,
+    5178, 5182, 0, 0, 0, 5186, 5190, 5194,
+    5198, 0, 0, 0, 0, 5202, 5206, 5210,
+    5214, 5218, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 5222, 5228, 5234, 5240, 5246,
+    5252, 5258, 5264, 5270, 5276, 5282, 5288, 5294,
+    5299, 5303, 5308, 5314, 5319, 5323, 5328, 5334,
+    5341, 5346, 5350, 5355, 5361, 5365, 5369, 5373,
+    5377, 5381, 5386, 5392, 5397, 5401, 5406, 5412,
+    5419, 5424, 5428, 5433, 5439, 5443, 5447, 5451,
+    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, 5455, 5460, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 5465, 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, 5470, 5475, 5480,
+    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, 5485, 0, 0, 0,
+    0, 5490, 0, 0, 5495, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 5500, 0, 5505, 0,
+    0, 0, 0, 0, 5510, 5515, 0, 5521,
+    5526, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 5532, 0, 0, 5537, 0, 0, 5542,
+    0, 5547, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    5552, 0, 5557, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 5562, 5567, 5572,
+    5577, 5582, 0, 0, 5587, 5592, 0, 0,
+    5597, 5602, 0, 0, 0, 0, 0, 0,
+    5607, 5612, 0, 0, 5617, 5622, 0, 0,
+    5627, 5632, 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, 5637, 5642, 5647, 5652,
+    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,
+    5657, 5662, 5667, 5672, 0, 0, 0, 0,
+    0, 0, 5677, 5682, 5687, 5692, 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, 5697, 5701, 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, 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, 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,
+    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,
+    5705, 5709, 5713, 5717, 5721, 5725, 5729, 5733,
+    5737, 5741, 5746, 5751, 5756, 5761, 5766, 5771,
+    5776, 5781, 5786, 5791, 5796, 5802, 5808, 5814,
+    5820, 5826, 5832, 5838, 5844, 5850, 5857, 5864,
+    5871, 5878, 5885, 5892, 5899, 5906, 5913, 5920,
+    5927, 5932, 5937, 5942, 5947, 5952, 5957, 5962,
+    5967, 5972, 5978, 5984, 5990, 5996, 6002, 6008,
+    6014, 6020, 6026, 6032, 6038, 6044, 6050, 6056,
+    6062, 6068, 6074, 6080, 6086, 6092, 6098, 6104,
+    6110, 6116, 6122, 6128, 6134, 6140, 6146, 6152,
+    6158, 6164, 6170, 6176, 6182, 6188, 6194, 6198,
+    6202, 6206, 6210, 6214, 6218, 6222, 6226, 6230,
+    6234, 6238, 6242, 6246, 6250, 6254, 6258, 6262,
+    6266, 6270, 6274, 6278, 6282, 6286, 6290, 6294,
+    6298, 6302, 6306, 6310, 6314, 6318, 6322, 6326,
+    6330, 6334, 6338, 6342, 6346, 6350, 6354, 6358,
+    6362, 6366, 6370, 6374, 6378, 6382, 6386, 6390,
+    6394, 6398, 6402, 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, 6406, 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, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 6413, 6419, 6424, 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, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 6430, 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, 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, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 6435,
+    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, 6439, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+
+    6443, 6447, 6451, 6455, 6459, 6463, 6467, 6471,
+    6475, 6479, 6483, 6487, 6491, 6495, 6499, 6503,
+    6507, 6511, 6515, 6519, 6523, 6527, 6531, 6535,
+    6539, 6543, 6547, 6551, 6555, 6559, 6563, 6567,
+    6571, 6575, 6579, 6583, 6587, 6591, 6595, 6599,
+    6603, 6607, 6611, 6615, 6619, 6623, 6627, 6631,
+    6635, 6639, 6643, 6647, 6651, 6655, 6659, 6663,
+    6667, 6671, 6675, 6679, 6683, 6687, 6691, 6695,
+    6699, 6703, 6707, 6711, 6715, 6719, 6723, 6727,
+    6731, 6735, 6739, 6743, 6747, 6751, 6755, 6759,
+    6763, 6767, 6771, 6775, 6779, 6783, 6787, 6791,
+    6795, 6799, 6803, 6807, 6811, 6815, 6819, 6823,
+    6827, 6831, 6835, 6839, 6843, 6847, 6851, 6855,
+    6859, 6863, 6867, 6871, 6875, 6879, 6883, 6887,
+    6891, 6895, 6899, 6903, 6907, 6911, 6915, 6919,
+    6923, 6927, 6931, 6935, 6939, 6943, 6947, 6951,
+    6955, 6959, 6963, 6967, 6971, 6975, 6979, 6983,
+    6987, 6991, 6995, 6999, 7003, 7007, 7011, 7015,
+    7019, 7023, 7027, 7031, 7035, 7039, 7043, 7047,
+    7051, 7055, 7059, 7063, 7067, 7071, 7075, 7079,
+    7083, 7087, 7091, 7095, 7099, 7103, 7107, 7111,
+    7115, 7119, 7123, 7127, 7131, 7135, 7139, 7143,
+    7147, 7151, 7155, 7159, 7163, 7167, 7171, 7175,
+    7179, 7183, 7187, 7191, 7195, 7199, 7203, 7207,
+    7211, 7215, 7219, 7223, 7227, 7231, 7235, 7239,
+    7243, 7247, 7251, 7255, 7259, 7263, 7267, 7271,
+    7275, 7279, 7283, 7287, 7291, 7295, 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,
+
+    7299, 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, 7303, 0,
+    7307, 7311, 7315, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 7319, 0, 7324, 0,
+    7329, 0, 7334, 0, 7339, 0, 7344, 0,
+    7349, 0, 7354, 0, 7359, 0, 7364, 0,
+    7369, 0, 7374, 0, 0, 7379, 0, 7384,
+    0, 7389, 0, 0, 0, 0, 0, 0,
+    7394, 7399, 0, 7404, 7409, 0, 7414, 7419,
+    0, 7424, 7429, 0, 7434, 7439, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 7444, 0, 0, 0,
+    0, 0, 0, 7449, 7454, 0, 7459, 7464,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 7469, 0, 7474, 0,
+    7479, 0, 7484, 0, 7489, 0, 7494, 0,
+    7499, 0, 7504, 0, 7509, 0, 7514, 0,
+    7519, 0, 7524, 0, 0, 7529, 0, 7534,
+    0, 7539, 0, 0, 0, 0, 0, 0,
+    7544, 7549, 0, 7554, 7559, 0, 7564, 7569,
+    0, 7574, 7579, 0, 7584, 7589, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 7594, 0, 0, 7599,
+    7604, 7609, 7614, 0, 0, 0, 7619, 7624,
+
+    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, 7629, 7633, 7637, 7641, 7645, 7649, 7653,
+    7657, 7661, 7665, 7669, 7673, 7677, 7681, 7685,
+    7689, 7693, 7697, 7701, 7705, 7709, 7713, 7717,
+    7721, 7725, 7729, 7733, 7737, 7741, 7745, 7749,
+    7753, 7757, 7761, 7765, 7769, 7773, 7777, 7781,
+    7785, 7789, 7793, 7797, 7801, 7805, 7809, 7813,
+    7817, 7821, 7825, 7829, 7833, 7837, 7841, 7845,
+    7849, 7853, 7857, 7861, 7865, 7869, 7873, 7877,
+    7881, 7885, 7889, 7893, 7897, 7901, 7905, 7909,
+    7913, 7917, 7921, 7925, 7929, 7933, 7937, 7941,
+    7945, 7949, 7953, 7957, 7961, 7965, 7969, 7973,
+    7977, 7981, 7985, 7989, 7993, 7997, 8001, 0,
+    0, 0, 8005, 8009, 8013, 8017, 8021, 8025,
+    8029, 8033, 8037, 8041, 8045, 8049, 8053, 8057,
+    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, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+
+    8061, 8067, 8073, 8079, 8085, 8091, 8097, 8103,
+    8109, 8115, 8121, 8127, 8133, 8139, 8145, 8152,
+    8159, 8166, 8173, 8180, 8187, 8194, 8201, 8208,
+    8215, 8222, 8229, 8236, 8243, 0, 0, 0,
+    8250, 8256, 8262, 8268, 8274, 8280, 8286, 8292,
+    8298, 8304, 8310, 8316, 8322, 8328, 8334, 8340,
+    8346, 8352, 8358, 8364, 8370, 8376, 8382, 8388,
+    8394, 8400, 8406, 8412, 8418, 8424, 8430, 8436,
+    8442, 8448, 8454, 8460, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 8466, 8471, 8476, 8481, 8486, 8491, 8496,
+    8501, 8506, 8511, 8516, 8521, 8526, 8531, 8536,
+    8541, 8545, 8549, 8553, 8557, 8561, 8565, 8569,
+    8573, 8577, 8581, 8585, 8589, 8593, 8597, 8602,
+    8607, 8612, 8617, 8622, 8627, 8632, 8637, 8642,
+    8647, 8652, 8657, 8662, 0, 0, 0, 0,
+    8667, 8671, 8675, 8679, 8683, 8687, 8691, 8695,
+    8699, 8703, 8707, 8711, 8715, 8719, 8723, 8727,
+    8731, 8735, 8739, 8743, 8747, 8751, 8755, 8759,
+    8763, 8767, 8771, 8775, 8779, 8783, 8787, 8791,
+    8795, 8799, 8803, 8807, 8811, 8815, 8819, 8823,
+    8827, 8831, 8835, 8839, 8843, 8847, 8851, 8855,
+    8859, 8863, 8868, 8873, 8878, 8883, 8888, 8893,
+    8898, 8903, 8908, 8913, 8918, 8923, 8928, 8933,
+    8938, 8943, 8948, 8953, 8958, 8963, 8968, 8973,
+    8978, 8983, 8989, 8995, 0, 0, 0, 0,
+    9001, 9005, 9009, 9013, 9017, 9021, 9025, 9029,
+    9033, 9037, 9041, 9045, 9049, 9053, 9057, 9061,
+    9065, 9069, 9073, 9077, 9081, 9085, 9089, 9093,
+    9097, 9101, 9105, 9109, 9113, 9117, 9121, 9125,
+    9129, 9133, 9137, 9141, 9145, 9149, 9153, 9157,
+    9161, 9165, 9169, 9173, 9177, 9181, 9185, 0,
+
+    9189, 9196, 9203, 9210, 9216, 9223, 9229, 9235,
+    9243, 9250, 9256, 9262, 9268, 9275, 9282, 9288,
+    9294, 9299, 9305, 9312, 9319, 9324, 9332, 9341,
+    9349, 9355, 9363, 9371, 9378, 9384, 9390, 9396,
+    9403, 9411, 9418, 9424, 9430, 9436, 9441, 9446,
+    9451, 9456, 9462, 9468, 9476, 9482, 9489, 9497,
+    9503, 9508, 9513, 9521, 9528, 9536, 9542, 9550,
+    9555, 9561, 9567, 9573, 9579, 9585, 9592, 9598,
+    9603, 9609, 9615, 9621, 9628, 9634, 9640, 9646,
+    9654, 9661, 9666, 9674, 9679, 9686, 9693, 9699,
+    9705, 9711, 9718, 9723, 9729, 9736, 9741, 9749,
+    9755, 9760, 9765, 9770, 9775, 9780, 9785, 9790,
+    9795, 9800, 9805, 9811, 9817, 9823, 9829, 9835,
+    9841, 9847, 9853, 9859, 9865, 9871, 9877, 9883,
+    9889, 9895, 9901, 9906, 9911, 9917, 9922, 0,
+    0, 0, 0, 9927, 9932, 9937, 9942, 9947,
+    9954, 9959, 9964, 9969, 9974, 9979, 9984, 9989,
+    9994, 10000, 10007, 10012, 10017, 10022, 10027, 10032,
+    10037, 10042, 10048, 10054, 10060, 10066, 10071, 10076,
+    10081, 10086, 10091, 10096, 10101, 10106, 10111, 10116,
+    10122, 10128, 10133, 10139, 10145, 10151, 10156, 10162,
+    10168, 10175, 10180, 10186, 10192, 10198, 10204, 10212,
+    10221, 10226, 10231, 10236, 10241, 10246, 10251, 10256,
+    10261, 10266, 10271, 10276, 10281, 10286, 10291, 10296,
+    10301, 10306, 10311, 10318, 10323, 10328, 10333, 10340,
+    10346, 10351, 10356, 10361, 10366, 10371, 10376, 10381,
+    10386, 10391, 10396, 10402, 10407, 10412, 10418, 10424,
+    10429, 10436, 10442, 10447, 10452, 10457, 0, 0,
+    10462, 10467, 10472, 10477, 10482, 10487, 10492, 10497,
+    10502, 10507, 10513, 10519, 10525, 10531, 10537, 10543,
+    10549, 10555, 10561, 10567, 10573, 10579, 10585, 10591,
+    10597, 10603, 10609, 10615, 10621, 10627, 10633, 0,
+
+    10639, 10643, 10647, 10651, 10655, 10659, 10663, 10667,
+    10671, 10675, 10679, 10683, 10687, 10691, 10695, 10699,
+    10703, 10707, 10711, 10715, 10719, 10723, 10727, 10731,
+    10735, 10739, 10743, 10747, 10751, 10755, 10759, 10763,
+    10767, 10771, 10775, 10779, 10783, 10787, 10791, 10795,
+    10799, 10803, 10807, 10811, 10815, 10819, 10823, 10827,
+    10831, 10835, 10839, 10843, 10847, 10851, 10855, 10859,
+    10863, 10867, 10871, 10875, 10879, 10883, 10887, 10891,
+    10895, 10899, 10903, 10907, 10911, 10915, 10919, 10923,
+    10927, 10931, 10935, 10939, 10943, 10947, 10951, 10955,
+    10959, 10963, 10967, 10971, 10975, 10979, 10983, 10987,
+    10991, 10995, 10999, 11003, 11007, 11011, 11015, 11019,
+    11023, 11027, 11031, 11035, 11039, 11043, 11047, 11051,
+    11055, 11059, 11063, 11067, 11071, 11075, 11079, 11083,
+    11087, 11091, 11095, 11099, 11103, 11107, 11111, 11115,
+    11119, 11123, 11127, 11131, 11135, 11139, 11143, 11147,
+    11151, 11155, 11159, 11163, 11167, 11171, 11175, 11179,
+    11183, 11187, 11191, 11195, 11199, 11203, 11207, 11211,
+    11215, 11219, 11223, 11227, 11231, 11235, 11239, 11243,
+    11247, 11251, 11255, 11259, 11263, 11267, 11271, 11275,
+    11279, 11283, 11287, 11291, 11295, 11299, 11303, 11307,
+    11311, 11315, 11319, 11323, 11327, 11331, 11335, 11339,
+    11343, 11347, 11351, 11355, 11359, 11363, 11367, 11371,
+    11375, 11379, 11383, 11387, 11391, 11395, 11399, 11403,
+    11407, 11411, 11415, 11419, 11423, 11427, 11431, 11435,
+    11439, 11443, 11447, 11451, 11455, 11459, 11463, 11467,
+    11471, 11475, 11479, 11483, 11487, 11491, 11495, 11499,
+    11503, 11507, 11511, 11515, 11519, 11523, 11527, 11531,
+    11535, 11539, 11543, 11547, 11551, 11555, 11559, 11563,
+    11567, 11571, 11575, 11579, 11583, 11587, 11591, 11595,
+    11599, 11603, 11607, 11611, 11615, 11619, 11623, 11627,
+    11631, 11635, 11639, 11643, 11647, 11651, 11655, 11659,
+
+    11663, 11667, 11671, 11675, 11679, 11683, 11687, 11691,
+    11695, 11699, 11703, 11707, 11711, 11715, 0, 0,
+    11719, 0, 11723, 0, 0, 11727, 11731, 11735,
+    11739, 11743, 11747, 11751, 11755, 11759, 11763, 0,
+    11767, 0, 11771, 0, 0, 11775, 11779, 0,
+    0, 0, 11783, 11787, 11791, 11795, 0, 0,
+    11799, 11803, 11807, 11811, 11815, 11819, 11823, 11827,
+    11831, 11835, 11839, 11843, 11847, 11851, 11855, 11859,
+    11863, 11867, 11871, 11875, 11879, 11883, 11887, 11891,
+    11895, 11899, 11903, 11907, 11911, 11915, 11919, 11923,
+    11927, 11931, 11935, 11939, 11943, 11947, 11951, 11955,
+    11959, 11963, 11967, 11971, 11975, 11979, 11983, 11987,
+    11991, 11995, 11999, 12003, 12007, 12011, 12015, 12019,
+    12023, 12027, 12031, 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, 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,
+
+    12035, 12040, 12045, 12050, 12056, 12062, 12067, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 12072, 12077, 12082, 12087, 12092,
+    0, 0, 0, 0, 0, 12097, 0, 12102,
+    12107, 12111, 12115, 12119, 12123, 12127, 12131, 12135,
+    12139, 12143, 12147, 12152, 12157, 12162, 12167, 12172,
+    12177, 12182, 12187, 12192, 12197, 12202, 12207, 0,
+    12212, 12217, 12222, 12227, 12232, 0, 12237, 0,
+    12242, 12247, 0, 12252, 12257, 0, 12262, 12267,
+    12272, 12277, 12282, 12287, 12292, 12297, 12302, 12307,
+    12312, 12316, 12320, 12324, 12328, 12332, 12336, 12340,
+    12344, 12348, 12352, 12356, 12360, 12364, 12368, 12372,
+    12376, 12380, 12384, 12388, 12392, 12396, 12400, 12404,
+    12408, 12412, 12416, 12420, 12424, 12428, 12432, 12436,
+    12440, 12444, 12448, 12452, 12456, 12460, 12464, 12468,
+    12472, 12476, 12480, 12484, 12488, 12492, 12496, 12500,
+    12504, 12508, 12512, 12516, 12520, 12524, 12528, 12532,
+    12536, 12540, 12544, 12548, 12552, 12556, 12560, 12564,
+    12568, 12572, 12576, 12580, 12584, 12588, 12592, 12596,
+    12600, 12604, 12608, 12612, 12616, 12620, 12624, 12628,
+    12632, 12636, 12640, 12644, 12648, 12652, 12656, 12660,
+    12664, 12668, 12672, 12676, 12680, 12684, 12688, 12692,
+    12696, 12700, 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, 12704, 12708, 12712, 12716, 12720,
+    12724, 12728, 12732, 12736, 12740, 12744, 12748, 12752,
+    12756, 12760, 12764, 12768, 12772, 12776, 12780, 12784,
+    12788, 12792, 12796, 12801, 12806, 12811, 12816, 12821,
+    12826, 12831, 12836, 12841, 12846, 12851, 12856, 12861,
+    12866, 12871, 12876, 12881, 12886, 12890, 12894, 12898,
+
+    12902, 12907, 12912, 12917, 12922, 12927, 12932, 12937,
+    12942, 12947, 12952, 12957, 12962, 12967, 12972, 12977,
+    12982, 12987, 12992, 12997, 13002, 13007, 13012, 13017,
+    13022, 13027, 13032, 13037, 13042, 13047, 13052, 13057,
+    13062, 13067, 13072, 13077, 13082, 13087, 13092, 13097,
+    13102, 13107, 13112, 13117, 13122, 13127, 13132, 13137,
+    13142, 13147, 13152, 13157, 13162, 13167, 13172, 13177,
+    13182, 13187, 13192, 13197, 13202, 13207, 13212, 13217,
+    13222, 13227, 13232, 13237, 13242, 13247, 13252, 13257,
+    13262, 13267, 13272, 13277, 13282, 13287, 13292, 13297,
+    13302, 13307, 13312, 13317, 13322, 13327, 13332, 13337,
+    13342, 13347, 13352, 13357, 13362, 13367, 13372, 13378,
+    13384, 13390, 13396, 13402, 13408, 13413, 13418, 13423,
+    13428, 13433, 13438, 13443, 13448, 13453, 13458, 13463,
+    13468, 13473, 13478, 13483, 13488, 13493, 13498, 13503,
+    13508, 13513, 13518, 13523, 13528, 13533, 13538, 13543,
+    13548, 13553, 13558, 13563, 13568, 13573, 13578, 13583,
+    13588, 13593, 13598, 13603, 13608, 13613, 13618, 13623,
+    13628, 13633, 13638, 13643, 13648, 13653, 13658, 13663,
+    13668, 13673, 13678, 13683, 13688, 13693, 13698, 13703,
+    13708, 13713, 13718, 13723, 13728, 13733, 13738, 13743,
+    13748, 13753, 13758, 13763, 13768, 13773, 13778, 13783,
+    13788, 13793, 13798, 13803, 13808, 13813, 13818, 13823,
+    13828, 13833, 13838, 13843, 13848, 13853, 13858, 13863,
+    13868, 13873, 13878, 13883, 13888, 13893, 13898, 13903,
+    13908, 13913, 13918, 13923, 13928, 13933, 13938, 13943,
+    13948, 13953, 13958, 13963, 13968, 13973, 13978, 13983,
+    13988, 13993, 13998, 14003, 14008, 14013, 14018, 14023,
+    14028, 14033, 14038, 14043, 14048, 14053, 14058, 14063,
+    14068, 14073, 14078, 14083, 14088, 14093, 14098, 14103,
+    14108, 14113, 14118, 14124, 14130, 14136, 14141, 14146,
+    14151, 14156, 14161, 14166, 14171, 14176, 14181, 14186,
+
+    14191, 14196, 14201, 14206, 14211, 14216, 14221, 14226,
+    14231, 14236, 14241, 14246, 14251, 14256, 14261, 14266,
+    14271, 14276, 14281, 14286, 14291, 14296, 14301, 14306,
+    14311, 14316, 14321, 14326, 14331, 14336, 14341, 14346,
+    14351, 14356, 14361, 14366, 14371, 14376, 14381, 14386,
+    14391, 14396, 14401, 14406, 14411, 14416, 14421, 14426,
+    14431, 14436, 14441, 14446, 14451, 14456, 14461, 14466,
+    14471, 14476, 14481, 14486, 14491, 14496, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    14501, 14507, 14513, 14519, 14525, 14531, 14537, 14543,
+    14549, 14555, 14561, 14567, 14573, 14579, 14585, 14591,
+    14597, 14603, 14609, 14615, 14621, 14627, 14633, 14639,
+    14645, 14651, 14657, 14663, 14669, 14675, 14681, 14687,
+    14693, 14699, 14705, 14711, 14717, 14723, 14729, 14735,
+    14741, 14747, 14753, 14759, 14765, 14771, 14777, 14783,
+    14789, 14795, 14801, 14807, 14813, 14819, 14825, 14831,
+    14837, 14843, 14849, 14855, 14861, 14867, 14873, 14879,
+    0, 0, 14885, 14891, 14897, 14903, 14909, 14915,
+    14921, 14927, 14933, 14939, 14945, 14951, 14957, 14963,
+    14969, 14975, 14981, 14987, 14993, 14999, 15005, 15011,
+    15017, 15023, 15029, 15035, 15041, 15047, 15053, 15059,
+    15065, 15071, 15077, 15083, 15089, 15095, 15101, 15107,
+    15113, 15119, 15125, 15131, 15137, 15143, 15149, 15155,
+    15161, 15167, 15173, 15179, 15185, 15191, 15197, 15203,
+    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,
+    15209, 15215, 15221, 15228, 15235, 15242, 15249, 15256,
+    15263, 15270, 15276, 15297, 15308, 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,
+    15315, 15319, 15323, 15327, 15331, 15335, 15339, 15343,
+    15347, 15351, 15355, 15359, 15363, 15367, 15371, 15375,
+    15379, 15383, 15387, 15391, 15395, 0, 0, 0,
+    0, 15399, 15403, 15407, 15411, 15415, 15419, 15423,
+    15427, 15431, 15435, 0, 15439, 15443, 15447, 15451,
+    15455, 15459, 15463, 15467, 15471, 15475, 15479, 15483,
+    15487, 15491, 15495, 15499, 15503, 15507, 15511, 0,
+    15515, 15519, 15523, 15527, 0, 0, 0, 0,
+    15531, 15536, 15541, 0, 15546, 0, 15551, 15556,
+    15561, 15566, 15571, 15576, 15581, 15586, 15591, 15596,
+    15601, 15605, 15609, 15613, 15617, 15621, 15625, 15629,
+    15633, 15637, 15641, 15645, 15649, 15653, 15657, 15661,
+    15665, 15669, 15673, 15677, 15681, 15685, 15689, 15693,
+    15697, 15701, 15705, 15709, 15713, 15717, 15721, 15725,
+    15729, 15733, 15737, 15741, 15745, 15749, 15753, 15757,
+    15761, 15765, 15769, 15773, 15777, 15781, 15785, 15789,
+    15793, 15797, 15801, 15805, 15809, 15813, 15817, 15821,
+    15825, 15829, 15833, 15837, 15841, 15845, 15849, 15853,
+    15857, 15861, 15865, 15869, 15873, 15877, 15881, 15885,
+    15889, 15893, 15897, 15901, 15905, 15909, 15913, 15917,
+    15921, 15925, 15929, 15933, 15937, 15941, 15945, 15949,
+    15953, 15957, 15961, 15965, 15969, 15973, 15977, 15981,
+    15985, 15989, 15993, 15997, 16001, 16005, 16009, 16013,
+    16017, 16021, 16025, 16029, 16033, 16037, 16041, 16045,
+    16049, 16053, 16057, 16061, 16065, 16069, 16074, 16079,
+    16084, 16089, 16094, 16099, 16104, 0, 0, 0,
+
+    0, 16109, 16113, 16117, 16121, 16125, 16129, 16133,
+    16137, 16141, 16145, 16149, 16153, 16157, 16161, 16165,
+    16169, 16173, 16177, 16181, 16185, 16189, 16193, 16197,
+    16201, 16205, 16209, 16213, 16217, 16221, 16225, 16229,
+    16233, 16237, 16241, 16245, 16249, 16253, 16257, 16261,
+    16265, 16269, 16273, 16277, 16281, 16285, 16289, 16293,
+    16297, 16301, 16305, 16309, 16313, 16317, 16321, 16325,
+    16329, 16333, 16337, 16341, 16345, 16349, 16353, 16357,
+    16361, 16365, 16369, 16373, 16377, 16381, 16385, 16389,
+    16393, 16397, 16401, 16405, 16409, 16413, 16417, 16421,
+    16425, 16429, 16433, 16437, 16441, 16445, 16449, 16453,
+    16457, 16461, 16465, 16469, 16473, 16477, 16481, 16485,
+    16489, 16493, 16497, 16501, 16505, 16509, 16513, 16517,
+    16521, 16525, 16529, 16533, 16537, 16541, 16545, 16549,
+    16553, 16557, 16561, 16565, 16569, 16573, 16577, 16581,
+    16585, 16589, 16593, 16597, 16601, 16605, 16609, 16613,
+    16617, 16621, 16625, 16629, 16633, 16637, 16641, 16645,
+    16649, 16653, 16657, 16661, 16665, 16669, 16673, 16677,
+    16681, 16685, 16689, 16693, 16697, 16701, 16705, 16709,
+    16713, 16717, 16721, 16725, 16729, 16733, 16737, 16741,
+    16745, 16749, 16753, 16757, 16761, 16765, 16769, 16773,
+    16777, 16781, 16785, 16789, 16793, 16797, 16801, 16805,
+    16809, 16813, 16817, 16821, 16825, 16829, 16833, 16837,
+    16841, 16845, 16849, 16853, 16857, 16861, 16865, 0,
+    0, 0, 16869, 16873, 16877, 16881, 16885, 16889,
+    0, 0, 16893, 16897, 16901, 16905, 16909, 16913,
+    0, 0, 16917, 16921, 16925, 16929, 16933, 16937,
+    0, 0, 16941, 16945, 16949, 0, 0, 0,
+    16953, 16957, 16961, 16965, 16969, 16973, 16977, 0,
+    16981, 16985, 16989, 16993, 16997, 17001, 17005, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+};
+
+// 67552 bytes
+
+const TQ_UINT16 TQUnicodeTables::ligature_map[] = {
+    0,
+    5567, 0,
+    5552, 0,
+    5572, 0,
+    67, 72, 77, 82, 87, 92, 332, 342, 352, 966, 1196, 1206, 1346, 2365, 3145, 3155, 0,
+    2375, 2385, 2395, 0,
+    97, 362, 372, 382, 392, 0,
+    402, 2415, 2425, 2435, 2445, 2455, 0,
+    102, 107, 112, 117, 412, 422, 432, 442, 452, 1216, 1226, 1356, 2485, 2495, 3265, 3275, 3285, 0,
+    2515, 0,
+    462, 472, 482, 492, 1076, 1146, 2525, 0,
+    502, 1336, 2535, 2545, 2555, 2565, 2575, 0,
+    122, 127, 132, 137, 512, 522, 532, 542, 552, 976, 1236, 1246, 2585, 3345, 3355, 0,
+    567, 0,
+    577, 1086, 2605, 2615, 2625, 0,
+    587, 597, 607, 2635, 2655, 2665, 0,
+    2675, 2685, 2695, 0,
+    142, 627, 637, 647, 1156, 2705, 2715, 2725, 2735, 0,
+    147, 152, 157, 162, 167, 662, 672, 682, 901, 986, 1096, 1256, 1266, 1386, 3365, 3375, 0,
+    2785, 2795, 0,
+    692, 702, 712, 1276, 1286, 2805, 2815, 2835, 0,
+    722, 732, 742, 752, 1316, 2845, 2855, 0,
+    762, 772, 1326, 2895, 2905, 2915, 2925, 0,
+    172, 177, 182, 187, 782, 792, 802, 812, 822, 832, 911, 996, 1296, 1306, 2935, 2945, 2955, 3485, 3495, 0,
+    2985, 2995, 0,
+    842, 3005, 3015, 3025, 3035, 3045, 0,
+    3055, 3065, 0,
+    192, 852, 862, 1406, 3075, 3555, 3565, 3575, 3585, 0,
+    867, 877, 887, 3085, 3095, 3105, 0,
+    197, 202, 207, 212, 217, 222, 337, 347, 357, 971, 1201, 1211, 1351, 2370, 3150, 3160, 0,
+    2380, 2390, 2400, 0,
+    227, 367, 377, 387, 397, 0,
+    407, 2420, 2430, 2440, 2450, 2460, 0,
+    232, 237, 242, 247, 417, 427, 437, 447, 457, 1221, 1231, 1361, 2490, 2500, 3270, 3280, 3290, 0,
+    2520, 0,
+    467, 477, 487, 497, 1081, 1151, 2530, 0,
+    507, 1341, 2540, 2550, 2560, 2570, 2580, 3115, 0,
+    252, 257, 262, 267, 517, 527, 537, 547, 981, 1241, 1251, 2590, 3350, 3360, 0,
+    572, 1126, 0,
+    582, 1091, 2610, 2620, 2630, 0,
+    592, 602, 612, 2640, 2660, 2670, 0,
+    2680, 2690, 2700, 0,
+    272, 632, 642, 652, 1161, 2710, 2720, 2730, 2740, 0,
+    277, 282, 287, 292, 297, 667, 677, 687, 906, 991, 1101, 1261, 1271, 1391, 3370, 3380, 0,
+    2790, 2800, 0,
+    697, 707, 717, 1281, 1291, 2810, 2820, 2840, 0,
+    727, 737, 747, 757, 1321, 2850, 2860, 0,
+    767, 777, 1331, 2900, 2910, 2920, 2930, 3120, 0,
+    302, 307, 312, 317, 787, 797, 807, 817, 827, 837, 916, 1001, 1301, 1311, 2940, 2950, 2960, 3490, 3500, 0,
+    2990, 3000, 0,
+    847, 3010, 3020, 3030, 3040, 3050, 3125, 0,
+    3060, 3070, 0,
+    322, 327, 857, 1411, 3080, 3130, 3560, 3570, 3580, 3590, 0,
+    872, 882, 892, 3090, 3100, 3110, 0,
+    1537, 4476, 4670, 0,
+    3165, 3175, 3185, 3195, 0,
+    1046, 0,
+    1166, 0,
+    1066, 1176, 0,
+    2405, 0,
+    3295, 3305, 3315, 3325, 0,
+    2595, 0,
+    3385, 3395, 3405, 3415, 0,
+    1376, 2745, 2755, 0,
+    1366, 0,
+    1186, 0,
+    1006, 1016, 1026, 1036, 0,
+    3170, 3180, 3190, 3200, 0,
+    1051, 0,
+    1171, 0,
+    1071, 1181, 0,
+    2410, 0,
+    3300, 3310, 3320, 3330, 0,
+    2600, 0,
+    3390, 3400, 3410, 3420, 0,
+    1381, 2750, 2760, 0,
+    1371, 0,
+    1191, 0,
+    1011, 1021, 1031, 1041, 0,
+    3215, 3225, 3235, 3245, 0,
+    3220, 3230, 3240, 3250, 0,
+    2465, 2475, 0,
+    2470, 2480, 0,
+    2765, 2775, 0,
+    2770, 2780, 0,
+    2865, 0,
+    2870, 0,
+    2875, 0,
+    2880, 0,
+    2965, 0,
+    2970, 0,
+    2975, 0,
+    2980, 0,
+    3140, 0,
+    3435, 3445, 3455, 3465, 3475, 0,
+    3440, 3450, 3460, 3470, 3480, 0,
+    3505, 3515, 3525, 3535, 3545, 0,
+    3510, 3520, 3530, 3540, 3550, 0,
+    1116, 0,
+    1106, 0,
+    1111, 0,
+    1056, 0,
+    1061, 0,
+    2505, 0,
+    2510, 0,
+    1396, 0,
+    1401, 0,
+    1121, 0,
+    1514, 0,
+    1542, 3635, 3640, 4433, 4438, 4443, 4452, 0,
+    1551, 3705, 3710, 4506, 0,
+    1556, 3775, 3780, 4515, 4524, 0,
+    1561, 1586, 3855, 3860, 4573, 4578, 4583, 0,
+    1566, 3925, 3930, 4708, 0,
+    4665, 0,
+    1571, 1591, 3995, 4646, 4651, 4656, 0,
+    1576, 4055, 4060, 4717, 4726, 0,
+    4418, 0,
+    4491, 0,
+    1596, 3595, 3600, 4095, 4398, 4403, 4413, 4423, 0,
+    1601, 3675, 3680, 4104, 0,
+    1606, 3735, 3740, 4113, 4486, 4496, 0,
+    1611, 1621, 3815, 3820, 4122, 4544, 4549, 4563, 0,
+    1631, 3895, 3900, 4131, 0,
+    4626, 4631, 0,
+    1626, 1636, 3955, 3960, 4140, 4607, 4612, 4636, 0,
+    1641, 4015, 4020, 4149, 4688, 4698, 0,
+    1581, 4554, 4568, 0,
+    1616, 4617, 4641, 0,
+    4693, 0,
+    1658, 1663, 0,
+    1711, 0,
+    1796, 1806, 0,
+    1706, 0,
+    1696, 1701, 1816, 0,
+    1786, 1836, 0,
+    1846, 0,
+    1721, 1731, 1856, 1866, 0,
+    1716, 0,
+    1876, 0,
+    1726, 1906, 1916, 1926, 0,
+    1936, 0,
+    1946, 0,
+    1896, 0,
+    1801, 1811, 0,
+    1751, 0,
+    1741, 1746, 1821, 0,
+    1791, 1841, 0,
+    1851, 0,
+    1736, 1766, 1861, 1871, 0,
+    1761, 0,
+    1881, 0,
+    1771, 1911, 1921, 1931, 0,
+    1941, 0,
+    1951, 0,
+    1901, 0,
+    1756, 0,
+    1776, 0,
+    1781, 0,
+    1826, 0,
+    1831, 0,
+    1886, 0,
+    1891, 0,
+    12167, 12172, 12177, 0,
+    12182, 12292, 0,
+    12187, 0,
+    12192, 0,
+    12197, 0,
+    12202, 12287, 0,
+    12207, 0,
+    12212, 0,
+    12097, 12217, 0,
+    12222, 0,
+    12227, 12297, 0,
+    12232, 0,
+    12237, 0,
+    12242, 0,
+    12247, 0,
+    12252, 0,
+    12257, 12302, 0,
+    12262, 0,
+    12267, 0,
+    12272, 0,
+    12147, 12152, 12277, 0,
+    12282, 0,
+    12102, 0,
+    1961, 1966, 1976, 0,
+    1971, 0,
+    1981, 0,
+    2011, 0,
+    2016, 0,
+    2006, 0,
+    2036, 0,
+    2041, 0,
+    2046, 0,
+    2051, 0,
+    2056, 0,
+    2061, 0,
+    2021, 0,
+    2066, 0,
+    2071, 0,
+    2026, 0,
+    2031, 0,
+    2086, 0,
+    2091, 0,
+    2096, 0,
+    2076, 2081, 0,
+    2111, 0,
+    2116, 0,
+    2121, 0,
+    2126, 0,
+    2101, 0,
+    2106, 0,
+    2146, 0,
+    2151, 0,
+    2131, 2136, 2141, 0,
+    2156, 0,
+    2161, 2171, 0,
+    2166, 0,
+    2176, 0,
+    2181, 0,
+    2186, 2191, 2196, 0,
+    2201, 0,
+    2206, 2216, 0,
+    2211, 0,
+    2221, 2226, 2236, 0,
+    2231, 0,
+    2290, 0,
+    2265, 0,
+    2270, 0,
+    2275, 0,
+    2280, 0,
+    2285, 0,
+    2295, 2300, 2325, 0,
+    2355, 0,
+    2330, 0,
+    2335, 0,
+    2340, 0,
+    2345, 0,
+    2350, 0,
+    2305, 0,
+    2315, 0,
+    2360, 0,
+    2645, 0,
+    2650, 0,
+    2825, 0,
+    2830, 0,
+    2885, 0,
+    2890, 0,
+    3205, 3255, 0,
+    3210, 3260, 0,
+    3335, 0,
+    3340, 0,
+    3425, 0,
+    3430, 0,
+    3605, 3615, 3625, 4158, 0,
+    3610, 3620, 3630, 4163, 0,
+    4168, 0,
+    4173, 0,
+    4178, 0,
+    4183, 0,
+    4188, 0,
+    4193, 0,
+    3645, 3655, 3665, 4198, 0,
+    3650, 3660, 3670, 4203, 0,
+    4208, 0,
+    4213, 0,
+    4218, 0,
+    4223, 0,
+    4228, 0,
+    4233, 0,
+    3685, 3695, 0,
+    3690, 3700, 0,
+    3715, 3725, 0,
+    3720, 3730, 0,
+    3745, 3755, 3765, 4238, 0,
+    3750, 3760, 3770, 4243, 0,
+    4248, 0,
+    4253, 0,
+    4258, 0,
+    4263, 0,
+    4268, 0,
+    4273, 0,
+    3785, 3795, 3805, 4278, 0,
+    3790, 3800, 3810, 4283, 0,
+    4288, 0,
+    4293, 0,
+    4298, 0,
+    4303, 0,
+    4308, 0,
+    4313, 0,
+    3825, 3835, 3845, 0,
+    3830, 3840, 3850, 0,
+    3865, 3875, 3885, 0,
+    3870, 3880, 3890, 0,
+    3905, 3915, 0,
+    3910, 3920, 0,
+    3935, 3945, 0,
+    3940, 3950, 0,
+    3965, 3975, 3985, 0,
+    3970, 3980, 3990, 0,
+    4000, 4005, 4010, 0,
+    4025, 4035, 4045, 4318, 0,
+    4030, 4040, 4050, 4323, 0,
+    4328, 0,
+    4333, 0,
+    4338, 0,
+    4343, 0,
+    4348, 0,
+    4353, 0,
+    4065, 4075, 4085, 4358, 0,
+    4070, 4080, 4090, 4363, 0,
+    4368, 0,
+    4373, 0,
+    4378, 0,
+    4383, 0,
+    4388, 0,
+    4393, 0,
+    4408, 0,
+    4481, 0,
+    4683, 0,
+    4428, 0,
+    4529, 4534, 4539, 0,
+    4501, 0,
+    4703, 0,
+    4592, 4597, 4602, 0,
+    5455, 0,
+    5460, 0,
+    5465, 0,
+    5470, 0,
+    5480, 0,
+    5475, 0,
+    5485, 0,
+    5490, 0,
+    5495, 0,
+    5500, 0,
+    5505, 0,
+    5532, 0,
+    5537, 0,
+    5542, 0,
+    5547, 0,
+    5562, 0,
+    5557, 0,
+    5577, 0,
+    5582, 0,
+    5587, 0,
+    5592, 0,
+    5597, 0,
+    5602, 0,
+    5607, 0,
+    5612, 0,
+    5657, 0,
+    5662, 0,
+    5617, 0,
+    5622, 0,
+    5627, 0,
+    5632, 0,
+    5667, 0,
+    5672, 0,
+    5637, 0,
+    5642, 0,
+    5647, 0,
+    5652, 0,
+    5677, 0,
+    5682, 0,
+    5687, 0,
+    5692, 0,
+    6430, 0,
+    7444, 0,
+    7319, 0,
+    7324, 0,
+    7329, 0,
+    7334, 0,
+    7339, 0,
+    7344, 0,
+    7349, 0,
+    7354, 0,
+    7359, 0,
+    7364, 0,
+    7369, 0,
+    7374, 0,
+    7379, 0,
+    7384, 0,
+    7389, 0,
+    7394, 7399, 0,
+    7404, 7409, 0,
+    7414, 7419, 0,
+    7424, 7429, 0,
+    7434, 7439, 0,
+    7459, 0,
+    7594, 0,
+    7469, 0,
+    7474, 0,
+    7479, 0,
+    7484, 0,
+    7489, 0,
+    7494, 0,
+    7499, 0,
+    7504, 0,
+    7509, 0,
+    7514, 0,
+    7519, 0,
+    7524, 0,
+    7529, 0,
+    7534, 0,
+    7539, 0,
+    7544, 7549, 0,
+    7554, 7559, 0,
+    7564, 7569, 0,
+    7574, 7579, 0,
+    7584, 7589, 0,
+    7599, 0,
+    7604, 0,
+    7609, 0,
+    7614, 0,
+    7619, 0,
+    12157, 12162, 0,
+
+};
+
+const TQ_UINT16 TQUnicodeTables::ligature_info[] = {
+    1, 2, 3, 4, 5, 6, 7, 8,
+    8, 9, 10, 11, 12, 13, 8, 14,
+    15, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 16, 17,
+    8, 18, 19, 8, 8, 8, 8, 8,
+    8, 8, 20, 8, 8, 8, 8, 8,
+    21, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 22, 8, 8, 8, 8,
+
+
+    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, 3, 5, 0,
+    0, 7, 24, 28, 34, 41, 59, 61,
+    69, 77, 93, 95, 101, 108, 112, 122,
+    139, 0, 142, 151, 159, 167, 187, 190,
+    197, 200, 210, 0, 0, 0, 0, 0,
+    0, 217, 234, 238, 244, 251, 269, 271,
+    279, 288, 303, 306, 312, 319, 323, 333,
+    350, 0, 353, 362, 370, 379, 399, 402,
+    410, 413, 424, 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,
+    431, 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, 435, 0, 440, 442, 444, 447,
+    0, 0, 449, 0, 0, 0, 0, 454,
+    0, 0, 0, 0, 456, 461, 465, 0,
+    467, 0, 0, 0, 469, 0, 0, 0,
+    0, 0, 474, 0, 479, 481, 483, 486,
+    0, 0, 488, 0, 0, 0, 0, 493,
+    0, 0, 0, 0, 495, 500, 504, 0,
+    506, 0, 0, 0, 508, 0, 0, 0,
+
+    0, 0, 513, 518, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 523, 526, 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, 529, 532, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 535, 537, 0, 0, 0, 0,
+    539, 541, 0, 0, 0, 0, 0, 0,
+    543, 545, 547, 549, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 551,
+    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,
+    553, 559, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 565,
+    571, 0, 0, 0, 0, 0, 0, 577,
+    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, 579, 581, 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, 583, 585,
+    587, 589, 0, 0, 0, 0, 591, 593,
+    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, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 595, 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, 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,
+    597, 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,
+    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, 599, 0, 0, 0, 607, 0, 612,
+    0, 618, 0, 0, 0, 0, 0, 626,
+    0, 631, 0, 0, 0, 633, 0, 0,
+    0, 640, 0, 0, 646, 0, 648, 0,
+    0, 650, 0, 0, 0, 659, 0, 664,
+    0, 671, 0, 0, 0, 0, 0, 680,
+    0, 685, 0, 0, 0, 688, 0, 0,
+    0, 697, 704, 708, 0, 0, 712, 0,
+    0, 0, 714, 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, 717, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    719, 0, 0, 722, 0, 724, 728, 731,
+    733, 0, 738, 0, 0, 0, 740, 0,
+    0, 0, 0, 742, 0, 0, 0, 747,
+    0, 0, 0, 749, 0, 751, 0, 0,
+    753, 0, 0, 756, 0, 758, 762, 765,
+    767, 0, 772, 0, 0, 0, 774, 0,
+    0, 0, 0, 776, 0, 0, 0, 781,
+    0, 0, 0, 783, 0, 785, 0, 0,
+    0, 0, 0, 0, 0, 0, 787, 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, 789, 791, 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, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    793, 795, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    797, 799, 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, 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,
+    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,
+    801, 805, 808, 810, 812, 814, 817, 0,
+    819, 821, 824, 826, 829, 0, 831, 0,
+    833, 835, 0, 837, 839, 0, 842, 844,
+    846, 848, 852, 0, 0, 0, 0, 0,
+    0, 0, 854, 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, 856,
+    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,
+    860, 0, 862, 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, 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, 864, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 866, 0, 0, 868, 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, 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, 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, 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, 870, 872, 874,
+    0, 0, 0, 0, 876, 0, 0, 0,
+    0, 878, 880, 0, 0, 0, 0, 0,
+    882, 0, 0, 884, 0, 0, 0, 886,
+    888, 0, 0, 890, 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, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 892, 894, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 896,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 898,
+    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, 901, 903,
+    0, 0, 0, 0, 905, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 907, 0, 0, 0, 0,
+    0, 0, 909, 0, 0, 0, 0, 0,
+    911, 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,
+    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, 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, 913, 915, 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, 917,
+    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, 921, 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, 923, 926,
+    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, 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, 928, 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, 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, 930,
+    0, 0, 0, 0, 0, 0, 932, 0,
+    0, 0, 936, 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, 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, 938, 941,
+    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, 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, 943, 0, 0, 947, 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, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    949, 0, 951, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 953, 0, 0, 0,
+    0, 955, 0, 0, 0, 0, 957, 0,
+    0, 0, 0, 959, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 961, 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,
+    965, 0, 967, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 969, 0, 0, 0,
+    0, 971, 0, 0, 0, 0, 973, 0,
+    0, 0, 0, 975, 0, 0, 0, 0,
+    0, 0, 977, 979, 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, 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, 981, 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, 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, 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, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 983, 985,
+    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, 987, 989, 0, 0, 0, 0,
+    0, 0, 991, 993, 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,
+    995, 998, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    1001, 1003, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 1005, 1007, 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,
+
+    1009, 1014, 1019, 1021, 1023, 1025, 1027, 1029,
+    1031, 1036, 1041, 1043, 1045, 1047, 1049, 1051,
+    1053, 1056, 0, 0, 0, 0, 0, 0,
+    1059, 1062, 0, 0, 0, 0, 0, 0,
+    1065, 1070, 1075, 1077, 1079, 1081, 1083, 1085,
+    1087, 1092, 1097, 1099, 1101, 1103, 1105, 1107,
+    1109, 1113, 0, 0, 0, 0, 0, 0,
+    1117, 1121, 0, 0, 0, 0, 0, 0,
+    1125, 1128, 0, 0, 0, 0, 0, 0,
+    1131, 1134, 0, 0, 0, 0, 0, 0,
+    1137, 1141, 0, 0, 0, 0, 0, 0,
+    0, 1145, 0, 0, 0, 0, 0, 0,
+    1149, 1154, 1159, 1161, 1163, 1165, 1167, 1169,
+    1171, 1176, 1181, 1183, 1185, 1187, 1189, 1191,
+    1193, 0, 0, 0, 1195, 0, 0, 0,
+    0, 0, 0, 0, 1197, 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, 1199, 0,
+    0, 0, 0, 0, 0, 0, 0, 1201,
+    0, 0, 0, 0, 0, 0, 1205, 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, 1207, 0,
+    0, 0, 0, 0, 0, 0, 1209, 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, 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,
+    1213, 0, 1215, 0, 1217, 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,
+    1219, 0, 1221, 0, 1223, 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, 1225, 0, 0, 0, 0,
+    1227, 0, 0, 1229, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 1231, 0, 1233, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 1235, 0, 0, 0,
+    0, 0, 0, 1237, 0, 1239, 0, 0,
+    1241, 0, 0, 0, 0, 1243, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 1245, 0, 0, 1247, 1249, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 1251, 1253, 0, 0, 1255, 1257,
+    0, 0, 1259, 1261, 1263, 1265, 0, 0,
+    0, 0, 1267, 1269, 0, 0, 1271, 1273,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 1275, 1277, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 1279, 0, 0, 0, 0, 0,
+    1281, 1283, 0, 1285, 0, 0, 0, 0,
+    0, 0, 1287, 1289, 1291, 1293, 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, 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, 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, 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, 1295, 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, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 1297, 0,
+    0, 0, 0, 1299, 0, 1301, 0, 1303,
+    0, 1305, 0, 1307, 0, 1309, 0, 1311,
+    0, 1313, 0, 1315, 0, 1317, 0, 1319,
+    0, 1321, 0, 0, 1323, 0, 1325, 0,
+    1327, 0, 0, 0, 0, 0, 0, 1329,
+    0, 0, 1332, 0, 0, 1335, 0, 0,
+    1338, 0, 0, 1341, 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, 1344, 0, 0,
+    0, 0, 0, 0, 0, 0, 1346, 0,
+    0, 0, 0, 1348, 0, 1350, 0, 1352,
+    0, 1354, 0, 1356, 0, 1358, 0, 1360,
+    0, 1362, 0, 1364, 0, 1366, 0, 1368,
+    0, 1370, 0, 0, 1372, 0, 1374, 0,
+    1376, 0, 0, 0, 0, 0, 0, 1378,
+    0, 0, 1381, 0, 0, 1384, 0, 0,
+    1387, 0, 0, 1390, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 1393,
+    1395, 1397, 1399, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 1401, 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, 1403, 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, 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,
+    0, 0, 0, 0, 0, 0, 0, 0,
+};
+
+// 14586 bytes
+
+const TQ_UINT8 TQUnicodeTables::direction_info[] = {
+    1, 2, 3, 4, 5, 6, 7, 8,
+    2, 9, 10, 11, 12, 13, 14, 15,
+    16, 2, 2, 2, 2, 2, 17, 18,
+    19, 2, 2, 2, 2, 2, 2, 20,
+    21, 22, 23, 24, 25, 26, 27, 28,
+    26, 29, 30, 2, 2, 2, 31, 32,
+    33, 2, 34, 2, 2, 2, 2, 2,
+    2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 2, 2, 35, 2, 2, 2,
+    2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 2, 36, 37, 38, 39, 40,
+
+
+    18, 18, 18, 18, 18, 18, 18, 18,
+    18, 8, 7, 8, 9, 7, 18, 18,
+    18, 18, 18, 18, 18, 18, 18, 18,
+    18, 18, 18, 18, 7, 7, 7, 8,
+    9, 10, 10, 4, 4, 4, 10, 10,
+    138, 138, 10, 4, 6, 4, 6, 3,
+    2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 6, 10, 138, 10, 138, 10,
+    10, 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, 138, 10, 138, 10, 10,
+    10, 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, 138, 10, 138, 10, 18,
+    18, 18, 18, 18, 18, 7, 18, 18,
+    18, 18, 18, 18, 18, 18, 18, 18,
+    18, 18, 18, 18, 18, 18, 18, 18,
+    18, 18, 18, 18, 18, 18, 18, 18,
+    6, 10, 4, 4, 4, 4, 10, 10,
+    10, 10, 0, 138, 10, 10, 10, 10,
+    4, 4, 2, 2, 10, 0, 10, 10,
+    10, 2, 0, 138, 10, 10, 10, 10,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 10,
+    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, 10,
+    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, 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, 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, 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, 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, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 10, 10, 0, 0, 0, 0, 0,
+    0, 0, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    0, 0, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    0, 0, 0, 0, 0, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+
+    17, 17, 17, 17, 17, 17, 17, 17,
+    17, 17, 17, 17, 17, 17, 17, 17,
+    17, 17, 17, 17, 17, 17, 17, 17,
+    17, 17, 17, 17, 17, 17, 17, 17,
+    17, 17, 17, 17, 17, 17, 17, 17,
+    17, 17, 17, 17, 17, 17, 17, 17,
+    17, 17, 17, 17, 17, 17, 17, 17,
+    17, 17, 17, 17, 17, 17, 17, 17,
+    17, 17, 17, 17, 17, 17, 17, 17,
+    17, 17, 17, 17, 17, 17, 17, 17,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    17, 17, 17, 17, 17, 17, 17, 17,
+    17, 17, 17, 17, 17, 17, 17, 17,
+    0, 0, 0, 0, 10, 10, 0, 0,
+    0, 0, 0, 0, 0, 0, 10, 0,
+    0, 0, 0, 0, 10, 10, 0, 10,
+    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, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 10, 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, 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, 17, 17, 17, 17, 0,
+    17, 17, 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, 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,
+    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, 10, 0, 0, 0, 0, 0,
+    0, 17, 17, 17, 17, 17, 17, 17,
+    17, 17, 17, 17, 17, 17, 17, 17,
+    17, 17, 0, 17, 17, 17, 17, 17,
+    17, 17, 17, 17, 17, 17, 17, 17,
+    17, 17, 17, 17, 17, 17, 17, 17,
+    17, 17, 0, 17, 17, 17, 1, 17,
+    1, 17, 17, 1, 17, 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, 0, 0, 0, 0, 0,
+    1, 1, 1, 1, 1, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 6, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 13, 0, 0, 0, 13,
+    0, 13, 77, 77, 77, 77, 45, 77,
+    45, 77, 45, 45, 45, 45, 45, 77,
+    77, 77, 77, 45, 45, 45, 45, 45,
+    45, 45, 45, 0, 0, 0, 0, 0,
+    109, 45, 45, 45, 45, 45, 45, 45,
+    77, 45, 45, 17, 17, 17, 17, 17,
+    17, 17, 17, 17, 17, 17, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 4, 5, 5, 13, 45, 45,
+    17, 77, 77, 77, 13, 77, 77, 77,
+    45, 45, 45, 45, 45, 45, 45, 45,
+    45, 45, 45, 45, 45, 45, 45, 45,
+    77, 77, 77, 77, 77, 77, 77, 77,
+    77, 77, 77, 77, 77, 77, 77, 77,
+    77, 77, 45, 45, 45, 45, 45, 45,
+    45, 45, 45, 45, 45, 45, 45, 45,
+    45, 45, 45, 45, 45, 45, 45, 45,
+    45, 45, 45, 45, 45, 45, 45, 45,
+    45, 45, 45, 45, 45, 45, 45, 45,
+    77, 45, 77, 77, 77, 77, 77, 77,
+    77, 77, 77, 77, 45, 77, 45, 77,
+    45, 45, 77, 77, 13, 77, 17, 17,
+    17, 17, 17, 17, 17, 13, 17, 17,
+    17, 17, 17, 17, 17, 13, 13, 17,
+    17, 10, 17, 17, 17, 17, 0, 0,
+    2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 45, 45, 45, 13, 13, 0,
+
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 0, 18,
+    77, 17, 45, 45, 45, 77, 77, 77,
+    77, 77, 45, 45, 45, 45, 77, 45,
+    45, 45, 45, 45, 45, 45, 45, 45,
+    77, 45, 77, 45, 77, 0, 0, 0,
+    17, 17, 17, 17, 17, 17, 17, 17,
+    17, 17, 17, 17, 17, 17, 17, 17,
+    17, 17, 17, 17, 17, 17, 17, 17,
+    17, 17, 17, 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,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 17, 17,
+    17, 17, 17, 17, 17, 17, 17, 17,
+    17, 13, 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, 17, 17, 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, 17, 0, 0, 0,
+    0, 17, 17, 17, 17, 17, 17, 17,
+    17, 0, 0, 0, 0, 17, 0, 0,
+    0, 17, 17, 17, 17, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 17, 17, 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, 17, 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, 17, 0, 0, 0,
+    0, 17, 17, 17, 17, 0, 0, 0,
+    0, 0, 0, 0, 0, 17, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 17, 17, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 4, 4, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+
+    0, 0, 17, 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, 17, 0, 0, 0,
+    0, 17, 17, 0, 0, 0, 0, 17,
+    17, 0, 0, 17, 17, 17, 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,
+    17, 17, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 17, 17, 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, 17, 0, 0, 0,
+    0, 17, 17, 17, 17, 17, 0, 17,
+    17, 0, 0, 0, 0, 17, 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, 17, 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, 17, 0, 0, 17,
+    0, 17, 17, 17, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 17, 0, 0,
+    0, 0, 0, 0, 0, 0, 17, 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, 17, 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,
+    17, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 17, 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, 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, 17, 17,
+    17, 0, 0, 0, 0, 0, 17, 17,
+    17, 0, 17, 17, 17, 17, 0, 0,
+    0, 0, 0, 0, 0, 17, 17, 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, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 17,
+    0, 0, 0, 0, 0, 0, 17, 0,
+    0, 0, 0, 0, 17, 17, 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, 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, 17, 17, 17, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 17, 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, 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, 17, 0, 0, 0, 0, 0,
+    0, 0, 17, 17, 17, 0, 17, 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, 0, 0,
+    0, 17, 0, 0, 17, 17, 17, 17,
+    17, 17, 17, 0, 0, 0, 0, 4,
+    0, 0, 0, 0, 0, 0, 0, 17,
+    17, 17, 17, 17, 17, 17, 17, 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, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 17, 0, 0, 17, 17, 17, 17,
+    17, 17, 0, 17, 17, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    17, 17, 17, 17, 17, 17, 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,
+    17, 17, 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, 17, 0, 17,
+    0, 17, 10, 10, 10, 10, 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, 17, 17, 17, 17, 17, 17, 17,
+    17, 17, 17, 17, 17, 17, 17, 0,
+    17, 17, 17, 17, 17, 0, 17, 17,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    17, 17, 17, 17, 17, 17, 17, 17,
+    0, 17, 17, 17, 17, 17, 17, 17,
+    17, 17, 17, 17, 17, 17, 17, 17,
+    17, 17, 17, 17, 17, 17, 17, 17,
+    17, 17, 17, 17, 17, 17, 17, 17,
+    17, 17, 17, 17, 17, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 17, 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, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 17, 17, 17,
+    17, 0, 17, 0, 0, 0, 17, 17,
+    0, 17, 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,
+    17, 17, 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, 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,
+    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, 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,
+    9, 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, 10, 10, 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, 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, 17, 17, 17, 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, 17, 17, 17, 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, 17, 17, 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, 17, 17, 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, 17,
+    17, 17, 17, 17, 17, 17, 0, 0,
+    0, 0, 0, 0, 0, 0, 17, 0,
+    0, 17, 17, 17, 17, 17, 17, 17,
+    17, 17, 17, 17, 0, 0, 0, 0,
+    0, 0, 0, 4, 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,
+
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 17, 17, 17, 18, 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, 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, 17, 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, 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,
+    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, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 10, 0, 10,
+    10, 10, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 10, 10, 10,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 10, 10, 10,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 10, 10, 10,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 10, 10, 0,
+
+    9, 9, 9, 9, 9, 9, 9, 9,
+    9, 9, 9, 18, 18, 114, 0, 1,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    9, 7, 11, 14, 16, 12, 15, 9,
+    4, 4, 4, 4, 4, 10, 10, 10,
+    10, 138, 138, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 138, 138, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 0, 0, 0, 0, 10,
+    0, 0, 0, 0, 0, 0, 0, 9,
+    18, 18, 18, 18, 0, 0, 0, 0,
+    0, 0, 18, 18, 18, 18, 18, 18,
+    2, 0, 0, 0, 2, 2, 2, 2,
+    2, 2, 4, 4, 10, 138, 138, 0,
+    2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 4, 4, 10, 138, 138, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    4, 4, 4, 4, 4, 4, 4, 4,
+    4, 4, 4, 4, 4, 4, 4, 4,
+    4, 4, 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,
+    17, 17, 17, 17, 17, 17, 17, 17,
+    17, 17, 17, 17, 17, 17, 17, 17,
+    17, 17, 17, 17, 17, 17, 17, 17,
+    17, 17, 17, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+
+    10, 10, 0, 10, 10, 10, 10, 0,
+    10, 10, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 10, 0, 10, 10,
+    10, 0, 0, 0, 0, 0, 10, 10,
+    10, 10, 10, 10, 0, 10, 0, 10,
+    0, 10, 0, 0, 0, 0, 4, 0,
+    0, 0, 10, 0, 0, 0, 0, 0,
+    0, 0, 10, 0, 0, 0, 0, 0,
+    138, 10, 10, 10, 10, 0, 0, 0,
+    0, 0, 10, 10, 0, 0, 0, 0,
+    0, 0, 0, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    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,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+
+    10, 138, 138, 138, 138, 10, 10, 10,
+    138, 138, 138, 138, 138, 138, 10, 10,
+    10, 138, 4, 4, 10, 138, 138, 10,
+    10, 10, 138, 138, 138, 138, 10, 138,
+    138, 138, 138, 10, 138, 10, 138, 10,
+    10, 10, 10, 138, 138, 138, 138, 138,
+    138, 138, 138, 138, 10, 10, 10, 10,
+    10, 138, 10, 138, 138, 138, 138, 138,
+    138, 138, 138, 138, 138, 138, 138, 138,
+    138, 138, 138, 138, 138, 10, 10, 10,
+    10, 10, 138, 138, 138, 138, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 138,
+    138, 10, 138, 10, 138, 138, 138, 138,
+    138, 138, 138, 138, 10, 10, 138, 138,
+    138, 138, 138, 138, 138, 138, 138, 138,
+    138, 138, 138, 138, 138, 138, 138, 138,
+    138, 138, 138, 138, 138, 138, 138, 138,
+    138, 138, 138, 138, 138, 10, 10, 138,
+    138, 138, 138, 10, 10, 10, 10, 10,
+    138, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 138, 138, 10, 10, 138, 138,
+    138, 138, 138, 138, 138, 138, 138, 138,
+    138, 138, 138, 138, 138, 138, 138, 138,
+    138, 10, 10, 10, 10, 10, 138, 138,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 138, 138, 138, 138, 138, 10, 10,
+    138, 138, 10, 10, 10, 10, 138, 138,
+    138, 138, 138, 138, 138, 138, 138, 138,
+    138, 138, 138, 138, 138, 138, 138, 138,
+    138, 138, 138, 138, 138, 138, 10, 10,
+    138, 138, 138, 138, 138, 138, 138, 138,
+    138, 138, 138, 138, 138, 138, 138, 138,
+
+    10, 10, 10, 10, 10, 10, 10, 10,
+    138, 138, 138, 138, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    138, 138, 10, 10, 10, 10, 10, 10,
+    10, 138, 138, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 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, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 0, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 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,
+
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 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,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 2, 2, 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, 2, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 0,
+
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 0, 0, 10, 10,
+    0, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 0, 0,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 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, 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, 10, 10, 10, 10, 0, 10, 10,
+    10, 10, 0, 0, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    0, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 0, 10, 0, 10,
+    10, 10, 10, 0, 0, 0, 10, 0,
+    10, 10, 10, 10, 10, 10, 10, 0,
+    0, 10, 10, 10, 10, 10, 10, 10,
+    138, 138, 138, 138, 138, 138, 138, 138,
+    138, 138, 138, 138, 138, 138, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 0, 0, 0,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    0, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    10, 10, 10, 138, 138, 138, 138, 10,
+    10, 10, 10, 10, 138, 138, 138, 10,
+    10, 10, 138, 138, 138, 138, 138, 138,
+    138, 138, 138, 138, 0, 0, 0, 0,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 138, 138, 138, 138, 138,
+    138, 138, 138, 138, 138, 138, 138, 138,
+    138, 138, 138, 138, 138, 138, 138, 138,
+    138, 10, 10, 138, 138, 138, 138, 138,
+    138, 138, 138, 138, 138, 138, 138, 138,
+    138, 138, 138, 138, 138, 138, 138, 138,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    138, 10, 10, 10, 10, 10, 10, 10,
+    138, 138, 138, 138, 138, 138, 10, 10,
+    10, 138, 10, 10, 10, 10, 138, 138,
+    138, 138, 138, 10, 138, 138, 10, 10,
+    138, 138, 138, 138, 138, 10, 10, 10,
+    10, 138, 10, 138, 138, 138, 10, 10,
+    138, 138, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 138, 138, 138, 138,
+    138, 138, 10, 10, 138, 138, 10, 10,
+
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 138, 138, 138, 138, 138, 138,
+    138, 138, 138, 138, 138, 138, 138, 138,
+    138, 138, 138, 138, 138, 10, 138, 138,
+    138, 138, 10, 10, 138, 10, 138, 10,
+    10, 138, 10, 138, 138, 138, 138, 10,
+    10, 10, 10, 10, 138, 138, 10, 10,
+    10, 10, 10, 10, 138, 138, 138, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 138,
+    138, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 138, 138, 10, 10,
+    10, 10, 138, 138, 138, 138, 10, 138,
+    138, 10, 10, 138, 138, 10, 10, 10,
+    10, 138, 138, 138, 138, 138, 138, 138,
+    138, 138, 138, 138, 138, 138, 138, 138,
+    138, 138, 138, 138, 138, 138, 138, 138,
+    138, 138, 138, 138, 138, 138, 138, 138,
+    138, 138, 138, 138, 138, 138, 138, 138,
+    138, 138, 138, 138, 10, 10, 138, 138,
+    138, 138, 138, 138, 138, 138, 10, 138,
+    138, 138, 138, 138, 138, 138, 138, 138,
+    138, 138, 138, 138, 138, 138, 138, 138,
+    138, 138, 138, 138, 138, 138, 138, 138,
+    138, 138, 138, 138, 138, 138, 138, 138,
+    138, 138, 138, 138, 138, 138, 138, 10,
+    10, 10, 10, 10, 138, 10, 138, 10,
+    10, 10, 138, 138, 138, 138, 138, 10,
+    10, 10, 10, 10, 138, 138, 138, 10,
+    10, 10, 10, 138, 10, 10, 10, 138,
+    138, 138, 138, 138, 10, 138, 10, 10,
+
+    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, 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,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 0, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 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,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 0, 0, 0, 0,
+
+    9, 10, 10, 10, 10, 0, 0, 0,
+    138, 138, 138, 138, 138, 138, 138, 138,
+    138, 138, 10, 10, 138, 138, 138, 138,
+    138, 138, 138, 138, 10, 10, 10, 10,
+    10, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 17, 17, 17, 17, 17, 17,
+    10, 0, 0, 0, 0, 0, 10, 10,
+    0, 0, 0, 0, 0, 10, 10, 10,
+    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, 0,
+    0, 17, 17, 10, 10, 0, 0, 0,
+    10, 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,
+    0, 0, 0, 10, 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, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    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, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    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, 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, 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,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 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, 17, 1,
+    1, 1, 1, 1, 1, 1, 1, 1,
+    1, 4, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 0,
+    1, 1, 1, 1, 1, 0, 1, 0,
+    1, 1, 0, 1, 1, 0, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 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, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 10, 10,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    0, 0, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    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,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 0, 0, 0,
+
+    17, 17, 17, 17, 17, 17, 17, 17,
+    17, 17, 17, 17, 17, 17, 17, 17,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    17, 17, 17, 17, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 0,
+    0, 10, 10, 10, 10, 10, 10, 10,
+    6, 10, 6, 0, 10, 6, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 4,
+    10, 10, 4, 4, 10, 10, 10, 0,
+    10, 4, 4, 10, 0, 0, 0, 0,
+    13, 13, 13, 13, 13, 0, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 0, 0, 18,
+
+    0, 10, 10, 4, 4, 4, 10, 10,
+    138, 138, 10, 4, 6, 4, 6, 3,
+    2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 6, 10, 138, 10, 138, 10,
+    10, 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, 138, 10, 138, 10, 10,
+    10, 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, 138, 10, 138, 10, 138,
+    138, 10, 138, 138, 10, 10, 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, 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,
+    4, 4, 10, 10, 10, 4, 4, 0,
+    10, 10, 10, 10, 10, 10, 10, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 18, 18, 18, 10, 10, 0, 0,
+};
+
+// 25082 bytes
+
+const TQ_UINT8 TQUnicodeTables::combining_info[] = {
+    1, 1, 1, 2, 3, 4, 5, 6,
+    1, 7, 8, 9, 10, 11, 12, 13,
+    14, 1, 1, 1, 1, 1, 1, 15,
+    16, 1, 1, 1, 1, 1, 1, 1,
+    17, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1,
+    18, 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, 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, 19, 1, 1, 20, 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, 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, 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,
+
+    230, 230, 230, 230, 230, 230, 230, 230,
+    230, 230, 230, 230, 230, 230, 230, 230,
+    230, 230, 230, 230, 230, 232, 220, 220,
+    220, 220, 232, 216, 220, 220, 220, 220,
+    220, 202, 202, 220, 220, 220, 220, 202,
+    202, 220, 220, 220, 220, 220, 220, 220,
+    220, 220, 220, 220, 1, 1, 1, 1,
+    1, 220, 220, 220, 220, 230, 230, 230,
+    230, 230, 230, 230, 230, 240, 230, 220,
+    220, 220, 230, 230, 230, 220, 220, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    234, 234, 233, 230, 230, 230, 230, 230,
+    230, 230, 230, 230, 230, 230, 230, 230,
+    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, 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, 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, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 230, 230, 230, 230, 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, 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, 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, 0, 0, 0, 0,
+    0, 220, 230, 230, 230, 230, 220, 230,
+    230, 230, 222, 220, 230, 230, 230, 230,
+    230, 230, 0, 220, 220, 220, 220, 220,
+    230, 230, 220, 230, 230, 222, 228, 230,
+    10, 11, 12, 13, 14, 15, 16, 17,
+    18, 19, 0, 20, 21, 22, 0, 23,
+    0, 24, 25, 0, 230, 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, 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, 27, 28, 29, 30, 31,
+    32, 33, 34, 230, 230, 220, 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,
+    35, 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,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 230, 230,
+    230, 230, 230, 230, 230, 0, 0, 230,
+    230, 230, 230, 220, 230, 0, 0, 230,
+    230, 0, 220, 230, 230, 220, 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, 36, 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,
+    230, 220, 230, 230, 220, 230, 230, 220,
+    220, 220, 230, 220, 220, 230, 220, 230,
+    230, 230, 220, 230, 220, 230, 220, 230,
+    220, 230, 230, 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, 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, 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, 7, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 9, 0, 0,
+    0, 230, 220, 230, 230, 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, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 7, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 9, 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, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 7, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 9, 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, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 7, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 9, 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, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 7, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 9, 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, 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, 9, 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, 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, 9, 0, 0,
+    0, 0, 0, 0, 0, 84, 91, 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, 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, 9, 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, 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, 9, 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, 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, 9, 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, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    103, 103, 9, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    107, 107, 107, 107, 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, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    118, 118, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    122, 122, 122, 122, 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,
+    220, 220, 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, 220, 0, 220,
+    0, 216, 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, 129, 130, 0, 132, 0, 0, 0,
+    0, 0, 130, 130, 130, 130, 0, 0,
+    130, 0, 230, 230, 9, 0, 230, 230,
+    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, 220, 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, 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, 7,
+    0, 9, 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, 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,
+    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, 9, 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, 9, 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, 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, 9, 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, 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, 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, 228, 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, 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,
+    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, 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,
+    230, 230, 1, 1, 230, 230, 230, 230,
+    1, 1, 1, 230, 230, 0, 0, 0,
+    0, 230, 0, 0, 0, 1, 1, 230,
+    220, 230, 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, 218, 228, 232, 222, 224, 224,
+    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, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 8, 8, 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, 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, 26, 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, 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, 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,
+    230, 230, 230, 230, 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, 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, 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,
+};
+
+// 30458 bytes
+
+const TQ_UINT16 TQUnicodeTables::case_info[] = {
+    1, 2, 3, 4, 5, 6, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 7, 8,
+    0, 9, 0, 0, 10, 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, 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, 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, 11,
+
+
+    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, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
+    0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
+    0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
+    0x78, 0x79, 0x7a, 0, 0, 0, 0, 0,
+    0, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
+    0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
+    0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
+    0x58, 0x59, 0x5a, 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, 0x39c, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
+    0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
+    0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0,
+    0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0,
+    0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
+    0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
+    0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0,
+    0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0x178,
+
+    0x101, 0x100, 0x103, 0x102, 0x105, 0x104, 0x107, 0x106,
+    0x109, 0x108, 0x10b, 0x10a, 0x10d, 0x10c, 0x10f, 0x10e,
+    0x111, 0x110, 0x113, 0x112, 0x115, 0x114, 0x117, 0x116,
+    0x119, 0x118, 0x11b, 0x11a, 0x11d, 0x11c, 0x11f, 0x11e,
+    0x121, 0x120, 0x123, 0x122, 0x125, 0x124, 0x127, 0x126,
+    0x129, 0x128, 0x12b, 0x12a, 0x12d, 0x12c, 0x12f, 0x12e,
+    0x69, 0x49, 0x133, 0x132, 0x135, 0x134, 0x137, 0x136,
+    0, 0x13a, 0x139, 0x13c, 0x13b, 0x13e, 0x13d, 0x140,
+    0x13f, 0x142, 0x141, 0x144, 0x143, 0x146, 0x145, 0x148,
+    0x147, 0, 0x14b, 0x14a, 0x14d, 0x14c, 0x14f, 0x14e,
+    0x151, 0x150, 0x153, 0x152, 0x155, 0x154, 0x157, 0x156,
+    0x159, 0x158, 0x15b, 0x15a, 0x15d, 0x15c, 0x15f, 0x15e,
+    0x161, 0x160, 0x163, 0x162, 0x165, 0x164, 0x167, 0x166,
+    0x169, 0x168, 0x16b, 0x16a, 0x16d, 0x16c, 0x16f, 0x16e,
+    0x171, 0x170, 0x173, 0x172, 0x175, 0x174, 0x177, 0x176,
+    0xff, 0x17a, 0x179, 0x17c, 0x17b, 0x17e, 0x17d, 0x53,
+    0, 0x253, 0x183, 0x182, 0x185, 0x184, 0x254, 0x188,
+    0x187, 0x256, 0x257, 0x18c, 0x18b, 0, 0x1dd, 0x259,
+    0x25b, 0x192, 0x191, 0x260, 0x263, 0x1f6, 0x269, 0x268,
+    0x199, 0x198, 0, 0, 0x26f, 0x272, 0x220, 0x275,
+    0x1a1, 0x1a0, 0x1a3, 0x1a2, 0x1a5, 0x1a4, 0x280, 0x1a8,
+    0x1a7, 0x283, 0, 0, 0x1ad, 0x1ac, 0x288, 0x1b0,
+    0x1af, 0x28a, 0x28b, 0x1b4, 0x1b3, 0x1b6, 0x1b5, 0x292,
+    0x1b9, 0x1b8, 0, 0, 0x1bd, 0x1bc, 0, 0x1f7,
+    0, 0, 0, 0, 0x1c6, 0x1c4, 0x1c4, 0x1c9,
+    0x1c7, 0x1c7, 0x1cc, 0x1ca, 0x1ca, 0x1ce, 0x1cd, 0x1d0,
+    0x1cf, 0x1d2, 0x1d1, 0x1d4, 0x1d3, 0x1d6, 0x1d5, 0x1d8,
+    0x1d7, 0x1da, 0x1d9, 0x1dc, 0x1db, 0x18e, 0x1df, 0x1de,
+    0x1e1, 0x1e0, 0x1e3, 0x1e2, 0x1e5, 0x1e4, 0x1e7, 0x1e6,
+    0x1e9, 0x1e8, 0x1eb, 0x1ea, 0x1ed, 0x1ec, 0x1ef, 0x1ee,
+    0, 0x1f3, 0x1f1, 0x1f1, 0x1f5, 0x1f4, 0x195, 0x1bf,
+    0x1f9, 0x1f8, 0x1fb, 0x1fa, 0x1fd, 0x1fc, 0x1ff, 0x1fe,
+
+    0x201, 0x200, 0x203, 0x202, 0x205, 0x204, 0x207, 0x206,
+    0x209, 0x208, 0x20b, 0x20a, 0x20d, 0x20c, 0x20f, 0x20e,
+    0x211, 0x210, 0x213, 0x212, 0x215, 0x214, 0x217, 0x216,
+    0x219, 0x218, 0x21b, 0x21a, 0x21d, 0x21c, 0x21f, 0x21e,
+    0x19e, 0, 0x223, 0x222, 0x225, 0x224, 0x227, 0x226,
+    0x229, 0x228, 0x22b, 0x22a, 0x22d, 0x22c, 0x22f, 0x22e,
+    0x231, 0x230, 0x233, 0x232, 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, 0x181, 0x186, 0, 0x189, 0x18a,
+    0, 0x18f, 0, 0x190, 0, 0, 0, 0,
+    0x193, 0, 0, 0x194, 0, 0, 0, 0,
+    0x197, 0x196, 0, 0, 0, 0, 0, 0x19c,
+    0, 0, 0x19d, 0, 0, 0x19f, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0x1a6, 0, 0, 0x1a9, 0, 0, 0, 0,
+    0x1ae, 0, 0x1b1, 0x1b2, 0, 0, 0, 0,
+    0, 0, 0x1b7, 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, 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, 0, 0, 0, 0, 0x399, 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, 0x3ac, 0,
+    0x3ad, 0x3ae, 0x3af, 0, 0x3cc, 0, 0x3cd, 0x3ce,
+    0, 0x3b1, 0x3b2, 0x3b3, 0x3b4, 0x3b5, 0x3b6, 0x3b7,
+    0x3b8, 0x3b9, 0x3ba, 0x3bb, 0x3bc, 0x3bd, 0x3be, 0x3bf,
+    0x3c0, 0x3c1, 0, 0x3c3, 0x3c4, 0x3c5, 0x3c6, 0x3c7,
+    0x3c8, 0x3c9, 0x3ca, 0x3cb, 0x386, 0x388, 0x389, 0x38a,
+    0, 0x391, 0x392, 0x393, 0x394, 0x395, 0x396, 0x397,
+    0x398, 0x399, 0x39a, 0x39b, 0x39c, 0x39d, 0x39e, 0x39f,
+    0x3a0, 0x3a1, 0x3a3, 0x3a3, 0x3a4, 0x3a5, 0x3a6, 0x3a7,
+    0x3a8, 0x3a9, 0x3aa, 0x3ab, 0x38c, 0x38e, 0x38f, 0,
+    0x392, 0x398, 0, 0, 0, 0x3a6, 0x3a0, 0,
+    0x3d9, 0x3d8, 0x3db, 0x3da, 0x3dd, 0x3dc, 0x3df, 0x3de,
+    0x3e1, 0x3e0, 0x3e3, 0x3e2, 0x3e5, 0x3e4, 0x3e7, 0x3e6,
+    0x3e9, 0x3e8, 0x3eb, 0x3ea, 0x3ed, 0x3ec, 0x3ef, 0x3ee,
+    0x39a, 0x3a1, 0x3a3, 0, 0x3b8, 0x395, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+
+    0x450, 0x451, 0x452, 0x453, 0x454, 0x455, 0x456, 0x457,
+    0x458, 0x459, 0x45a, 0x45b, 0x45c, 0x45d, 0x45e, 0x45f,
+    0x430, 0x431, 0x432, 0x433, 0x434, 0x435, 0x436, 0x437,
+    0x438, 0x439, 0x43a, 0x43b, 0x43c, 0x43d, 0x43e, 0x43f,
+    0x440, 0x441, 0x442, 0x443, 0x444, 0x445, 0x446, 0x447,
+    0x448, 0x449, 0x44a, 0x44b, 0x44c, 0x44d, 0x44e, 0x44f,
+    0x410, 0x411, 0x412, 0x413, 0x414, 0x415, 0x416, 0x417,
+    0x418, 0x419, 0x41a, 0x41b, 0x41c, 0x41d, 0x41e, 0x41f,
+    0x420, 0x421, 0x422, 0x423, 0x424, 0x425, 0x426, 0x427,
+    0x428, 0x429, 0x42a, 0x42b, 0x42c, 0x42d, 0x42e, 0x42f,
+    0x400, 0x401, 0x402, 0x403, 0x404, 0x405, 0x406, 0x407,
+    0x408, 0x409, 0x40a, 0x40b, 0x40c, 0x40d, 0x40e, 0x40f,
+    0x461, 0x460, 0x463, 0x462, 0x465, 0x464, 0x467, 0x466,
+    0x469, 0x468, 0x46b, 0x46a, 0x46d, 0x46c, 0x46f, 0x46e,
+    0x471, 0x470, 0x473, 0x472, 0x475, 0x474, 0x477, 0x476,
+    0x479, 0x478, 0x47b, 0x47a, 0x47d, 0x47c, 0x47f, 0x47e,
+    0x481, 0x480, 0, 0, 0, 0, 0, 0,
+    0, 0, 0x48b, 0x48a, 0x48d, 0x48c, 0x48f, 0x48e,
+    0x491, 0x490, 0x493, 0x492, 0x495, 0x494, 0x497, 0x496,
+    0x499, 0x498, 0x49b, 0x49a, 0x49d, 0x49c, 0x49f, 0x49e,
+    0x4a1, 0x4a0, 0x4a3, 0x4a2, 0x4a5, 0x4a4, 0x4a7, 0x4a6,
+    0x4a9, 0x4a8, 0x4ab, 0x4aa, 0x4ad, 0x4ac, 0x4af, 0x4ae,
+    0x4b1, 0x4b0, 0x4b3, 0x4b2, 0x4b5, 0x4b4, 0x4b7, 0x4b6,
+    0x4b9, 0x4b8, 0x4bb, 0x4ba, 0x4bd, 0x4bc, 0x4bf, 0x4be,
+    0, 0x4c2, 0x4c1, 0x4c4, 0x4c3, 0x4c6, 0x4c5, 0x4c8,
+    0x4c7, 0x4ca, 0x4c9, 0x4cc, 0x4cb, 0x4ce, 0x4cd, 0,
+    0x4d1, 0x4d0, 0x4d3, 0x4d2, 0x4d5, 0x4d4, 0x4d7, 0x4d6,
+    0x4d9, 0x4d8, 0x4db, 0x4da, 0x4dd, 0x4dc, 0x4df, 0x4de,
+    0x4e1, 0x4e0, 0x4e3, 0x4e2, 0x4e5, 0x4e4, 0x4e7, 0x4e6,
+    0x4e9, 0x4e8, 0x4eb, 0x4ea, 0x4ed, 0x4ec, 0x4ef, 0x4ee,
+    0x4f1, 0x4f0, 0x4f3, 0x4f2, 0x4f5, 0x4f4, 0, 0,
+    0x4f9, 0x4f8, 0, 0, 0, 0, 0, 0,
+
+    0x501, 0x500, 0x503, 0x502, 0x505, 0x504, 0x507, 0x506,
+    0x509, 0x508, 0x50b, 0x50a, 0x50d, 0x50c, 0x50f, 0x50e,
+    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, 0x561, 0x562, 0x563, 0x564, 0x565, 0x566, 0x567,
+    0x568, 0x569, 0x56a, 0x56b, 0x56c, 0x56d, 0x56e, 0x56f,
+    0x570, 0x571, 0x572, 0x573, 0x574, 0x575, 0x576, 0x577,
+    0x578, 0x579, 0x57a, 0x57b, 0x57c, 0x57d, 0x57e, 0x57f,
+    0x580, 0x581, 0x582, 0x583, 0x584, 0x585, 0x586, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0x531, 0x532, 0x533, 0x534, 0x535, 0x536, 0x537,
+    0x538, 0x539, 0x53a, 0x53b, 0x53c, 0x53d, 0x53e, 0x53f,
+    0x540, 0x541, 0x542, 0x543, 0x544, 0x545, 0x546, 0x547,
+    0x548, 0x549, 0x54a, 0x54b, 0x54c, 0x54d, 0x54e, 0x54f,
+    0x550, 0x551, 0x552, 0x553, 0x554, 0x555, 0x556, 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, 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,
+
+    0x1e01, 0x1e00, 0x1e03, 0x1e02, 0x1e05, 0x1e04, 0x1e07, 0x1e06,
+    0x1e09, 0x1e08, 0x1e0b, 0x1e0a, 0x1e0d, 0x1e0c, 0x1e0f, 0x1e0e,
+    0x1e11, 0x1e10, 0x1e13, 0x1e12, 0x1e15, 0x1e14, 0x1e17, 0x1e16,
+    0x1e19, 0x1e18, 0x1e1b, 0x1e1a, 0x1e1d, 0x1e1c, 0x1e1f, 0x1e1e,
+    0x1e21, 0x1e20, 0x1e23, 0x1e22, 0x1e25, 0x1e24, 0x1e27, 0x1e26,
+    0x1e29, 0x1e28, 0x1e2b, 0x1e2a, 0x1e2d, 0x1e2c, 0x1e2f, 0x1e2e,
+    0x1e31, 0x1e30, 0x1e33, 0x1e32, 0x1e35, 0x1e34, 0x1e37, 0x1e36,
+    0x1e39, 0x1e38, 0x1e3b, 0x1e3a, 0x1e3d, 0x1e3c, 0x1e3f, 0x1e3e,
+    0x1e41, 0x1e40, 0x1e43, 0x1e42, 0x1e45, 0x1e44, 0x1e47, 0x1e46,
+    0x1e49, 0x1e48, 0x1e4b, 0x1e4a, 0x1e4d, 0x1e4c, 0x1e4f, 0x1e4e,
+    0x1e51, 0x1e50, 0x1e53, 0x1e52, 0x1e55, 0x1e54, 0x1e57, 0x1e56,
+    0x1e59, 0x1e58, 0x1e5b, 0x1e5a, 0x1e5d, 0x1e5c, 0x1e5f, 0x1e5e,
+    0x1e61, 0x1e60, 0x1e63, 0x1e62, 0x1e65, 0x1e64, 0x1e67, 0x1e66,
+    0x1e69, 0x1e68, 0x1e6b, 0x1e6a, 0x1e6d, 0x1e6c, 0x1e6f, 0x1e6e,
+    0x1e71, 0x1e70, 0x1e73, 0x1e72, 0x1e75, 0x1e74, 0x1e77, 0x1e76,
+    0x1e79, 0x1e78, 0x1e7b, 0x1e7a, 0x1e7d, 0x1e7c, 0x1e7f, 0x1e7e,
+    0x1e81, 0x1e80, 0x1e83, 0x1e82, 0x1e85, 0x1e84, 0x1e87, 0x1e86,
+    0x1e89, 0x1e88, 0x1e8b, 0x1e8a, 0x1e8d, 0x1e8c, 0x1e8f, 0x1e8e,
+    0x1e91, 0x1e90, 0x1e93, 0x1e92, 0x1e95, 0x1e94, 0, 0,
+    0, 0, 0, 0x1e60, 0, 0, 0, 0,
+    0x1ea1, 0x1ea0, 0x1ea3, 0x1ea2, 0x1ea5, 0x1ea4, 0x1ea7, 0x1ea6,
+    0x1ea9, 0x1ea8, 0x1eab, 0x1eaa, 0x1ead, 0x1eac, 0x1eaf, 0x1eae,
+    0x1eb1, 0x1eb0, 0x1eb3, 0x1eb2, 0x1eb5, 0x1eb4, 0x1eb7, 0x1eb6,
+    0x1eb9, 0x1eb8, 0x1ebb, 0x1eba, 0x1ebd, 0x1ebc, 0x1ebf, 0x1ebe,
+    0x1ec1, 0x1ec0, 0x1ec3, 0x1ec2, 0x1ec5, 0x1ec4, 0x1ec7, 0x1ec6,
+    0x1ec9, 0x1ec8, 0x1ecb, 0x1eca, 0x1ecd, 0x1ecc, 0x1ecf, 0x1ece,
+    0x1ed1, 0x1ed0, 0x1ed3, 0x1ed2, 0x1ed5, 0x1ed4, 0x1ed7, 0x1ed6,
+    0x1ed9, 0x1ed8, 0x1edb, 0x1eda, 0x1edd, 0x1edc, 0x1edf, 0x1ede,
+    0x1ee1, 0x1ee0, 0x1ee3, 0x1ee2, 0x1ee5, 0x1ee4, 0x1ee7, 0x1ee6,
+    0x1ee9, 0x1ee8, 0x1eeb, 0x1eea, 0x1eed, 0x1eec, 0x1eef, 0x1eee,
+    0x1ef1, 0x1ef0, 0x1ef3, 0x1ef2, 0x1ef5, 0x1ef4, 0x1ef7, 0x1ef6,
+    0x1ef9, 0x1ef8, 0, 0, 0, 0, 0, 0,
+
+    0x1f08, 0x1f09, 0x1f0a, 0x1f0b, 0x1f0c, 0x1f0d, 0x1f0e, 0x1f0f,
+    0x1f00, 0x1f01, 0x1f02, 0x1f03, 0x1f04, 0x1f05, 0x1f06, 0x1f07,
+    0x1f18, 0x1f19, 0x1f1a, 0x1f1b, 0x1f1c, 0x1f1d, 0, 0,
+    0x1f10, 0x1f11, 0x1f12, 0x1f13, 0x1f14, 0x1f15, 0, 0,
+    0x1f28, 0x1f29, 0x1f2a, 0x1f2b, 0x1f2c, 0x1f2d, 0x1f2e, 0x1f2f,
+    0x1f20, 0x1f21, 0x1f22, 0x1f23, 0x1f24, 0x1f25, 0x1f26, 0x1f27,
+    0x1f38, 0x1f39, 0x1f3a, 0x1f3b, 0x1f3c, 0x1f3d, 0x1f3e, 0x1f3f,
+    0x1f30, 0x1f31, 0x1f32, 0x1f33, 0x1f34, 0x1f35, 0x1f36, 0x1f37,
+    0x1f48, 0x1f49, 0x1f4a, 0x1f4b, 0x1f4c, 0x1f4d, 0, 0,
+    0x1f40, 0x1f41, 0x1f42, 0x1f43, 0x1f44, 0x1f45, 0, 0,
+    0, 0x1f59, 0, 0x1f5b, 0, 0x1f5d, 0, 0x1f5f,
+    0, 0x1f51, 0, 0x1f53, 0, 0x1f55, 0, 0x1f57,
+    0x1f68, 0x1f69, 0x1f6a, 0x1f6b, 0x1f6c, 0x1f6d, 0x1f6e, 0x1f6f,
+    0x1f60, 0x1f61, 0x1f62, 0x1f63, 0x1f64, 0x1f65, 0x1f66, 0x1f67,
+    0x1fba, 0x1fbb, 0x1fc8, 0x1fc9, 0x1fca, 0x1fcb, 0x1fda, 0x1fdb,
+    0x1ff8, 0x1ff9, 0x1fea, 0x1feb, 0x1ffa, 0x1ffb, 0, 0,
+    0x1f88, 0x1f89, 0x1f8a, 0x1f8b, 0x1f8c, 0x1f8d, 0x1f8e, 0x1f8f,
+    0x1f80, 0x1f81, 0x1f82, 0x1f83, 0x1f84, 0x1f85, 0x1f86, 0x1f87,
+    0x1f98, 0x1f99, 0x1f9a, 0x1f9b, 0x1f9c, 0x1f9d, 0x1f9e, 0x1f9f,
+    0x1f90, 0x1f91, 0x1f92, 0x1f93, 0x1f94, 0x1f95, 0x1f96, 0x1f97,
+    0x1fa8, 0x1fa9, 0x1faa, 0x1fab, 0x1fac, 0x1fad, 0x1fae, 0x1faf,
+    0x1fa0, 0x1fa1, 0x1fa2, 0x1fa3, 0x1fa4, 0x1fa5, 0x1fa6, 0x1fa7,
+    0x1fb8, 0x1fb9, 0, 0x1fbc, 0, 0, 0, 0,
+    0x1fb0, 0x1fb1, 0x1f70, 0x1f71, 0x1fb3, 0, 0x399, 0,
+    0, 0, 0, 0x1fcc, 0, 0, 0, 0,
+    0x1f72, 0x1f73, 0x1f74, 0x1f75, 0x1fc3, 0, 0, 0,
+    0x1fd8, 0x1fd9, 0, 0, 0, 0, 0, 0,
+    0x1fd0, 0x1fd1, 0x1f76, 0x1f77, 0, 0, 0, 0,
+    0x1fe8, 0x1fe9, 0, 0, 0, 0x1fec, 0, 0,
+    0x1fe0, 0x1fe1, 0x1f7a, 0x1f7b, 0x1fe5, 0, 0, 0,
+    0, 0, 0, 0x1ffc, 0, 0, 0, 0,
+    0x1f78, 0x1f79, 0x1f7c, 0x1f7d, 0x1ff3, 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, 0x3c9, 0,
+    0, 0, 0x6b, 0xe5, 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,
+    0x2170, 0x2171, 0x2172, 0x2173, 0x2174, 0x2175, 0x2176, 0x2177,
+    0x2178, 0x2179, 0x217a, 0x217b, 0x217c, 0x217d, 0x217e, 0x217f,
+    0x2160, 0x2161, 0x2162, 0x2163, 0x2164, 0x2165, 0x2166, 0x2167,
+    0x2168, 0x2169, 0x216a, 0x216b, 0x216c, 0x216d, 0x216e, 0x216f,
+    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, 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, 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, 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, 0x24d0, 0x24d1,
+    0x24d2, 0x24d3, 0x24d4, 0x24d5, 0x24d6, 0x24d7, 0x24d8, 0x24d9,
+    0x24da, 0x24db, 0x24dc, 0x24dd, 0x24de, 0x24df, 0x24e0, 0x24e1,
+    0x24e2, 0x24e3, 0x24e4, 0x24e5, 0x24e6, 0x24e7, 0x24e8, 0x24e9,
+    0x24b6, 0x24b7, 0x24b8, 0x24b9, 0x24ba, 0x24bb, 0x24bc, 0x24bd,
+    0x24be, 0x24bf, 0x24c0, 0x24c1, 0x24c2, 0x24c3, 0x24c4, 0x24c5,
+    0x24c6, 0x24c7, 0x24c8, 0x24c9, 0x24ca, 0x24cb, 0x24cc, 0x24cd,
+    0x24ce, 0x24cf, 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, 0xff41, 0xff42, 0xff43, 0xff44, 0xff45, 0xff46, 0xff47,
+    0xff48, 0xff49, 0xff4a, 0xff4b, 0xff4c, 0xff4d, 0xff4e, 0xff4f,
+    0xff50, 0xff51, 0xff52, 0xff53, 0xff54, 0xff55, 0xff56, 0xff57,
+    0xff58, 0xff59, 0xff5a, 0, 0, 0, 0, 0,
+    0, 0xff21, 0xff22, 0xff23, 0xff24, 0xff25, 0xff26, 0xff27,
+    0xff28, 0xff29, 0xff2a, 0xff2b, 0xff2c, 0xff2d, 0xff2e, 0xff2f,
+    0xff30, 0xff31, 0xff32, 0xff33, 0xff34, 0xff35, 0xff36, 0xff37,
+    0xff38, 0xff39, 0xff3a, 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, 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,
+};
+// 36602 bytes
+
+const TQ_INT8 TQUnicodeTables::decimal_info[] = {
+    1, 0, 0, 0, 0, 0, 2, 0,
+    0, 3, 3, 4, 3, 5, 6, 7,
+    8, 0, 0, 9, 0, 0, 0, 10,
+    11, 0, 0, 0, 0, 0, 0, 0,
+    12, 0, 0, 0, 13, 0, 0, 14,
+    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, 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, 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, 11,
+
+
+    -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,
+    0, 1, 2, 3, 4, 5, 6, 7,
+    8, 9, -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, 2, 3, -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, -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,
+    0, 1, 2, 3, 4, 5, 6, 7,
+    8, 9, -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, -1, -1, -1, -1, -1,
+    0, 1, 2, 3, 4, 5, 6, 7,
+    8, 9, -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, 0, 1,
+    2, 3, 4, 5, 6, 7, 8, 9,
+    -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, 0, 1,
+    2, 3, 4, 5, 6, 7, 8, 9,
+    -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, 0, 1,
+    2, 3, 4, 5, 6, 7, 8, 9,
+    -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,
+    2, 3, 4, 5, 6, 7, 8, 9,
+    -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, 0, 1,
+    2, 3, 4, 5, 6, 7, 8, 9,
+    -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, -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,
+    0, 1, 2, 3, 4, 5, 6, 7,
+    8, 9, -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,
+    0, 1, 2, 3, 4, 5, 6, 7,
+    8, 9, -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,
+    0, 1, 2, 3, 4, 5, 6, 7,
+    8, 9, -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, -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, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1,
+    0, 1, 2, 3, 4, 5, 6, 7,
+    8, 9, -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, -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, -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, 2, 3, 4, 5, 6, 7,
+    8, 9, -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, -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, -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,
+    0, 1, 2, 3, 4, 5, 6, 7,
+    8, 9, -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,
+    0, 1, 2, 3, 4, 5, 6, 7,
+    8, 9, -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, -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, -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,
+    0, -1, -1, -1, 4, 5, 6, 7,
+    8, 9, -1, -1, -1, -1, -1, -1,
+    0, 1, 2, 3, 4, 5, 6, 7,
+    8, 9, -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, -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, 2, 3, 4, 5, 6, 7, 8,
+    9, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, 1, 2, 3, 4,
+    5, 6, 7, 8, 9, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1,
+    1, 2, 3, 4, 5, 6, 7, 8,
+    9, -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, 0, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, 1, 2, 3,
+    4, 5, 6, 7, 8, 9, -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, 2,
+    3, 4, 5, 6, 7, 8, 9, -1,
+    1, 2, 3, 4, 5, 6, 7, 8,
+    9, -1, 1, 2, 3, 4, 5, 6,
+    7, 8, 9, -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,
+};
+// 40698 bytes
+
+#endif
+
+#ifdef TQT_NO_UNICODETABLES
+
+const TQ_UINT8 TQUnicodeTables::latin1_line_break_info[] = {
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 15, 23, 19, 21, 22, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    26, 5, 2, 11, 8, 9, 11, 2,
+    0, 1, 11, 8, 7, 14, 7, 6,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 7, 7, 11, 11, 11, 5,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 0, 8, 1, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 0, 15, 1, 11, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    3, 11, 9, 8, 8, 8, 11, 11,
+    11, 11, 11, 2, 11, 15, 11, 11,
+    9, 8, 11, 11, 16, 11, 11, 11,
+    11, 11, 11, 2, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+};
+
+#else
+
+const TQ_UINT8 TQUnicodeTables::line_break_info[] = {
+    1, 2, 3, 4, 5, 6, 7, 8,
+    2, 9, 10, 11, 12, 13, 14, 15,
+    16, 17, 2, 18, 2, 2, 19, 20,
+    21, 2, 2, 2, 2, 2, 2, 2,
+    22, 23, 24, 25, 2, 2, 2, 26,
+    2, 27, 2, 2, 2, 2, 28, 29,
+    30, 31, 32, 33, 34, 34, 34, 34,
+    34, 34, 34, 34, 34, 34, 34, 34,
+    34, 34, 34, 34, 34, 34, 34, 34,
+    34, 34, 34, 34, 34, 35, 34, 34,
+    34, 34, 34, 34, 34, 34, 34, 34,
+    34, 34, 34, 34, 34, 34, 34, 34,
+    34, 34, 34, 34, 34, 34, 34, 34,
+    34, 34, 34, 34, 34, 34, 34, 34,
+    34, 34, 34, 34, 34, 34, 34, 34,
+    34, 34, 34, 34, 34, 34, 34, 34,
+    34, 34, 34, 34, 34, 34, 34, 34,
+    34, 34, 34, 34, 34, 34, 34, 34,
+    34, 34, 34, 34, 34, 34, 34, 34,
+    34, 34, 34, 34, 34, 34, 34, 36,
+    34, 34, 34, 34, 37, 2, 2, 2,
+    2, 2, 2, 2, 34, 34, 34, 34,
+    34, 34, 34, 34, 34, 34, 34, 34,
+    34, 34, 34, 34, 34, 34, 34, 34,
+    34, 34, 34, 34, 34, 34, 34, 34,
+    34, 34, 34, 34, 34, 34, 34, 34,
+    34, 34, 34, 34, 34, 34, 34, 38,
+    39, 39, 39, 39, 39, 39, 39, 39,
+    2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 2, 2, 2, 2, 2, 2,
+    2, 34, 40, 41, 2, 42, 43, 44,
+
+
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 15, 23, 19, 21, 22, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    26, 5, 2, 11, 8, 9, 11, 2,
+    0, 1, 11, 8, 7, 14, 7, 6,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 7, 7, 11, 11, 11, 5,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 0, 8, 1, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 0, 15, 1, 11, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    3, 11, 9, 8, 8, 8, 11, 11,
+    11, 11, 11, 2, 11, 15, 11, 11,
+    9, 8, 11, 11, 16, 11, 11, 11,
+    11, 11, 11, 2, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    16, 11, 11, 11, 16, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 19, 19, 19, 19, 11,
+    19, 19, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 7, 15, 11, 11, 11, 11, 11,
+    11, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 11, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 11, 19, 19, 19, 11, 19,
+    11, 19, 19, 11, 19, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 11, 11, 11, 11, 11, 11,
+    19, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 11, 11, 19,
+    19, 11, 19, 19, 19, 19, 11, 11,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 11, 11, 11, 11, 11, 11,
+
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 19,
+    11, 19, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+
+    11, 19, 19, 19, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 19, 11, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 11, 11,
+    11, 19, 19, 19, 19, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 19, 19, 11, 11, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 19, 19, 19, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 19, 11, 19, 19,
+    19, 19, 19, 19, 19, 11, 11, 19,
+    19, 11, 11, 19, 19, 19, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 19,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 19, 19, 11, 11, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    11, 11, 8, 8, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+
+    11, 11, 19, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 19, 11, 19, 19,
+    19, 19, 19, 11, 11, 11, 11, 19,
+    19, 11, 11, 19, 19, 19, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    19, 19, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 19, 19, 19, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 19, 11, 19, 19,
+    19, 19, 19, 19, 19, 19, 11, 19,
+    19, 19, 11, 19, 19, 19, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+
+    11, 19, 19, 19, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 19, 11, 19, 19,
+    19, 19, 19, 19, 11, 11, 11, 19,
+    19, 11, 11, 19, 19, 19, 11, 11,
+    11, 11, 11, 11, 11, 11, 19, 19,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 19, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 19, 19,
+    19, 19, 19, 11, 11, 11, 19, 19,
+    19, 11, 19, 19, 19, 19, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 19,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+
+    11, 19, 19, 19, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 19, 19,
+    19, 19, 19, 19, 19, 11, 19, 19,
+    19, 11, 19, 19, 19, 19, 11, 11,
+    11, 11, 11, 11, 11, 19, 19, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 19, 19, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 19, 19,
+    19, 19, 19, 19, 19, 11, 19, 19,
+    19, 11, 19, 19, 19, 19, 11, 11,
+    11, 11, 11, 11, 11, 19, 19, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+
+    11, 11, 19, 19, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 19, 19,
+    19, 19, 19, 19, 11, 11, 19, 19,
+    19, 11, 19, 19, 19, 19, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 19,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 19, 19, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 19, 11, 11, 11, 11, 19,
+    19, 19, 19, 19, 19, 11, 19, 11,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 19, 19, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+
+    11, 20, 20, 20, 20, 20, 20, 20,
+    20, 20, 20, 20, 20, 20, 20, 20,
+    20, 20, 20, 20, 20, 20, 20, 20,
+    20, 20, 20, 20, 20, 20, 20, 20,
+    20, 20, 20, 20, 20, 20, 20, 20,
+    20, 20, 20, 20, 20, 20, 20, 20,
+    20, 19, 20, 20, 19, 19, 19, 19,
+    19, 19, 19, 11, 11, 11, 11, 8,
+    20, 20, 20, 20, 20, 20, 20, 19,
+    19, 19, 19, 19, 19, 19, 19, 11,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 4, 4, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 20, 20, 11, 20, 11, 11, 20,
+    20, 11, 20, 11, 11, 20, 11, 11,
+    11, 11, 11, 11, 20, 20, 20, 20,
+    11, 20, 20, 20, 20, 20, 20, 20,
+    11, 20, 20, 20, 11, 20, 11, 20,
+    11, 11, 20, 20, 11, 20, 20, 20,
+    20, 19, 20, 20, 19, 19, 19, 19,
+    19, 19, 11, 19, 19, 20, 11, 11,
+    20, 20, 20, 20, 20, 11, 20, 11,
+    19, 19, 19, 19, 19, 19, 11, 11,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 11, 11, 20, 20, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 15, 3, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    19, 19, 11, 11, 11, 11, 11, 11,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 19, 11, 19,
+    11, 19, 0, 1, 0, 1, 19, 19,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 11, 19, 19,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    11, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 19, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+
+    20, 20, 20, 20, 20, 20, 20, 20,
+    20, 20, 20, 20, 20, 20, 20, 20,
+    20, 20, 20, 20, 20, 20, 20, 20,
+    20, 20, 20, 20, 20, 20, 20, 20,
+    20, 20, 11, 20, 20, 20, 20, 20,
+    11, 20, 20, 11, 19, 19, 19, 19,
+    19, 19, 19, 11, 11, 11, 19, 19,
+    19, 19, 11, 11, 11, 11, 11, 11,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 11, 11, 11, 11, 11, 11,
+    20, 20, 20, 20, 20, 20, 19, 19,
+    19, 19, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 11, 11, 11, 11, 11, 12,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 11, 11, 11, 11, 11,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 11, 11, 11, 11, 11, 11,
+
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 15, 11, 11, 11, 11, 11, 11,
+    11, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    15, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 0, 1, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 19, 19, 19, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 19, 19, 19, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 19, 19, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 19, 19, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    20, 20, 20, 20, 20, 20, 20, 20,
+    20, 20, 20, 20, 20, 20, 20, 20,
+    20, 20, 20, 20, 20, 20, 20, 20,
+    20, 20, 20, 20, 20, 20, 20, 20,
+    20, 20, 20, 20, 20, 20, 20, 20,
+    20, 20, 20, 20, 20, 20, 20, 20,
+    20, 20, 20, 20, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 4, 15, 4, 4,
+    4, 4, 4, 8, 11, 11, 11, 11,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+
+    11, 11, 11, 11, 11, 11, 16, 11,
+    11, 11, 11, 19, 19, 19, 19, 11,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 19, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+
+    15, 15, 15, 15, 15, 15, 15, 3,
+    15, 15, 15, 18, 19, 19, 19, 19,
+    15, 3, 15, 15, 17, 11, 11, 11,
+    2, 2, 0, 2, 2, 2, 0, 2,
+    11, 11, 11, 11, 13, 13, 13, 15,
+    21, 21, 19, 19, 19, 19, 19, 3,
+    9, 9, 9, 9, 9, 9, 9, 9,
+    11, 2, 2, 11, 4, 11, 11, 11,
+    11, 11, 11, 11, 4, 0, 1, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 15,
+    3, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 19, 19, 19, 19, 19, 19,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 0, 1, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 0, 1, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    8, 8, 8, 8, 8, 8, 8, 9,
+    8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+
+    11, 11, 11, 9, 11, 11, 11, 11,
+    11, 9, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 8, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 9, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 8, 8, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 0, 1, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 0, 1, 2, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 2, 2, 2, 2, 11,
+    11, 11, 5, 5, 11, 11, 11, 11,
+    0, 1, 0, 1, 0, 1, 0, 1,
+    0, 1, 0, 1, 0, 1, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 0, 1,
+    0, 1, 0, 1, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 0, 1, 0, 1, 0,
+    1, 0, 1, 0, 1, 0, 1, 0,
+    1, 0, 1, 0, 1, 0, 1, 0,
+    1, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    0, 1, 0, 1, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 0, 1, 11, 11,
+
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 11, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 11, 11, 11, 11,
+
+    12, 1, 1, 12, 12, 4, 12, 12,
+    0, 1, 0, 1, 0, 1, 0, 1,
+    0, 1, 12, 12, 0, 1, 0, 1,
+    0, 1, 0, 1, 4, 0, 1, 1,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 19, 19, 19, 19, 19, 19,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 4, 4, 12, 12, 12,
+    11, 4, 12, 4, 12, 4, 12, 4,
+    12, 4, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 4, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 4, 12, 4, 12, 4,
+    12, 12, 12, 12, 12, 12, 4, 12,
+    12, 12, 12, 12, 12, 4, 4, 11,
+    11, 19, 19, 4, 4, 4, 4, 12,
+    4, 4, 12, 4, 12, 4, 12, 4,
+    12, 4, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 4, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 4, 12, 4, 12, 4,
+    12, 12, 12, 12, 12, 12, 4, 12,
+    12, 12, 12, 12, 12, 4, 4, 12,
+    12, 12, 12, 4, 4, 4, 12, 12,
+
+    11, 11, 11, 11, 11, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 11, 11, 11,
+    11, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 11,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    4, 4, 4, 4, 4, 4, 4, 4,
+    4, 4, 4, 4, 4, 4, 4, 4,
+
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 11, 11, 11,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 11, 11, 11, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 11, 11, 11, 11,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 11,
+
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 11,
+    11, 11, 11, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 11, 11,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 11,
+
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 11, 11, 11,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+
+    24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24,
+
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 11, 11,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 19, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 0, 1,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 9, 11, 11, 11,
+
+    19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    19, 19, 19, 19, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    12, 12, 12, 12, 12, 0, 1, 0,
+    1, 0, 1, 0, 1, 0, 1, 0,
+    1, 0, 1, 0, 1, 12, 12, 11,
+    11, 12, 12, 12, 12, 12, 12, 12,
+    1, 12, 1, 11, 4, 4, 5, 5,
+    12, 0, 1, 0, 1, 0, 1, 12,
+    12, 12, 12, 12, 12, 12, 12, 11,
+    12, 8, 9, 12, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 3,
+
+    11, 5, 12, 12, 8, 9, 12, 12,
+    0, 1, 12, 12, 1, 12, 1, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 4, 4, 12, 12, 12, 5,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 0, 12, 1, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 0, 12, 1, 12, 0,
+    1, 1, 0, 1, 1, 4, 11, 4,
+    4, 4, 4, 4, 4, 4, 4, 4,
+    4, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 4, 4,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    9, 8, 12, 12, 12, 8, 8, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11,
+    11, 19, 19, 19, 25, 11, 11, 11,
+};
+// 52474 bytes
+
+// END OF GENERATED DATA
+#endif
+
+
+
+#ifndef TQT_NO_UNICODETABLES
+const TQ_UINT16 TQUnicodeTables::symmetricPairs[] = {
+    0x0028, 0x0029, 0x003C, 0x003E, 0x005B, 0x005D, 0x007B, 0x007D,
+    0x00AB, 0x00BB, 0x2039, 0x203A, 0x2045, 0x2046, 0x207D, 0x207E,
+    0x208D, 0x208E, 0x2208, 0x220B, 0x2209, 0x220C, 0x220A, 0x220D,
+    0x2215, 0x29F5, 0x223C, 0x223D, 0x2243, 0x22CD, 0x2252, 0x2253,
+    0x2254, 0x2255, 0x2264, 0x2265, 0x2266, 0x2267, 0x2268, 0x2269,
+    0x226A, 0x226B, 0x226E, 0x226F, 0x2270, 0x2271, 0x2272, 0x2273,
+    0x2274, 0x2275, 0x2276, 0x2277, 0x2278, 0x2279, 0x227A, 0x227B,
+    0x227C, 0x227D, 0x227E, 0x227F, 0x2280, 0x2281, 0x2282, 0x2283,
+    0x2284, 0x2285, 0x2286, 0x2287, 0x2288, 0x2289, 0x228A, 0x228B,
+    0x228F, 0x2290, 0x2291, 0x2292, 0x2298, 0x29B8, 0x22A2, 0x22A3,
+    0x22A6, 0x2ADE, 0x22A8, 0x2AE4, 0x22A9, 0x2AE3, 0x22AB, 0x2AE5,
+    0x22B0, 0x22B1, 0x22B2, 0x22B3, 0x22B4, 0x22B5, 0x22B6, 0x22B7,
+    0x22C9, 0x22CA, 0x22CB, 0x22CC, 0x22D0, 0x22D1, 0x22D6, 0x22D7,
+    0x22D8, 0x22D9, 0x22DA, 0x22DB, 0x22DC, 0x22DD, 0x22DE, 0x22DF,
+    0x22E0, 0x22E1, 0x22E2, 0x22E3, 0x22E4, 0x22E5, 0x22E6, 0x22E7,
+    0x22E8, 0x22E9, 0x22EA, 0x22EB, 0x22EC, 0x22ED, 0x22F0, 0x22F1,
+    0x22F2, 0x22FA, 0x22F3, 0x22FB, 0x22F4, 0x22FC, 0x22F6, 0x22FD,
+    0x22F7, 0x22FE, 0x2308, 0x2309, 0x230A, 0x230B, 0x2329, 0x232A,
+    0x2768, 0x2769, 0x276A, 0x276B, 0x276C, 0x276D, 0x276E, 0x276F,
+    0x2770, 0x2771, 0x2772, 0x2773, 0x2774, 0x2775, 0x27D5, 0x27D6,
+    0x27DD, 0x27DE, 0x27E2, 0x27E3, 0x27E4, 0x27E5, 0x27E6, 0x27E7,
+    0x27E8, 0x27E9, 0x27EA, 0x27EB, 0x2983, 0x2984, 0x2985, 0x2986,
+    0x2987, 0x2988, 0x2989, 0x298A, 0x298B, 0x298C, 0x298D, 0x2990,
+    0x298E, 0x298F, 0x2991, 0x2992, 0x2993, 0x2994, 0x2995, 0x2996,
+    0x2997, 0x2998, 0x29C0, 0x29C1, 0x29C4, 0x29C5, 0x29CF, 0x29D0,
+    0x29D1, 0x29D2, 0x29D4, 0x29D5, 0x29D8, 0x29D9, 0x29DA, 0x29DB,
+    0x29F8, 0x29F9, 0x29FC, 0x29FD, 0x2A2B, 0x2A2C, 0x2A34, 0x2A35,
+    0x2A3C, 0x2A3D, 0x2A64, 0x2A65, 0x2A79, 0x2A7A, 0x2A7D, 0x2A7E,
+    0x2A7F, 0x2A80, 0x2A81, 0x2A82, 0x2A83, 0x2A84, 0x2A8B, 0x2A8C,
+    0x2A91, 0x2A92, 0x2A93, 0x2A94, 0x2A95, 0x2A96, 0x2A97, 0x2A98,
+    0x2A99, 0x2A9A, 0x2A9B, 0x2A9C, 0x2AA1, 0x2AA2, 0x2AA6, 0x2AA7,
+    0x2AA8, 0x2AA9, 0x2AAA, 0x2AAB, 0x2AAC, 0x2AAD, 0x2AAF, 0x2AB0,
+    0x2AB3, 0x2AB4, 0x2ABB, 0x2ABC, 0x2ABD, 0x2ABE, 0x2ABF, 0x2AC0,
+    0x2AC1, 0x2AC2, 0x2AC3, 0x2AC4, 0x2AC5, 0x2AC6, 0x2ACD, 0x2ACE,
+    0x2ACF, 0x2AD0, 0x2AD1, 0x2AD2, 0x2AD3, 0x2AD4, 0x2AD5, 0x2AD6,
+    0x2AEC, 0x2AED, 0x2AF7, 0x2AF8, 0x2AF9, 0x2AFA, 0x3008, 0x3009,
+    0x300A, 0x300B, 0x300C, 0x300D, 0x300E, 0x300F, 0x3010, 0x3011,
+    0x3014, 0x3015, 0x3016, 0x3017, 0x3018, 0x3019, 0x301A, 0x301B,
+    0xFF08, 0xFF09, 0xFF1C, 0xFF1E, 0xFF3B, 0xFF3D, 0xFF5B, 0xFF5D,
+    0xFF5F, 0xFF60, 0xFF62, 0xFF63,
+};
+
+// ### shouldn't this be const?
+const int TQUnicodeTables::symmetricPairsSize =
+   sizeof(symmetricPairs)/sizeof(symmetricPairs[0]);
+
+#else
+
+/*
+  only include info for the first tqunicode range (latin1) when building
+  without tqunicode tables.
+*/
+const TQ_UINT8 TQUnicodeTables::tqunicode_info[] = {
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    7, 26, 26, 26, 28, 26, 26, 26,
+    22, 23, 26, 27, 26, 21, 26, 26,
+    4, 4, 4, 4, 4, 4, 4, 4,
+    4, 4, 26, 26, 27, 27, 27, 26,
+    26, 15, 15, 15, 15, 15, 15, 15,
+    15, 15, 15, 15, 15, 15, 15, 15,
+    15, 15, 15, 15, 15, 15, 15, 15,
+    15, 15, 15, 22, 26, 23, 29, 20,
+    29, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 22, 27, 23, 27, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10,
+    7, 26, 28, 28, 28, 28, 30, 30,
+    29, 30, 16, 24, 27, 21, 30, 29,
+    30, 27, 6, 6, 29, 16, 30, 26,
+    29, 6, 16, 25, 6, 6, 6, 26,
+    15, 15, 15, 15, 15, 15, 15, 15,
+    15, 15, 15, 15, 15, 15, 15, 15,
+    15, 15, 15, 15, 15, 15, 15, 27,
+    15, 15, 15, 15, 15, 15, 15, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 27,
+    16, 16, 16, 16, 16, 16, 16, 16
+};
+
+#endif
+
+/*
+ * ----------------------------------------------------------------------
+ * End of tqunicode tables
+ * ----------------------------------------------------------------------
+ */
+
+enum Script {
+    // European Alphabetic Scripts
+    Latin,
+    Greek,
+    Cyrillic,
+    Armenian,
+    Georgian,
+    Runic,
+    Ogham,
+    SpacingModifiers,
+    CombiningMarks,
+
+    // Middle Eastern Scripts
+    Hebrew,
+    Arabic,
+    Syriac,
+    Thaana,
+
+    // South and Southeast Asian Scripts
+    Devanagari,
+    Bengali,
+    Gurmukhi,
+    Gujarati,
+    Oriya,
+    Tamil,
+    Telugu,
+    Kannada,
+    Malayalam,
+    Sinhala,
+    Thai,
+    Lao,
+    Tibetan,
+    Myanmar,
+    Khmer,
+
+    // East Asian Scripts
+    Han,
+    Hiragana,
+    Katakana,
+    Hangul,
+    Bopomofo,
+    Yi,
+
+    // Additional Scripts
+    Ethiopic,
+    Cherokee,
+    CanadianAboriginal,
+    Mongolian,
+
+    // Symbols
+    CurrencySymbols,
+    LetterlikeSymbols,
+    NumberForms,
+    MathematicalOperators,
+    TechnicalSymbols,
+    GeometricSymbols,
+    MiscellaneousSymbols,
+    EnclosedAndSquare,
+    Braille,
+
+    Unicode,
+
+    // some scripts added in Unicode 3.2
+    Tagalog,
+    Hanunoo,
+    Buhid,
+    Tagbanwa,
+
+    KatakanaHalfWidth,		// from JIS X 0201
+
+    // from Unicode 4.0
+    Limbu,
+    TaiLe,
+
+    // End
+    NScripts,
+    UnknownScript = NScripts
+};
+
+// copied form tqfont.h, as we can't include it in tools. Do not modify without
+// changing the script enum in tqfont.h aswell.
+const unsigned char TQUnicodeTables::otherScripts [128] = {
+#define SCRIPTS_02 0
+    0xaf, Latin, 0xff, SpacingModifiers, 			// row 0x02, index 0
+#define SCRIPTS_03 4
+    0x6f, CombiningMarks, 0xff, Greek, 			// row 0x03, index 4
+#define SCRIPTS_05 8
+    0x2f, Cyrillic, 0x8f, Armenian, 0xff, Hebrew,	// row 0x05, index 8
+#define SCRIPTS_07 14
+    0x4f, Syriac, 0x7f, Unicode, 0xbf, Thaana,
+    0xff, Unicode, 						// row 0x07, index 14
+#define SCRIPTS_10 22
+    0x9f, Myanmar, 0xff, Georgian,			// row 0x10, index 20
+#define SCRIPTS_13 26
+    0x7f, Ethiopic, 0x9f, Unicode, 0xff, Cherokee,	// row 0x13, index 24
+#define SCRIPTS_16 32
+    0x7f, CanadianAboriginal, 0x9f, Ogham,
+    0xff, Runic, 						// row 0x16 index 30
+#define SCRIPTS_17 38
+    0x1f, Tagalog, 0x3f, Hanunoo, 0x5f, Buhid,
+    0x7f, Tagbanwa, 0xff, Khmer,				// row 0x17, index 36
+#define SCRIPTS_18 48
+    0xaf, Mongolian, 0xff, Unicode,		       	// row 0x18, index 46
+#define SCRIPTS_19 52
+    0x4f, Limbu, 0x7f, TaiLe, 0xdf, Unicode, 0xff, Khmer,
+#define SCRIPTS_20 60
+    0x0a, Unicode, 0x0d, UnknownScript, 0x6f, Unicode, 0x9f, NumberForms,
+    0xab, CurrencySymbols, 0xac, Latin,
+    0xcf, CurrencySymbols, 0xff, CombiningMarks,		// row 0x20, index 50
+#define SCRIPTS_21 76
+    0x4f, LetterlikeSymbols, 0x8f, NumberForms,
+    0xff, MathematicalOperators,					// row 0x21, index 62
+#define SCRIPTS_24 82
+    0x5f, TechnicalSymbols, 0xff, EnclosedAndSquare,	// row 0x24, index 68
+#define SCRIPTS_2e 86
+    0x7f, Unicode, 0xff, Han,				// row 0x2e, index 72
+#define SCRIPTS_30 90
+    0x3f, Han, 0x9f, Hiragana, 0xff, Katakana,	// row 0x30, index 76
+#define SCRIPTS_31 96
+    0x2f, Bopomofo, 0x8f, Hangul, 0x9f, Han,
+    0xff, Unicode,						// row 0x31, index 82
+#define SCRIPTS_fb 104
+    0x06, Latin, 0x1c, Unicode, 0x4f, Hebrew,
+    0xff, Arabic,						// row 0xfb, index 90
+#define SCRIPTS_fe 112
+    0x1f, Unicode, 0x2f, CombiningMarks, 0x6f, Han,
+    0xff, Arabic,						// row 0xfe, index 98
+#define SCRIPTS_ff 120
+    0x60, Han,        		// row 0xff, index 106
+    0x9f, KatakanaHalfWidth, 0xef, Han, 0xff, Unicode
+};
+
+// (uc-0x0900)>>7
+const unsigned char TQUnicodeTables::indicScripts [] =
+{
+    Devanagari, Bengali,
+    Gurmukhi, Gujarati,
+    Oriya, Tamil,
+    Telugu, Kannada,
+    Malayalam, Sinhala,
+    Thai, Lao
+};
+
+
+// 0x80 + x: x is the offset into the otherScripts table
+const unsigned char TQUnicodeTables::scriptTable[256] =
+{
+    Latin, Latin, 0x80+SCRIPTS_02, 0x80+SCRIPTS_03,
+    Cyrillic, 0x80+SCRIPTS_05, Arabic, 0x80+SCRIPTS_07,
+    Unicode, SCRIPTS_INDIC, SCRIPTS_INDIC, SCRIPTS_INDIC,
+    SCRIPTS_INDIC, SCRIPTS_INDIC, SCRIPTS_INDIC, Tibetan,
+
+    0x80+SCRIPTS_10, Hangul, Ethiopic, 0x80+SCRIPTS_13,
+    CanadianAboriginal, CanadianAboriginal, 0x80+SCRIPTS_16, 0x80+SCRIPTS_17,
+    0x80+SCRIPTS_18, 0x80+SCRIPTS_19, Unicode, Unicode,
+    Unicode, Unicode, Latin, Greek,
+
+    0x80+SCRIPTS_20, 0x80+SCRIPTS_21, MathematicalOperators, TechnicalSymbols,
+    0x80+SCRIPTS_24, GeometricSymbols, MiscellaneousSymbols, MiscellaneousSymbols,
+    Braille, Unicode, Unicode, Unicode,
+    Unicode, Unicode, 0x80+SCRIPTS_2e, Han,
+
+    0x80+SCRIPTS_30, 0x80+SCRIPTS_31, EnclosedAndSquare, EnclosedAndSquare,
+    Han, Han, Han, Han,
+    Han, Han, Han, Han,
+    Han, Han, Han, Han,
+
+    Han, Han, Han, Han, Han, Han, Han, Han,
+    Han, Han, Han, Han, Han, Han, Han, Han,
+
+    Han, Han, Han, Han, Han, Han, Han, Han,
+    Han, Han, Han, Han, Han, Han, Han, Han,
+
+    Han, Han, Han, Han, Han, Han, Han, Han,
+    Han, Han, Han, Han, Han, Han, Han, Han,
+
+    Han, Han, Han, Han, Han, Han, Han, Han,
+    Han, Han, Han, Han, Han, Han, Han, Han,
+
+
+    Han, Han, Han, Han, Han, Han, Han, Han,
+    Han, Han, Han, Han, Han, Han, Han, Han,
+
+    Han, Han, Han, Han, Han, Han, Han, Han,
+    Han, Han, Han, Han, Han, Han, Han, Han,
+
+    Yi, Yi, Yi, Yi, Yi, Unicode, Unicode, Unicode,
+    Unicode, Unicode, Unicode, Unicode, Hangul, Hangul, Hangul, Hangul,
+
+    Hangul, Hangul, Hangul, Hangul, Hangul, Hangul, Hangul, Hangul,
+    Hangul, Hangul, Hangul, Hangul, Hangul, Hangul, Hangul, Hangul,
+
+    Hangul, Hangul, Hangul, Hangul, Hangul, Hangul, Hangul, Hangul,
+    Hangul, Hangul, Hangul, Hangul, Hangul, Hangul, Hangul, Hangul,
+
+    Hangul, Hangul, Hangul, Hangul, Hangul, Hangul, Hangul, Hangul,
+    Unicode, Unicode, Unicode, Unicode, Unicode, Unicode, Unicode, Unicode,
+
+    Unicode, Unicode, Unicode, Unicode, Unicode, Unicode, Unicode, Unicode,
+    Unicode, Unicode, Unicode, Unicode, Unicode, Unicode, Unicode, Unicode,
+
+    Unicode, Unicode, Unicode, Unicode, Unicode, Unicode, Unicode, Unicode,
+    Unicode, Han, Han, 0x80+SCRIPTS_fb, Arabic, Arabic, 0x80+SCRIPTS_fe, 0x80+SCRIPTS_ff
+};
+
diff --git a/tqtinterface/qt4/src/tools/tqunicodetables_p.h b/tqtinterface/qt4/src/tools/tqunicodetables_p.h
new file mode 100644
index 0000000..4afa5d1
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqunicodetables_p.h
@@ -0,0 +1,266 @@
+/****************************************************************************
+**
+** ???
+**
+** Copyright (C) 2005-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the widgets module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQUNICODETABLES_P_H
+#define TQUNICODETABLES_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the TQt API.  It exists for the convenience
+// of internal files.  This header file may change from version to version
+// without notice, or even be removed.
+//
+// We mean it.
+//
+//
+
+#ifndef TQT_H
+#include "tqstring.h"
+#endif // TQT_H
+
+#ifdef TQT_NO_UNICODETABLES
+# include <ctype.h>
+#endif
+
+class TQUnicodeTables {
+public:
+    static const TQ_UINT8 tqunicode_info[];
+#ifndef TQT_NO_UNICODETABLES
+    static const TQ_UINT16 decomposition_map[];
+    static const TQ_UINT16 decomposition_info[];
+    static const TQ_UINT16 ligature_map[];
+    static const TQ_UINT16 ligature_info[];
+    static const TQ_UINT8 direction_info[];
+    static const TQ_UINT8 combining_info[];
+    static const TQ_UINT16 case_info[];
+    static const TQ_INT8 decimal_info[];
+    static const TQ_UINT16 symmetricPairs[];
+    static const int symmetricPairsSize;
+    static const TQ_UINT8 line_break_info[];
+#else
+    static const TQ_UINT8 latin1_line_break_info[];
+#endif
+    static const unsigned char otherScripts[];
+    static const unsigned char indicScripts[];
+    static const unsigned char scriptTable[];
+    enum { SCRIPTS_INDIC = 0x7e };
+
+    // see http://www.tqunicode.org/reports/tr14/tr14-13.html
+    // we don't use the XX and AI properties and map them to AL instead.
+    enum LineBreakClass {
+	LineBreak_OP, LineBreak_CL, LineBreak_QU, LineBreak_GL, LineBreak_NS,
+	LineBreak_EX, LineBreak_SY, LineBreak_IS, LineBreak_PR, LineBreak_PO,
+	LineBreak_NU, LineBreak_AL, LineBreak_ID, LineBreak_IN, LineBreak_HY,
+	LineBreak_BA, LineBreak_BB, LineBreak_B2, LineBreak_ZW, LineBreak_CM,
+	LineBreak_SA, LineBreak_BK, LineBreak_CR, LineBreak_LF, LineBreak_SG,
+	LineBreak_CB, LineBreak_SP
+    };
+};
+
+
+inline TQChar::Category category( const TQChar &c )
+{
+#ifdef TQT_NO_UNICODETABLES
+    if ( c.tqunicode() > 0xff ) return TQChar::Letter_Uppercase; //########
+    return (TQChar::Category)TQUnicodeTables::tqunicode_info[c.tqunicode()];
+#else
+    register int uc = ((int)TQUnicodeTables::tqunicode_info[c.row()]) << 8;
+    uc += c.cell();
+    return (TQChar::Category)TQUnicodeTables::tqunicode_info[uc];
+#endif // TQT_NO_UNICODETABLES
+}
+
+inline TQChar lower( const TQChar &c )
+{
+#ifndef TQT_NO_UNICODETABLES
+    int row = c.row();
+    int cell = c.cell();
+    register int ci = TQUnicodeTables::case_info[row];
+    register int uc = ((int)TQUnicodeTables::tqunicode_info[c.row()]) << 8;
+    uc += c.cell();
+    if (TQUnicodeTables::tqunicode_info[uc] != TQChar::Letter_Uppercase || !ci)
+	return c;
+    TQ_UINT16 lower = TQUnicodeTables::case_info[(ci<<8)+cell];
+    return lower ? TQChar(lower) : c;
+#else
+    if ( c.row() )
+	return c;
+    return TQChar( tolower((uchar) c.latin1()) );
+#endif
+}
+
+inline TQChar upper( const TQChar &c )
+{
+#ifndef TQT_NO_UNICODETABLES
+    int row = c.row();
+    int cell = c.cell();
+    register int ci = TQUnicodeTables::case_info[row];
+    register int uc = ((int)TQUnicodeTables::tqunicode_info[c.row()]) << 8;
+    uc += c.cell();
+    if (TQUnicodeTables::tqunicode_info[uc] != TQChar::Letter_Lowercase || !ci)
+	return c;
+    TQ_UINT16 upper = TQUnicodeTables::case_info[(ci<<8)+cell];
+    return upper ? TQChar(upper) : c;
+#else
+    if ( c.row() )
+	return c;
+    return TQChar( toupper((uchar) c.latin1()) );
+#endif
+}
+
+inline TQChar::Direction direction( const TQChar &c )
+{
+#ifndef TQT_NO_UNICODETABLES
+    register int pos = TQUnicodeTables::direction_info[c.row()];
+    return (TQChar::Direction) (TQUnicodeTables::direction_info[(pos<<8)+c.cell()] & 0x1f);
+#else
+    TQ_UNUSED(c);
+    return TQChar::DirL;
+#endif
+}
+
+inline bool mirrored( const TQChar &c )
+{
+#ifndef TQT_NO_UNICODETABLES
+    register int pos = TQUnicodeTables::direction_info[c.row()];
+    return TQUnicodeTables::direction_info[(pos<<8)+c.cell()] > 128;
+#else
+    TQ_UNUSED(c);
+    return FALSE;
+#endif
+}
+
+
+inline TQChar mirroredChar( const TQChar &ch )
+{
+#ifndef TQT_NO_UNICODETABLES
+    if(!::mirrored( ch ))
+	return ch;
+
+    int i;
+    int c = ch.tqunicode();
+    for (i = 0; i < TQUnicodeTables::symmetricPairsSize; i ++) {
+	if (TQUnicodeTables::symmetricPairs[i] == c)
+	    return TQUnicodeTables::symmetricPairs[(i%2) ? (i-1) : (i+1)];
+    }
+#endif
+    return ch;
+}
+
+inline TQChar::Joining joining( const TQChar &ch )
+{
+#ifndef TQT_NO_UNICODETABLES
+    register int pos = TQUnicodeTables::direction_info[ch.row()];
+    return (TQChar::Joining) ((TQUnicodeTables::direction_info[(pos<<8)+ch.cell()] >> 5) &0x3);
+#else
+    TQ_UNUSED(ch);
+    return TQChar::OtherJoining;
+#endif
+}
+
+inline bool isMark( const TQChar &ch )
+{
+    TQChar::Category c = ::category( ch );
+    return c >= TQChar::Mark_NonSpacing && c <= TQChar::Mark_Enclosing;
+}
+
+inline unsigned char combiningClass( const TQChar &ch )
+{
+#ifndef TQT_NO_UNICODETABLES
+    const int pos = TQUnicodeTables::combining_info[ch.row()];
+    return TQUnicodeTables::combining_info[(pos<<8) + ch.cell()];
+#else
+    TQ_UNUSED(ch);
+    return 0;
+#endif
+}
+
+inline bool isSpace( const TQChar &ch )
+{
+    if( ch.tqunicode() >= 9 && ch.tqunicode() <=13 ) return TRUE;
+    TQChar::Category c = ::category( ch );
+    return c >= TQChar::Separator_Space && c <= TQChar::Separator_Paragraph;
+}
+
+inline int lineBreakClass( const TQChar &ch )
+{
+#ifdef TQT_NO_UNICODETABLES
+    return ch.row() ? TQUnicodeTables::LineBreak_AL
+	: TQUnicodeTables::latin1_line_break_info[ch.cell()];
+#else
+    register int pos = ((int)TQUnicodeTables::line_break_info[ch.row()] << 8) + ch.cell();
+    return TQUnicodeTables::line_break_info[pos];
+#endif
+}
+
+inline int scriptForChar( ushort uc )
+{
+    unsigned char script = TQUnicodeTables::scriptTable[(uc>>8)];
+    if ( script >= TQUnicodeTables::SCRIPTS_INDIC ) {
+	if ( script == TQUnicodeTables::SCRIPTS_INDIC ) {
+	    script = TQUnicodeTables::indicScripts[ (uc-0x0900)>>7 ];
+	} else {
+	    // 0x80 + SCRIPTS_xx
+	    unsigned char index = script-0x80;
+	    unsigned char cell = uc &0xff;
+	    while( TQUnicodeTables::otherScripts[index++] < cell )
+		index++;
+	    script = TQUnicodeTables::otherScripts[index];
+	}
+    }
+    return script;
+}
+
+#ifdef TQ_WS_X11
+#define SCRIPT_FOR_CHAR( script, c ) 	\
+do { 						\
+    unsigned short _uc = (c).tqunicode(); 		\
+    if ( _uc < 0x100 ) {				\
+	script = TQFont::Latin;		\
+    } else { 					\
+        script = (TQFont::Script)scriptForChar( _uc ); 	\
+    } 						\
+} while( FALSE )
+#else
+#define SCRIPT_FOR_CHAR( script, c ) \
+    script = (TQFont::Script)scriptForChar( (c).tqunicode() )
+#endif
+
+#endif
diff --git a/tqtinterface/qt4/src/tools/tquuid.cpp b/tqtinterface/qt4/src/tools/tquuid.cpp
new file mode 100644
index 0000000..65db5fa
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tquuid.cpp
@@ -0,0 +1,421 @@
+/****************************************************************************
+**
+** Implementation of TQUuid class
+**
+** Copyright (C) 2000-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "tquuid.h"
+
+#include "tqdatastream.h"
+
+/*!
+    \class TQUuid tquuid.h
+    \brief The TQUuid class defines a Universally Unique Identifier (UUID).
+
+    \reentrant
+
+    For objects or declarations that must be uniquely identified,
+    UUIDs (also known as GUIDs) are widely used in order to assign a
+    fixed and easy to compare value to the object or declaration. The
+    128-bit value of a UUID is generated by an algorithm that
+    guarantees that the value is unique.
+
+    In TQt, UUIDs are wrapped by the TQUuid struct which provides
+    convenience functions for handling UUIDs. Most platforms provide a
+    tool to generate new UUIDs, for example, uuidgen and guidgen.
+
+    UUIDs generated by TQUuid, are based on the \c Random version of the
+    \c DCE (Distributed Computing Environment) standard.
+
+    UUIDs can be constructed from numeric values or from strings, or
+    using the static createUuid() function. They can be converted to a
+    string with toString(). UUIDs have a variant() and a version(),
+    and null UUIDs return TRUE from isNull().
+*/
+
+/*!
+    \fn TQUuid::TQUuid()
+
+    Creates the null UUID {00000000-0000-0000-0000-000000000000}.
+*/
+
+/*!
+    \fn TQUuid::TQUuid( uint l, ushort w1, ushort w2, uchar b1, uchar b2, uchar b3, uchar b4, uchar b5, uchar b6, uchar b7, uchar b8 )
+
+    Creates a UUID with the value specified by the parameters, \a l,
+    \a w1, \a w2, \a b1, \a b2, \a b3, \a b4, \a b5, \a b6, \a b7, \a
+    b8.
+
+    Example:
+    \code
+    // {67C8770B-44F1-410A-AB9A-F9B5446F13EE}
+    TQUuid IID_MyInterface( 0x67c8770b, 0x44f1, 0x410a, 0xab, 0x9a, 0xf9, 0xb5, 0x44, 0x6f, 0x13, 0xee )
+    \endcode
+*/
+
+/*!
+    \fn TQUuid::TQUuid( const TQUuid &orig )
+
+    Creates a copy of the TQUuid \a orig.
+*/
+#ifndef TQT_NO_TQUUID_STRING
+/*!
+    Creates a TQUuid object from the string \a text. The function can
+    only convert a string in the format
+    {HHHHHHHH-HHHH-HHHH-HHHH-HHHHHHHHHHHH} (where 'H' stands for a hex
+    digit). If the conversion fails a null UUID is created.
+*/
+TQUuid::TQUuid( const TQString &text )
+{
+    bool ok;
+    if ( text.isEmpty() ) {
+	*this = TQUuid();
+	return;
+    }
+    TQString temp = text.upper();
+    if ( temp[0] != '{' )
+	temp = "{" + text;
+    if ( text[(int)text.length()-1] != '}' )
+	temp += "}";
+
+    data1 = temp.mid( 1, 8 ).toULong( &ok, 16 );
+    if ( !ok ) {
+	*this = TQUuid();
+	return;
+    }
+
+    data2 = temp.mid( 10, 4 ).toUInt( &ok, 16 );
+    if ( !ok ) {
+	*this = TQUuid();
+	return;
+    }
+    data3 = temp.mid( 15, 4 ).toUInt( &ok, 16 );
+    if ( !ok ) {
+	*this = TQUuid();
+	return;
+    }
+    data4[0] = temp.mid( 20, 2 ).toUInt( &ok, 16 );
+    if ( !ok ) {
+	*this = TQUuid();
+	return;
+    }
+    data4[1] = temp.mid( 22, 2 ).toUInt( &ok, 16 );
+    if ( !ok ) {
+	*this = TQUuid();
+	return;
+    }
+    for ( int i = 2; i<8; i++ ) {
+	data4[i] = temp.mid( 25 + (i-2)*2, 2 ).toUShort( &ok, 16 );
+	if ( !ok ) {
+	    *this = TQUuid();
+	    return;
+	}
+    }
+}
+
+/*!
+    \internal
+*/
+TQUuid::TQUuid( const char *text )
+{
+    *this = TQUuid( TQString(text) );
+}
+#endif
+/*!
+    \fn TQUuid TQUuid::operator=(const TQUuid &uuid )
+
+    Assigns the value of \a uuid to this TQUuid object.
+*/
+
+/*!
+    \fn bool TQUuid::operator==(const TQUuid &other) const
+
+    Returns TRUE if this TQUuid and the \a other TQUuid are identical;
+    otherwise returns FALSE.
+*/
+
+/*!
+    \fn bool TQUuid::operator!=(const TQUuid &other) const
+
+    Returns TRUE if this TQUuid and the \a other TQUuid are different;
+    otherwise returns FALSE.
+*/
+#ifndef TQT_NO_TQUUID_STRING
+/*!
+    \fn TQUuid::operator TQString() const
+
+    Returns the string representation of the uuid.
+
+    \sa toString()
+*/
+
+/*!
+    TQString TQUuid::toString() const
+
+    Returns the string representation of the uuid.
+*/
+TQString TQUuid::toString() const
+{
+    TQString result;
+
+    result = "{" + TQT_TQSTRING(TQString::number( data1, 16 )).rightJustify( 8, '0' ) + "-";
+    result += TQT_TQSTRING(TQString::number( (int)data2, 16 )).rightJustify( 4, '0' ) + "-";
+    result += TQT_TQSTRING(TQString::number( (int)data3, 16 )).rightJustify( 4, '0' ) + "-";
+    result += TQT_TQSTRING(TQString::number( (int)data4[0], 16 )).rightJustify( 2, '0' );
+    result += TQT_TQSTRING(TQString::number( (int)data4[1], 16 )).rightJustify( 2, '0' ) + "-";
+    for ( int i = 2; i < 8; i++ )
+	result += TQT_TQSTRING(TQString::number( (int)data4[i], 16 )).rightJustify( 2, '0' );
+
+    return result + "}";
+}
+#endif
+
+#ifndef TQT_NO_DATASTREAM
+/*!
+    \relates TQUuid
+    Writes the uuid \a id to the datastream \a s.
+*/
+TQDataStream &operator<<( TQDataStream &s, const TQUuid &id )
+{
+    s << (TQ_UINT32)id.data1;
+    s << (TQ_UINT16)id.data2;
+    s << (TQ_UINT16)id.data3;
+    for (int i = 0; i < 8; i++ )
+	s << (TQ_UINT8)id.data4[i];
+    return s;
+}
+
+/*!
+    \relates TQUuid
+    Reads uuid from from the stream \a s into \a id.
+*/
+TQDataStream &operator>>( TQDataStream &s, TQUuid &id )
+{
+    TQ_UINT32 u32;
+    TQ_UINT16 u16;
+    TQ_UINT8 u8;
+    s >> u32;
+    id.data1 = u32;
+    s >> u16;
+    id.data2 = u16;
+    s >> u16;
+    id.data3 = u16;
+    for (int i = 0; i < 8; i++ ) {
+	s >> u8;
+	id.data4[i] = u8;
+    }
+    return s;
+}
+#endif
+
+/*!
+    Returns TRUE if this is the null UUID
+    {00000000-0000-0000-0000-000000000000}; otherwise returns FALSE.
+*/
+bool TQUuid::isNull() const
+{
+    return data4[0] == 0 && data4[1] == 0 && data4[2] == 0 && data4[3] == 0 &&
+	   data4[4] == 0 && data4[5] == 0 && data4[6] == 0 && data4[7] == 0 &&
+	   data1 == 0 && data2 == 0 && data3 == 0;
+}
+
+/*!
+    \enum TQUuid::Variant
+
+    This enum defines the variant of the UUID, which is the scheme
+    which defines the tqlayout of the 128-bits value.
+
+    \value VarUnknown Variant is unknown
+    \value NCS Reserved for NCS (Network Computing System) backward compatibility
+    \value DCE Distributed Computing Environment, the scheme used by TQUuid
+    \value Microsoft Reserved for Microsoft backward compatibility (GUID)
+    \value Reserved Reserved for future definition
+*/
+
+/*!
+    \enum TQUuid::Version
+
+    This enum defines the version of the UUID.
+
+    \value VerUnknown Version is unknown
+    \value Time Time-based, by using timestamp, clock sequence, and
+    MAC network card address (if available) for the node sections
+    \value EmbeddedPOSIX DCE Security version, with embedded POSIX UUIDs
+    \value Name Name-based, by using values from a name for all sections
+    \value Random Random-based, by using random numbers for all sections
+*/
+
+/*!
+    \fn TQUuid::Variant TQUuid::variant() const
+
+    Returns the variant of the UUID.
+    The null UUID is considered to be of an unknown variant.
+
+    \sa version()
+*/
+TQUuid::Variant TQUuid::variant() const
+{
+    if ( isNull() )
+	return VarUnknown;
+    // Check the 3 MSB of data4[0]
+    if ( (data4[0] & 0x80) == 0x00 ) return NCS;
+    else if ( (data4[0] & 0xC0) == 0x80 ) return DCE;
+    else if ( (data4[0] & 0xE0) == 0xC0 ) return Microsoft;
+    else if ( (data4[0] & 0xE0) == 0xE0 ) return Reserved;
+    return VarUnknown;
+}
+
+/*!
+    \fn TQUuid::Version TQUuid::version() const
+
+    Returns the version of the UUID, if the UUID is of the DCE
+    variant; otherwise returns VerUnknown.
+
+    \sa variant()
+*/
+TQUuid::Version TQUuid::version() const
+{
+    // Check the 4 MSB of data3
+    Version ver = (Version)(data3>>12);
+    if ( isNull() 
+	 || (variant() != DCE)
+	 || ver < Time 
+	 || ver > Random )
+	return VerUnknown;
+    return ver;
+}
+
+/*!
+    \fn bool TQUuid::operator<(const TQUuid &other) const
+
+    Returns TRUE if this TQUuid is of the same variant,
+    and lexicographically before the \a other TQUuid;
+    otherwise returns FALSE.
+
+    \sa variant()
+*/
+#define ISLESS(f1, f2) if (f1!=f2) return (f1<f2);
+bool TQUuid::operator<(const TQUuid &other ) const
+{
+    if ( variant() != other.variant() )
+	return FALSE;
+
+    ISLESS( data1, other.data1 );
+    ISLESS( data2, other.data2 );
+    ISLESS( data3, other.data3 );
+    for ( int n = 0; n < 8; n++ ) {
+	ISLESS( data4[n], other.data4[n] );
+    }
+    return FALSE;
+}
+
+/*!
+    \fn bool TQUuid::operator>(const TQUuid &other) const
+
+    Returns TRUE if this TQUuid is of the same variant,
+    and lexicographically after the \a other TQUuid;
+    otherwise returns FALSE.
+
+    \sa variant()
+*/
+#define ISMORE(f1, f2) if (f1!=f2) return (f1>f2);
+bool TQUuid::operator>(const TQUuid &other ) const
+{
+    if ( variant() != other.variant() )
+	return FALSE;
+
+    ISMORE( data1, other.data1 );
+    ISMORE( data2, other.data2 );
+    ISMORE( data3, other.data3 );
+    for ( int n = 0; n < 8; n++ ) {
+	ISMORE( data4[n], other.data4[n] );
+    }
+    return FALSE;
+}
+
+/*!
+    \fn TQUuid TQUuid::createUuid()
+
+    Returns a new UUID of \c DCE variant, and \c Random type. The
+    UUIDs generated are based on the platform specific pseudo-random
+    generator, which is usually not a cryptographic-quality random
+    number generator. Therefore, a UUID is not guaranteed to be unique
+    cross application instances.
+
+    On Windows, the new UUID is extremely likely to be unique on the
+    same or any other system, networked or not.
+
+    \sa variant(), version()
+*/
+#if defined(TQ_OS_WIN32)
+#include <objbase.h> // For CoCreateGuid
+TQUuid TQUuid::createUuid()
+{
+    GUID guid;
+    CoCreateGuid( &guid );
+    TQUuid result = guid;
+    return result;
+}
+#else // !TQ_OS_WIN32
+#include "tqdatetime.h"
+#include "stdlib.h" // For srand/rand
+TQUuid TQUuid::createUuid()
+{
+    static const int intbits = sizeof(int)*8;
+    static int randbits = 0;
+    if ( !randbits ) {
+	int max = RAND_MAX;
+	do { ++randbits; } while ( (max=max>>1) );
+	srand( (uint)TQDateTime::tqcurrentDateTime().toTime_t() );
+	rand(); // Skip first
+    }
+
+    TQUuid result;
+    uint *data = &(result.data1);
+    int chunks = 16 / sizeof(uint);
+    while ( chunks-- ) {
+	uint randNumber = 0;
+	for ( int filled = 0; filled < intbits; filled += randbits )
+	    randNumber |= rand()<<filled;
+	 *(data+chunks) = randNumber;
+    }
+
+    result.data4[0] = (result.data4[0] & 0x3F) | 0x80;	// UV_DCE
+    result.data3 = (result.data3 & 0x0FFF) | 0x4000;	// UV_Random
+
+    return result;
+}
+#endif // !TQ_OS_WIN32
+
diff --git a/tqtinterface/qt4/src/tools/tquuid.h b/tqtinterface/qt4/src/tools/tquuid.h
new file mode 100644
index 0000000..7a2de25
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tquuid.h
@@ -0,0 +1,194 @@
+/****************************************************************************
+**
+** Definition of TQUuid class
+**
+** Created : 010523
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQUUID_H
+#define TQUUID_H
+
+#ifndef TQT_H
+#include "tqstring.h"
+#endif // TQT_H
+
+#include <string.h>
+
+#if defined(TQ_OS_WIN32)
+#ifndef GUID_DEFINED
+#define GUID_DEFINED
+typedef struct _GUID
+{
+    ulong   Data1;
+    ushort  Data2;
+    ushort  Data3;
+    uchar   Data4[ 8 ];
+} GUID, *REFGUID, *LPGUID;
+#endif
+#endif
+
+
+struct TQ_EXPORT TQUuid
+{
+    enum Variant {
+	VarUnknown	=-1,
+	NCS		= 0, // 0 - -
+	DCE		= 2, // 1 0 -
+	Microsoft	= 6, // 1 1 0
+	Reserved	= 7  // 1 1 1
+    };
+
+    enum Version {
+	VerUnknown	=-1,
+	Time		= 1, // 0 0 0 1
+	EmbeddedPOSIX	= 2, // 0 0 1 0
+	Name		= 3, // 0 0 1 1
+	Random		= 4  // 0 1 0 0
+    };
+
+    TQUuid()
+    {
+	memset( this, 0, sizeof(TQUuid) );
+    }
+    TQUuid( uint l, ushort w1, ushort w2, uchar b1, uchar b2, uchar b3, uchar b4, uchar b5, uchar b6, uchar b7, uchar b8 )
+    {
+	data1 = l;
+	data2 = w1;
+	data3 = w2;
+	data4[0] = b1;
+	data4[1] = b2;
+	data4[2] = b3;
+	data4[3] = b4;
+	data4[4] = b5;
+	data4[5] = b6;
+	data4[6] = b7;
+	data4[7] = b8;
+    }
+    TQUuid( const TQUuid &uuid )
+    {
+	memcpy( this, &uuid, sizeof(TQUuid) );
+    }
+#ifndef TQT_NO_TQUUID_STRING
+    TQUuid( const TQString & );
+    TQUuid( const char * );
+    TQString toString() const;
+    operator TQString() const { return toString(); }
+#endif
+    bool isNull() const;
+
+    TQUuid &operator=(const TQUuid &orig )
+    {
+	memcpy( this, &orig, sizeof(TQUuid) );
+	return *this;
+    }
+
+    bool operator==(const TQUuid &orig ) const
+    {
+	uint i;
+	if ( data1 != orig.data1 || data2 != orig.data2 || 
+	     data3 != orig.data3 )
+	    return FALSE;
+
+	for( i = 0; i < 8; i++ )
+	    if ( data4[i] != orig.data4[i] )
+		return FALSE;
+	
+	return TRUE;
+    }
+
+    bool operator!=(const TQUuid &orig ) const
+    {
+	return !( *this == orig );
+    }
+
+    bool operator<(const TQUuid &other ) const;
+    bool operator>(const TQUuid &other ) const;
+
+#if defined(TQ_OS_WIN32)
+    // On Windows we have a type GUID that is used by the platform API, so we
+    // provide convenience operators to cast from and to this type.
+    TQUuid( const GUID &guid )
+    {
+	memcpy( this, &guid, sizeof(GUID) );
+    }
+
+    TQUuid &operator=(const GUID &orig )
+    {
+	memcpy( this, &orig, sizeof(TQUuid) );
+	return *this;
+    }
+
+    operator GUID() const
+    {
+	GUID guid = { data1, data2, data3, { data4[0], data4[1], data4[2], data4[3], data4[4], data4[5], data4[6], data4[7] } };
+	return guid;
+    }
+
+    bool operator==( const GUID &guid ) const
+    {
+	uint i;
+	if ( data1 != guid.Data1 || data2 != guid.Data2 || 
+	     data3 != guid.Data3 )
+	    return FALSE;
+
+	for( i = 0; i < 8; i++ )
+	    if ( data4[i] != guid.Data4[i] )
+		return FALSE;
+	
+	return TRUE;
+    }
+
+    bool operator!=( const GUID &guid ) const
+    {
+	return !( *this == guid );
+    }
+#endif
+    static TQUuid createUuid();
+    TQUuid::Variant variant() const;
+    TQUuid::Version version() const;
+
+    uint    data1;
+    ushort  data2;
+    ushort  data3;
+    uchar   data4[ 8 ];
+};
+
+#ifndef TQT_NO_DATASTREAM
+TQ_EXPORT TQDataStream &operator<<( TQDataStream &, const TQUuid & );
+TQ_EXPORT TQDataStream &operator>>( TQDataStream &, TQUuid & );
+#endif
+
+#endif //TQUUID_H
diff --git a/tqtinterface/qt4/src/tools/tqvaluelist.h b/tqtinterface/qt4/src/tools/tqvaluelist.h
new file mode 100644
index 0000000..67c2574
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqvaluelist.h
@@ -0,0 +1,671 @@
+/****************************************************************************
+**
+** Definition of TQValueList class
+**
+** Created : 990406
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQVALUELIST_H
+#define TQVALUELIST_H
+
+#ifndef TQT_H
+#include "tqtl.h"
+#include "tqshared.h"
+#include "tqdatastream.h"
+#endif // TQT_H
+
+#ifndef TQT_NO_STL
+#include <iterator>
+#include <list>
+#endif
+
+//#define TQT_CHECK_VALUELIST_RANGE
+
+#if defined(TQ_CC_MSVC)
+#pragma warning(disable:4284) // "return type for operator -> is not a UDT"
+#endif
+
+template <class T>
+class TQValueListNode
+{
+public:
+    TQValueListNode( const T& t ) : data( t ) { }
+    TQValueListNode() { }
+#if defined(TQ_TEMPLATEDLL)
+    // Workaround MS bug in memory de/allocation in DLL vs. EXE
+    virtual ~TQValueListNode() { }
+#endif
+
+    TQValueListNode<T>* next;
+    TQValueListNode<T>* prev;
+    T data;
+};
+
+template<class T>
+class TQValueListIterator
+{
+ public:
+    /**
+     * Typedefs
+     */
+    typedef TQValueListNode<T>* NodePtr;
+#ifndef TQT_NO_STL
+    typedef std::bidirectional_iterator_tag  iterator_category;
+#endif
+    typedef T        value_type;
+    typedef size_t size_type;
+#ifndef TQT_NO_STL
+    typedef ptrdiff_t  difference_type;
+#else
+    typedef int difference_type;
+#endif
+    typedef T*   pointer;
+    typedef T& reference;
+
+    /**
+     * Variables
+     */
+    NodePtr node;
+
+    /**
+     * Functions
+     */
+    TQValueListIterator() : node( 0 ) {}
+    TQValueListIterator( NodePtr p ) : node( p ) {}
+    TQValueListIterator( const TQValueListIterator<T>& it ) : node( it.node ) {}
+
+    bool operator==( const TQValueListIterator<T>& it ) const { return node == it.node; }
+    bool operator!=( const TQValueListIterator<T>& it ) const { return node != it.node; }
+    const T& operator*() const { return node->data; }
+    T& operator*() { return node->data; }
+    // UDT for T = x*
+    // T* operator->() const { return &node->data; }
+
+    TQValueListIterator<T>& operator++() {
+	node = node->next;
+	return *this;
+    }
+
+    TQValueListIterator<T> operator++(int) {
+	TQValueListIterator<T> tmp = *this;
+	node = node->next;
+	return tmp;
+    }
+
+    TQValueListIterator<T>& operator--() {
+	node = node->prev;
+	return *this;
+    }
+
+    TQValueListIterator<T> operator--(int) {
+	TQValueListIterator<T> tmp = *this;
+	node = node->prev;
+	return tmp;
+    }
+
+    TQValueListIterator<T>& operator+=( int j ) {
+	while ( j-- )
+	    node = node->next;
+	return *this;
+    }
+
+    TQValueListIterator<T>& operator-=( int j ) {
+	while ( j-- )
+	    node = node->prev;
+	return *this;
+    }
+
+};
+
+template<class T>
+class TQValueListConstIterator
+{
+ public:
+    /**
+     * Typedefs
+     */
+    typedef TQValueListNode<T>* NodePtr;
+#ifndef TQT_NO_STL
+    typedef std::bidirectional_iterator_tag  iterator_category;
+#endif
+    typedef T        value_type;
+    typedef size_t size_type;
+#ifndef TQT_NO_STL
+    typedef ptrdiff_t  difference_type;
+#else
+    typedef int difference_type;
+#endif
+    typedef const T*   pointer;
+    typedef const T& reference;
+
+    /**
+     * Variables
+     */
+    NodePtr node;
+
+    /**
+     * Functions
+     */
+    TQValueListConstIterator() : node( 0 ) {}
+    TQValueListConstIterator( NodePtr p ) : node( p ) {}
+    TQValueListConstIterator( const TQValueListConstIterator<T>& it ) : node( it.node ) {}
+    TQValueListConstIterator( const TQValueListIterator<T>& it ) : node( it.node ) {}
+
+    bool operator==( const TQValueListConstIterator<T>& it ) const { return node == it.node; }
+    bool operator!=( const TQValueListConstIterator<T>& it ) const { return node != it.node; }
+    const T& operator*() const { return node->data; }
+    // UDT for T = x*
+    // const T* operator->() const { return &node->data; }
+
+    TQValueListConstIterator<T>& operator++() {
+	node = node->next;
+	return *this;
+    }
+
+    TQValueListConstIterator<T> operator++(int) {
+	TQValueListConstIterator<T> tmp = *this;
+	node = node->next;
+	return tmp;
+    }
+
+    TQValueListConstIterator<T>& operator--() {
+	node = node->prev;
+	return *this;
+    }
+
+    TQValueListConstIterator<T> operator--(int) {
+	TQValueListConstIterator<T> tmp = *this;
+	node = node->prev;
+	return tmp;
+    }
+};
+
+template <class T>
+class TQValueListPrivate : public TQShared
+{
+public:
+    /**
+     * Typedefs
+     */
+    typedef TQValueListIterator<T> Iterator;
+    typedef TQValueListConstIterator<T> ConstIterator;
+    typedef TQValueListNode<T> Node;
+    typedef TQValueListNode<T>* NodePtr;
+    typedef size_t size_type;
+
+    /**
+     * Functions
+     */
+    TQValueListPrivate();
+    TQValueListPrivate( const TQValueListPrivate<T>& _p );
+
+    void derefAndDelete() // ### hack to get around hp-cc brain damage
+    {
+	if ( deref() )
+	    delete this;
+    }
+
+#if defined(TQ_TEMPLATEDLL)
+    // Workaround MS bug in memory de/allocation in DLL vs. EXE
+    virtual
+#endif
+    ~TQValueListPrivate();
+
+    Iterator insert( Iterator it, const T& x );
+    Iterator remove( Iterator it );
+    NodePtr tqfind( NodePtr start, const T& x ) const;
+    int tqfindIndex( NodePtr start, const T& x ) const;
+    uint tqcontains( const T& x ) const;
+    uint remove( const T& x );
+    NodePtr at( size_type i ) const;
+    void clear();
+
+    NodePtr node;
+    size_type nodes;
+};
+
+template <class T>
+TQ_INLINE_TEMPLATES TQValueListPrivate<T>::TQValueListPrivate()
+{
+    node = new Node; node->next = node->prev = node; nodes = 0;
+}
+
+template <class T>
+TQ_INLINE_TEMPLATES TQValueListPrivate<T>::TQValueListPrivate( const TQValueListPrivate<T>& _p )
+    : TQShared()
+{
+    node = new Node; node->next = node->prev = node; nodes = 0;
+    Iterator b( _p.node->next );
+    Iterator e( _p.node );
+    Iterator i( node );
+    while( b != e )
+	insert( i, *b++ );
+}
+
+template <class T>
+TQ_INLINE_TEMPLATES TQValueListPrivate<T>::~TQValueListPrivate() {
+    NodePtr p = node->next;
+    while( p != node ) {
+	NodePtr x = p->next;
+	delete p;
+	p = x;
+    }
+    delete node;
+}
+
+template <class T>
+TQ_INLINE_TEMPLATES TQ_TYPENAME TQValueListPrivate<T>::Iterator TQValueListPrivate<T>::insert( TQ_TYPENAME TQValueListPrivate<T>::Iterator it, const T& x )
+{
+    NodePtr p = new Node( x );
+    p->next = it.node;
+    p->prev = it.node->prev;
+    it.node->prev->next = p;
+    it.node->prev = p;
+    nodes++;
+    return p;
+}
+
+template <class T>
+TQ_INLINE_TEMPLATES TQ_TYPENAME TQValueListPrivate<T>::Iterator TQValueListPrivate<T>::remove( TQ_TYPENAME TQValueListPrivate<T>::Iterator it )
+{
+    TQ_ASSERT ( it.node != node );
+    NodePtr next = it.node->next;
+    NodePtr prev = it.node->prev;
+    prev->next = next;
+    next->prev = prev;
+    delete it.node;
+    nodes--;
+    return Iterator( next );
+}
+
+template <class T>
+TQ_INLINE_TEMPLATES TQ_TYPENAME TQValueListPrivate<T>::NodePtr TQValueListPrivate<T>::tqfind( TQ_TYPENAME TQValueListPrivate<T>::NodePtr start, const T& x ) const
+{
+    ConstIterator first( start );
+    ConstIterator last( node );
+    while( first != last) {
+	if ( *first == x )
+	    return first.node;
+	++first;
+    }
+    return last.node;
+}
+
+template <class T>
+TQ_INLINE_TEMPLATES int TQValueListPrivate<T>::tqfindIndex( TQ_TYPENAME TQValueListPrivate<T>::NodePtr start, const T& x ) const
+{
+    ConstIterator first( start );
+    ConstIterator last( node );
+    int pos = 0;
+    while( first != last) {
+	if ( *first == x )
+	    return pos;
+	++first;
+	++pos;
+    }
+    return -1;
+}
+
+template <class T>
+TQ_INLINE_TEMPLATES uint TQValueListPrivate<T>::tqcontains( const T& x ) const
+{
+    uint result = 0;
+    Iterator first = Iterator( node->next );
+    Iterator last = Iterator( node );
+    while( first != last) {
+	if ( *first == x )
+	    ++result;
+	++first;
+    }
+    return result;
+}
+
+template <class T>
+TQ_INLINE_TEMPLATES uint TQValueListPrivate<T>::remove( const T& _x )
+{
+    const T x = _x;
+    uint result = 0;
+    Iterator first = Iterator( node->next );
+    Iterator last = Iterator( node );
+    while( first != last) {
+	if ( *first == x ) {
+	    first = remove( first );
+	    ++result;
+	} else
+	    ++first;
+    }
+    return result;
+}
+
+template <class T>
+TQ_INLINE_TEMPLATES TQ_TYPENAME TQValueListPrivate<T>::NodePtr TQValueListPrivate<T>::at( size_type i ) const
+{
+    TQ_ASSERT( i <= nodes );
+    NodePtr p = node->next;
+    for( size_type x = 0; x < i; ++x )
+	p = p->next;
+    return p;
+}
+
+template <class T>
+TQ_INLINE_TEMPLATES void TQValueListPrivate<T>::clear()
+{
+    nodes = 0;
+    NodePtr p = node->next;
+    while( p != node ) {
+	NodePtr next = p->next;
+	delete p;
+	p = next;
+    }
+    node->next = node->prev = node;
+}
+
+#ifdef TQT_CHECK_RANGE
+# if !defined( TQT_NO_DEBUG ) && defined( TQT_CHECK_VALUELIST_RANGE )
+#  define TQT_CHECK_INVALID_LIST_ELEMENT if ( empty() ) qWarning( "TQValueList: Warning invalid element" )
+#  define TQT_CHECK_INVALID_LIST_ELEMENT_FATAL TQ_ASSERT( !empty() );
+# else
+#  define TQT_CHECK_INVALID_LIST_ELEMENT
+#  define TQT_CHECK_INVALID_LIST_ELEMENT_FATAL
+# endif
+#else
+# define TQT_CHECK_INVALID_LIST_ELEMENT
+# define TQT_CHECK_INVALID_LIST_ELEMENT_FATAL
+#endif
+
+template <class T> class TQDeepCopy;
+
+template <class T>
+class TQValueList
+{
+public:
+    /**
+     * Typedefs
+     */
+    typedef TQValueListIterator<T> iterator;
+    typedef TQValueListConstIterator<T> const_iterator;
+    typedef T value_type;
+    typedef value_type* pointer;
+    typedef const value_type* const_pointer;
+    typedef value_type& reference;
+    typedef const value_type& const_reference;
+    typedef size_t size_type;
+#ifndef TQT_NO_STL
+    typedef ptrdiff_t  difference_type;
+#else
+    typedef int difference_type;
+#endif
+
+    /**
+     * API
+     */
+    TQValueList() { sh = new TQValueListPrivate<T>; }
+    TQValueList( const TQValueList<T>& l ) { sh = l.sh; sh->ref(); }
+#ifndef TQT_NO_STL
+    TQValueList( const std::list<T>& l )
+    {
+	sh = new TQValueListPrivate<T>;
+	tqCopy( l.begin(), l.end(), std::back_inserter( *this ) );
+    }
+#endif
+    ~TQValueList() { sh->derefAndDelete(); }
+
+    TQValueList<T>& operator= ( const TQValueList<T>& l )
+    {
+	l.sh->ref();
+	sh->derefAndDelete();
+	sh = l.sh;
+	return *this;
+    }
+#ifndef TQT_NO_STL
+    TQValueList<T>& operator= ( const std::list<T>& l )
+    {
+	detach();
+	tqCopy( l.begin(), l.end(), std::back_inserter( *this ) );
+	return *this;
+    }
+    bool operator== ( const std::list<T>& l ) const
+    {
+	if ( size() != l.size() )
+	    return FALSE;
+	const_iterator it2 = begin();
+#if !defined(TQ_CC_MIPS)
+	typename
+#endif
+	std::list<T>::const_iterator it = l.begin();
+	for ( ; it2 != end(); ++it2, ++it )
+	if ( !((*it2) == (*it)) )
+	    return FALSE;
+	return TRUE;
+    }
+#endif
+    bool operator== ( const TQValueList<T>& l ) const;
+    bool operator!= ( const TQValueList<T>& l ) const { return !( *this == l ); }
+    iterator begin() { detach(); return iterator( sh->node->next ); }
+    const_iterator begin() const { return const_iterator( sh->node->next ); }
+    const_iterator constBegin() const { return const_iterator( sh->node->next ); }
+    iterator end() { detach(); return iterator( sh->node ); }
+    const_iterator end() const { return const_iterator( sh->node ); }
+    const_iterator constEnd() const { return const_iterator( sh->node ); }
+    iterator insert( iterator it, const T& x ) { detach(); return sh->insert( it, x ); }
+    uint remove( const T& x ) { detach(); return sh->remove( x ); }
+    void clear();
+
+    // ### 4.0: move out of class
+    TQValueList<T>& operator<< ( const T& x )
+    {
+	append( x );
+	return *this;
+    }
+
+    size_type size() const { return sh->nodes; }
+    bool empty() const { return sh->nodes == 0; }
+    void push_front( const T& x ) { detach(); sh->insert( begin(), x ); }
+    void push_back( const T& x ) { detach(); sh->insert( end(), x ); }
+    iterator erase( iterator pos ) { detach(); return sh->remove( pos ); }
+    iterator erase( iterator first, iterator last );
+    reference front() { TQT_CHECK_INVALID_LIST_ELEMENT_FATAL; return *begin(); }
+    const_reference front() const { TQT_CHECK_INVALID_LIST_ELEMENT_FATAL; return *begin(); }
+    reference back() { TQT_CHECK_INVALID_LIST_ELEMENT_FATAL; return *(--end()); }
+    const_reference back() const { TQT_CHECK_INVALID_LIST_ELEMENT_FATAL; return *(--end()); }
+    void pop_front() { TQT_CHECK_INVALID_LIST_ELEMENT; erase( begin() ); }
+    void pop_back() {
+	TQT_CHECK_INVALID_LIST_ELEMENT;
+	iterator tmp = end();
+	erase( --tmp );
+    }
+    void insert( iterator pos, size_type n, const T& x );
+    // Some compilers (incl. vc++) would instantiate this function even if
+    // it is not used; this would constrain TQValueList to classes that provide
+    // an operator<
+    /*
+    void sort()
+    {
+	qHeapSort( *this );
+    }
+    */
+
+    TQValueList<T> operator+ ( const TQValueList<T>& l ) const;
+    TQValueList<T>& operator+= ( const TQValueList<T>& l );
+
+    iterator fromLast() { detach(); return iterator( sh->node->prev ); }
+    const_iterator fromLast() const { return const_iterator( sh->node->prev ); }
+
+    bool isEmpty() const { return ( sh->nodes == 0 ); }
+
+    iterator append( const T& x ) { detach(); return sh->insert( end(), x ); }
+    iterator prepend( const T& x ) { detach(); return sh->insert( begin(), x ); }
+
+    iterator remove( iterator it ) { detach(); return sh->remove( it ); }
+
+    T& first() { TQT_CHECK_INVALID_LIST_ELEMENT; detach(); return sh->node->next->data; }
+    const T& first() const { TQT_CHECK_INVALID_LIST_ELEMENT; return sh->node->next->data; }
+    T& last() { TQT_CHECK_INVALID_LIST_ELEMENT; detach(); return sh->node->prev->data; }
+    const T& last() const { TQT_CHECK_INVALID_LIST_ELEMENT; return sh->node->prev->data; }
+
+    T& operator[] ( size_type i ) { TQT_CHECK_INVALID_LIST_ELEMENT; detach(); return sh->at(i)->data; }
+    const T& operator[] ( size_type i ) const { TQT_CHECK_INVALID_LIST_ELEMENT; return sh->at(i)->data; }
+    iterator at( size_type i ) { TQT_CHECK_INVALID_LIST_ELEMENT; detach(); return iterator( sh->at(i) ); }
+    const_iterator at( size_type i ) const { TQT_CHECK_INVALID_LIST_ELEMENT; return const_iterator( sh->at(i) ); }
+    iterator tqat( size_type i ) { TQT_CHECK_INVALID_LIST_ELEMENT; detach(); return iterator( sh->at(i) ); }
+    const_iterator tqat( size_type i ) const { TQT_CHECK_INVALID_LIST_ELEMENT; return const_iterator( sh->at(i) ); }
+    iterator tqfind ( const T& x ) { detach(); return iterator( sh->tqfind( sh->node->next, x) ); }
+    const_iterator tqfind ( const T& x ) const { return const_iterator( sh->tqfind( sh->node->next, x) ); }
+    iterator tqfind ( iterator it, const T& x ) { detach(); return iterator( sh->tqfind( it.node, x ) ); }
+    const_iterator tqfind ( const_iterator it, const T& x ) const { return const_iterator( sh->tqfind( it.node, x ) ); }
+    int tqfindIndex( const T& x ) const { return sh->tqfindIndex( sh->node->next, x) ; }
+    size_type tqcontains( const T& x ) const { return sh->tqcontains( x ); }
+
+    size_type count() const { return sh->nodes; }
+
+    TQValueList<T>& operator+= ( const T& x )
+    {
+	append( x );
+	return *this;
+    }
+    typedef TQValueListIterator<T> Iterator;
+    typedef TQValueListConstIterator<T> ConstIterator;
+    typedef T ValueType;
+
+protected:
+    /**
+     * Helpers
+     */
+    void detach() { if ( sh->count > 1 ) detachInternal(); }
+
+    /**
+     * Variables
+     */
+    TQValueListPrivate<T>* sh;
+
+private:
+    void detachInternal();
+
+    friend class TQDeepCopy< TQValueList<T> >;
+};
+
+template <class T>
+TQ_INLINE_TEMPLATES bool TQValueList<T>::operator== ( const TQValueList<T>& l ) const
+{
+    if ( size() != l.size() )
+	return FALSE;
+    const_iterator it2 = begin();
+    const_iterator it = l.begin();
+    for( ; it != l.end(); ++it, ++it2 )
+	if ( !( *it == *it2 ) )
+	    return FALSE;
+    return TRUE;
+}
+
+template <class T>
+TQ_INLINE_TEMPLATES void TQValueList<T>::clear()
+{
+    if ( sh->count == 1 ) sh->clear(); else { sh->deref(); sh = new TQValueListPrivate<T>; }
+}
+
+template <class T>
+TQ_INLINE_TEMPLATES TQ_TYPENAME TQValueList<T>::iterator TQValueList<T>::erase( TQ_TYPENAME TQValueList<T>::iterator first, TQ_TYPENAME TQValueList<T>::iterator last )
+{
+    while ( first != last )
+	erase( first++ );
+    return last;
+}
+
+
+template <class T>
+TQ_INLINE_TEMPLATES void TQValueList<T>::insert( TQ_TYPENAME TQValueList<T>::iterator pos, size_type n, const T& x )
+{
+    for ( ; n > 0; --n )
+	insert( pos, x );
+}
+
+template <class T>
+TQ_INLINE_TEMPLATES TQValueList<T> TQValueList<T>::operator+ ( const TQValueList<T>& l ) const
+{
+    TQValueList<T> l2( *this );
+    for( const_iterator it = l.begin(); it != l.end(); ++it )
+	l2.append( *it );
+    return l2;
+}
+
+template <class T>
+TQ_INLINE_TEMPLATES TQValueList<T>& TQValueList<T>::operator+= ( const TQValueList<T>& l )
+{
+    TQValueList<T> copy = l;
+    for( const_iterator it = copy.begin(); it != copy.end(); ++it )
+	append( *it );
+    return *this;
+}
+
+template <class T>
+TQ_INLINE_TEMPLATES void TQValueList<T>::detachInternal()
+{
+    sh->deref(); sh = new TQValueListPrivate<T>( *sh );
+}
+
+#ifndef TQT_NO_DATASTREAM
+template <class T>
+TQ_INLINE_TEMPLATES TQDataStream& operator>>( TQDataStream& s, TQValueList<T>& l )
+{
+    l.clear();
+    TQ_UINT32 c;
+    s >> c;
+    for( TQ_UINT32 i = 0; i < c; ++i )
+    {
+	T t;
+	s >> t;
+	l.append( t );
+	if ( s.atEnd() )
+	    break;
+    }
+    return s;
+}
+
+template <class T>
+TQ_INLINE_TEMPLATES TQDataStream& operator<<( TQDataStream& s, const TQValueList<T>& l )
+{
+    s << (TQ_UINT32)l.size();
+    TQValueListConstIterator<T> it = l.begin();
+    for( ; it != l.end(); ++it )
+	s << *it;
+    return s;
+}
+#endif // TQT_NO_DATASTREAM
+
+#define TQ_DEFINED_TQVALUELIST
+#define TQ_DEFINED_TQVALUELIST
+#include "tqwinexport.h"
+#endif // TQVALUELIST_H
diff --git a/tqtinterface/qt4/src/tools/tqvaluestack.h b/tqtinterface/qt4/src/tools/tqvaluestack.h
new file mode 100644
index 0000000..e19ed69
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqvaluestack.h
@@ -0,0 +1,67 @@
+/****************************************************************************
+**
+** Definition of TQValueStack class
+**
+** Created : 990925
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQVALUESTACK_H
+#define TQVALUESTACK_H
+
+#ifndef TQT_H
+#include "tqvaluelist.h"
+#endif // TQT_H
+
+
+template<class T>
+class TQValueStack : public TQValueList<T>
+{
+public:
+    TQValueStack() {}
+   ~TQValueStack() {}
+    void  push( const T& d ) { this->append(d); }
+    T pop()
+    {
+	T elem( this->last() );
+	if ( !this->isEmpty() )
+	    this->remove( this->fromLast() );
+	return elem;
+    }
+    T& top() { return this->last(); }
+    const T& top() const { return this->last(); }
+};
+
+#endif
diff --git a/tqtinterface/qt4/src/tools/tqvaluevector.h b/tqtinterface/qt4/src/tools/tqvaluevector.h
new file mode 100644
index 0000000..03ef9d2
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqvaluevector.h
@@ -0,0 +1,577 @@
+/****************************************************************************
+**
+** Definition of TQValueVector class
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQVALUEVECTOR_H
+#define TQVALUEVECTOR_H
+
+#ifndef TQT_H
+#include "tqtl.h"
+#include "tqshared.h"
+#include "tqdatastream.h"
+#endif // TQT_H
+
+#ifndef TQT_NO_STL
+#include <vector>
+#endif
+
+template <class T>
+class TQValueVectorPrivate : public TQShared
+{
+public:
+    typedef T value_type;
+    typedef T* pointer;
+
+    TQValueVectorPrivate()
+	: start( 0 ), finish( 0 ), end( 0 )
+    {
+    }
+
+    TQValueVectorPrivate( const TQValueVectorPrivate<T>& x );
+    TQValueVectorPrivate( size_t size );
+
+    void derefAndDelete() // work-around for hp-cc
+    {
+	if ( deref() )
+	    delete this;
+    }
+
+#if defined(TQ_TEMPLATEDLL)
+    // Workaround MS bug in memory de/allocation in DLL vs. EXE
+    virtual
+#endif
+    ~TQValueVectorPrivate()
+    {
+	delete[] start;
+    }
+
+    size_t size() const
+    {
+	return finish - start;
+    }
+
+    bool empty() const
+    {
+	return start == finish;
+    }
+
+    size_t capacity() const
+    {
+	return end - start;
+    }
+
+    void insert( pointer pos, const T& x );
+    void insert( pointer pos, size_t n, const T& x );
+    void reserve( size_t n );
+
+    void clear()
+    {
+	delete[] start;
+	start = 0;
+	finish = 0;
+	end = 0;
+    }
+
+
+    pointer start;
+    pointer finish;
+    pointer end;
+
+private:
+    pointer growAndCopy( size_t n, pointer s, pointer f );
+
+    TQValueVectorPrivate<T>& operator=( const TQValueVectorPrivate<T>& x );
+
+};
+
+template <class T>
+TQ_INLINE_TEMPLATES TQValueVectorPrivate<T>::TQValueVectorPrivate( const TQValueVectorPrivate<T>& x )
+    : TQShared()
+{
+    size_t i = x.size();
+    if ( i > 0 ) {
+	start = new T[ i ];
+	finish = start + i;
+	end = start + i;
+#if defined(__xlC__) && __xlC__ < 0x400 // xlC 3.6 confused by const
+	tqCopy( (pointer)x.start, (pointer)x.finish, start );
+#else
+	tqCopy( x.start, x.finish, start );
+#endif
+    } else {
+	start = 0;
+	finish = 0;
+	end = 0;
+    }
+}
+
+template <class T>
+TQ_INLINE_TEMPLATES TQValueVectorPrivate<T>::TQValueVectorPrivate( size_t size )
+{
+    if ( size > 0 ) {
+	start = new T[size];
+	finish = start + size;
+	end = start + size;
+    } else {
+	start = 0;
+	finish = 0;
+	end = 0;
+    }
+}
+
+template <class T>
+TQ_INLINE_TEMPLATES void TQValueVectorPrivate<T>::insert( pointer pos, const T& x )
+{
+    const size_t lastSize = size();
+    const size_t n = lastSize !=0 ? 2*lastSize : 1;
+    const size_t offset = pos - start;
+    pointer newStart = new T[n];
+    pointer newFinish = newStart + offset;
+    tqCopy( start, pos, newStart );
+    *newFinish = x;
+    tqCopy( pos, finish, ++newFinish );
+    delete[] start;
+    start = newStart;
+    finish = newStart + lastSize + 1;
+    end = newStart + n;
+}
+
+template <class T>
+TQ_INLINE_TEMPLATES void TQValueVectorPrivate<T>::insert( pointer pos, size_t n, const T& x )
+{
+    if ( size_t( end - finish ) >= n ) {
+	// enough room
+	const size_t elems_after = finish - pos;
+	pointer old_finish = finish;
+	if ( elems_after > n ) {
+	    tqCopy( finish - n, finish, finish );
+	    finish += n;
+	    tqCopyBackward( pos, old_finish - n, old_finish );
+	    tqFill( pos, pos + n, x );
+	} else {
+	    pointer filler = finish;
+	    size_t i = n - elems_after;
+	    for ( ; i > 0; --i, ++filler )
+		*filler = x;
+	    finish += n - elems_after;
+	    tqCopy( pos, old_finish, finish );
+	    finish += elems_after;
+	    tqFill( pos, old_finish, x );
+	}
+    } else {
+	// not enough room
+	const size_t lastSize = size();
+	const size_t len = lastSize + TQMAX( lastSize, n );
+	pointer newStart = new T[len];
+	pointer newFinish = tqCopy( start, pos, newStart );
+	// fill up inserted space
+	size_t i = n;
+	for ( ; i > 0; --i, ++newFinish )
+	    *newFinish = x;
+	newFinish = tqCopy( pos, finish, newFinish );
+	delete[] start;
+	start = newStart;
+	finish = newFinish;
+	end = newStart + len;
+    }
+}
+
+template <class T>
+TQ_INLINE_TEMPLATES void TQValueVectorPrivate<T>::reserve( size_t n )
+{
+    const size_t lastSize = size();
+    pointer tmp = growAndCopy( n, start, finish );
+    start = tmp;
+    finish = tmp + lastSize;
+    end = start + n;
+}
+
+template <class T>
+TQ_INLINE_TEMPLATES TQ_TYPENAME TQValueVectorPrivate<T>::pointer TQValueVectorPrivate<T>::growAndCopy( size_t n, pointer s, pointer f )
+{
+    pointer newStart = new T[n];
+    tqCopy( s, f, newStart );
+    delete[] start;
+    return newStart;
+}
+
+template <class T> class TQDeepCopy;
+
+template <class T>
+class TQValueVector
+{
+public:
+    typedef T value_type;
+    typedef value_type* pointer;
+    typedef const value_type* const_pointer;
+    typedef value_type* iterator;
+    typedef const value_type* const_iterator;
+    typedef value_type& reference;
+    typedef const value_type& const_reference;
+    typedef size_t size_type;
+#ifndef TQT_NO_STL
+    typedef ptrdiff_t difference_type;
+#else
+    typedef int difference_type;
+#endif
+
+    TQValueVector()
+    {
+	sh = new TQValueVectorPrivate<T>;
+    }
+
+    TQValueVector( const TQValueVector<T>& v )
+    {
+	sh = v.sh;
+	sh->ref();
+    }
+
+    TQValueVector( size_type n, const T& val = T() );
+
+#ifndef TQT_NO_STL
+    TQValueVector( std::vector<T>& v ) // ### remove in 4.0
+    {
+	sh = new TQValueVectorPrivate<T>( v.size() );
+	tqCopy( v.begin(), v.end(), begin() );
+    }
+
+    TQValueVector( const std::vector<T>& v )
+    {
+	sh = new TQValueVectorPrivate<T>( v.size() );
+	tqCopy( v.begin(), v.end(), begin() );
+    }
+#endif
+
+    ~TQValueVector()
+    {
+	sh->derefAndDelete();
+    }
+
+    TQValueVector<T>& operator= ( const TQValueVector<T>& v )
+    {
+	v.sh->ref();
+	sh->derefAndDelete();
+	sh = v.sh;
+	return *this;
+    }
+
+#ifndef TQT_NO_STL
+    TQValueVector<T>& operator= ( const std::vector<T>& v )
+    {
+	clear();
+	resize( v.size() );
+	tqCopy( v.begin(), v.end(), begin() );
+	return *this;
+    }
+#endif
+
+    size_type size() const { return sh->size(); }
+
+    bool empty() const { return sh->empty(); }
+
+    size_type capacity() const
+    {
+	return size_type( sh->capacity() );
+    }
+
+    iterator begin()
+    {
+	detach();
+	return sh->start;
+    }
+
+    const_iterator begin() const
+    {
+	return sh->start;
+    }
+
+    const_iterator constBegin() const
+    {
+	return sh->start;
+    }
+
+    iterator end()
+    {
+	detach();
+	return sh->finish;
+    }
+
+    const_iterator end() const
+    {
+	return sh->finish;
+    }
+
+    const_iterator constEnd() const
+    {
+	return sh->finish;
+    }
+
+    reference at( size_type i, bool* ok = 0 )
+    {
+	detach();
+	if ( ok )
+	    *ok = ( i < size() );
+	return *( begin() + i );
+    }
+    reference tqat( size_type i, bool* ok = 0 ) { return at(i, ok); }
+
+    const_reference at( size_type i, bool* ok = 0 ) const
+    {
+	if ( ok )
+	    *ok = ( i < size() );
+	return *( begin() + i );
+    }
+    const_reference tqat( size_type i, bool* ok = 0 ) const { return at(i, ok); }
+
+    reference operator[]( size_type i )
+    {
+	detach();
+	return *( begin() + i );
+    }
+
+    const_reference operator[]( size_type i ) const
+    {
+	return *( begin() + i );
+    }
+
+    reference front()
+    {
+	TQ_ASSERT( !empty() );
+	detach();
+	return *begin();
+    }
+
+    const_reference front() const
+    {
+	TQ_ASSERT( !empty() );
+	return *begin();
+    }
+
+    reference back()
+    {
+	TQ_ASSERT( !empty() );
+	detach();
+	return *( end() - 1 );
+    }
+
+    const_reference back() const
+    {
+	TQ_ASSERT( !empty() );
+	return *( end() - 1 );
+    }
+
+    void push_back( const T& x )
+    {
+	detach();
+	if ( sh->finish == sh->end ) {
+	    sh->reserve( size()+size()/2+1 );
+	}
+	*sh->finish = x;
+	++sh->finish;
+    }
+
+    void pop_back()
+    {
+	detach();
+	if ( empty() )
+	    return;
+	--sh->finish;
+    }
+
+    iterator insert( iterator pos, const T& x );
+    iterator insert( iterator pos, size_type n, const T& x );
+
+    void reserve( size_type n )
+    {
+	if ( capacity() < n ) {
+	    detach();
+	    sh->reserve( n );
+	}
+    }
+
+    void resize( size_type n, const T& val = T() )
+    {
+	if ( n < size() )
+	    erase( begin() + n, end() );
+	else
+	    insert( end(), n - size(), val );
+    }
+
+    void clear()
+    {
+	detach();
+	sh->clear();
+    }
+
+    iterator erase( iterator pos )
+    {
+	detach();
+	if ( pos + 1 != end() )
+	    tqCopy( pos + 1, sh->finish, pos );
+	--sh->finish;
+	return pos;
+    }
+
+    iterator erase( iterator first, iterator last )
+    {
+	detach();
+	tqCopy( last, sh->finish, first );
+	sh->finish = sh->finish - ( last - first );
+	return first;
+    }
+
+    // ### remove in TQt 4.0
+    bool operator==( const TQValueVector<T>& x )
+    {
+	return size()==x.size() ? tqEqual( constBegin(), constEnd(), x.begin()) : FALSE;
+    }
+
+    bool operator==( const TQValueVector<T>& x ) const
+    {
+	return size()==x.size() ? tqEqual( begin(), end(), x.begin() ) : FALSE;
+    }
+
+    typedef T ValueType;
+    typedef ValueType *Iterator;
+    typedef const ValueType *ConstIterator;
+
+    size_type count() const { return size(); }
+    bool isEmpty() const { return empty(); }
+
+    reference first() { return front(); }
+    const_reference first() const { return front(); }
+    reference last() { return back(); }
+    const_reference last() const { return back(); }
+    void append( const T& x ) { push_back( x ); }
+
+protected:
+    void detach()
+    {
+	if ( sh->count > 1 ) { detachInternal(); }
+    }
+    void detachInternal();
+    TQValueVectorPrivate<T>* sh;
+
+private:
+    friend class TQDeepCopy< TQValueVector<T> >;
+};
+
+template <class T>
+TQ_INLINE_TEMPLATES TQValueVector<T>::TQValueVector( size_type n, const T& val )
+{
+    sh = new TQValueVectorPrivate<T>( n );
+    tqFill( begin(), end(), val );
+}
+
+template <class T>
+TQ_INLINE_TEMPLATES void TQValueVector<T>::detachInternal()
+{
+    sh->deref();
+    sh = new TQValueVectorPrivate<T>( *sh );
+}
+
+template <class T>
+TQ_INLINE_TEMPLATES TQ_TYPENAME TQValueVector<T>::iterator TQValueVector<T>::insert( iterator pos, const T& x )
+{
+    size_type offset = pos - sh->start;
+    detach();
+    if ( pos == end() ) {
+	if ( sh->finish == sh->end )
+	    push_back( x );
+	else {
+	    *sh->finish = x;
+	    ++sh->finish;
+	}
+    } else {
+	if ( sh->finish == sh->end ) {
+	    sh->insert( pos, x );
+	} else {
+	    *sh->finish = *(sh->finish - 1);
+	    ++sh->finish;
+	    tqCopyBackward( pos, sh->finish - 2, sh->finish - 1 );
+	    *pos = x;
+	}
+    }
+    return begin() + offset;
+}
+
+template <class T>
+TQ_INLINE_TEMPLATES TQ_TYPENAME TQValueVector<T>::iterator TQValueVector<T>::insert( iterator pos, size_type n, const T& x )
+{
+    if ( n != 0 ) {
+	size_type offset = pos - sh->start;
+	detach();
+	pos = begin() + offset;
+	sh->insert( pos, n, x );
+    }
+    return pos;
+}
+
+
+#ifndef TQT_NO_DATASTREAM
+template<class T>
+TQ_INLINE_TEMPLATES TQDataStream& operator>>( TQDataStream& s, TQValueVector<T>& v )
+{
+    v.clear();
+    TQ_UINT32 c;
+    s >> c;
+    v.resize( c );
+    for( TQ_UINT32 i = 0; i < c; ++i )
+    {
+	T t;
+	s >> t;
+	v[i] = t;
+    }
+    return s;
+}
+
+template<class T>
+TQ_INLINE_TEMPLATES TQDataStream& operator<<( TQDataStream& s, const TQValueVector<T>& v )
+{
+    s << (TQ_UINT32)v.size();
+    // ### use typename TQValueVector<T>::const_iterator once all supported
+    // ### compilers know about the 'typename' keyword.
+    const T* it = v.begin();
+    for( ; it != v.end(); ++it )
+	s << *it;
+    return s;
+}
+#endif // TQT_NO_DATASTREAM
+
+#define TQ_DEFINED_TQVALUEVECTOR
+#include "tqwinexport.h"
+#endif // TQVALUEVECTOR_H
diff --git a/tqtinterface/qt4/src/tools/tqwaitcondition.h b/tqtinterface/qt4/src/tools/tqwaitcondition.h
new file mode 100644
index 0000000..a3966a2
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqwaitcondition.h
@@ -0,0 +1,79 @@
+/****************************************************************************
+**
+** Definition of TQWaitCondition class
+**
+** Created : 931107
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQWAITCONDITION_H
+#define TQWAITCONDITION_H
+
+#ifndef TQT_H
+#include "tqglobal.h"
+#endif // TQT_H
+
+#if defined(TQT_THREAD_SUPPORT)
+
+#include <limits.h>
+
+class TQWaitConditionPrivate;
+class TQMutex;
+
+class TQ_EXPORT TQWaitCondition
+{
+public:
+    TQWaitCondition();
+    virtual ~TQWaitCondition();
+
+    // default argument causes thread to block indefinately
+    bool wait( unsigned long time = ULONG_MAX );
+    bool wait( TQMutex *mutex, unsigned long time = ULONG_MAX );
+
+    void wakeOne();
+    void wakeAll();
+
+private:
+    TQWaitConditionPrivate * d;
+
+#if defined(TQ_DISABLE_COPY)
+    TQWaitCondition( const TQWaitCondition & );
+    TQWaitCondition &operator=( const TQWaitCondition & );
+#endif
+};
+
+#endif
+
+#endif
diff --git a/tqtinterface/qt4/src/tools/tqwaitcondition_unix.cpp b/tqtinterface/qt4/src/tools/tqwaitcondition_unix.cpp
new file mode 100644
index 0000000..89ce471
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqwaitcondition_unix.cpp
@@ -0,0 +1,316 @@
+/****************************************************************************
+**
+** TQWaitCondition class for Unix
+**
+** Created : 20010725
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#if defined(TQT_THREAD_SUPPORT)
+
+#include "tqplatformdefs.h"
+
+typedef pthread_mutex_t TQ_MUTEX_T;
+
+#include "tqwaitcondition.h"
+#include "tqmutex.h"
+#include "tqmutex_p.h"
+
+#include <errno.h>
+#include <string.h>
+
+
+struct TQWaitConditionPrivate {
+    pthread_cond_t cond;
+};
+
+
+/*!
+    \class TQWaitCondition tqwaitcondition.h
+    \threadsafe
+    \brief The TQWaitCondition class allows waiting/waking for conditions between threads.
+
+    \ingroup thread
+    \ingroup environment
+
+    TQWaitConditions allow a thread to tell other threads that some
+    sort of condition has been met; one or many threads can block
+    waiting for a TQWaitCondition to set a condition with wakeOne() or
+    wakeAll(). Use wakeOne() to wake one randomly selected event or
+    wakeAll() to wake them all. For example, say we have three tasks
+    that should be performed every time the user presses a key; each
+    task could be split into a thread, each of which would have a
+    run() body like this:
+
+    \code
+    TQWaitCondition key_pressed;
+
+    for (;;) {
+	key_pressed.wait(); // This is a TQWaitCondition global variable
+	// Key was pressed, do something interesting
+	do_something();
+    }
+    \endcode
+
+    A fourth thread would read key presses and wake the other three
+    threads up every time it receives one, like this:
+
+    \code
+    TQWaitCondition key_pressed;
+
+    for (;;) {
+	getchar();
+	// Causes any thread in key_pressed.wait() to return from
+	// that method and continue processing
+	key_pressed.wakeAll();
+    }
+    \endcode
+
+    Note that the order the three threads are woken up in is
+    undefined, and that if some or all of the threads are still in
+    do_something() when the key is pressed, they won't be woken up
+    (since they're not waiting on the condition variable) and so the
+    task will not be performed for that key press. This can be
+    avoided by, for example, doing something like this:
+
+    \code
+    TQMutex mymutex;
+    TQWaitCondition key_pressed;
+    int mycount=0;
+
+    // Worker thread code
+    for (;;) {
+	key_pressed.wait(); // This is a TQWaitCondition global variable
+	mymutex.lock();
+	mycount++;
+	mymutex.unlock();
+	do_something();
+	mymutex.lock();
+	mycount--;
+	mymutex.unlock();
+    }
+
+    // Key reading thread code
+    for (;;) {
+	getchar();
+	mymutex.lock();
+	// Sleep until there are no busy worker threads
+	while( mycount > 0 ) {
+	    mymutex.unlock();
+	    sleep( 1 );
+	    mymutex.lock();
+	}
+	mymutex.unlock();
+	key_pressed.wakeAll();
+    }
+    \endcode
+
+    The mutexes are necessary because the results of two threads
+    attempting to change the value of the same variable simultaneously
+    are unpredictable.
+*/
+
+/*!
+    Constructs a new event signalling, i.e. wait condition, object.
+*/
+TQWaitCondition::TQWaitCondition()
+{
+    d = new TQWaitConditionPrivate;
+
+    int ret = pthread_cond_init(&d->cond, NULL);
+
+#ifdef TQT_CHECK_RANGE
+    if (ret)
+	qWarning( "Wait condition init failure: %s", strerror( ret ) );
+#endif
+}
+
+
+/*!
+    Deletes the event signalling, i.e. wait condition, object.
+*/
+TQWaitCondition::~TQWaitCondition()
+{
+    int ret = pthread_cond_destroy(&d->cond);
+
+    if (ret) {
+#ifdef TQT_CHECK_RANGE
+	qWarning( "Wait condition destroy failure: %s", strerror( ret ) );
+#endif
+
+	// seems we have threads waiting on us, lets wake them up
+	pthread_cond_broadcast(&d->cond);
+    }
+
+    delete d;
+}
+
+/*!
+    This wakes one thread waiting on the TQWaitCondition. The thread
+    that is woken up depends on the operating system's scheduling
+    policies, and cannot be controlled or predicted.
+
+    \sa wakeAll()
+*/
+void TQWaitCondition::wakeOne()
+{
+    int ret = pthread_cond_signal(&d->cond);
+
+#ifdef TQT_CHECK_RANGE
+    if (ret)
+	qWarning("Wait condition wakeOne failure: %s", strerror(ret));
+#endif
+}
+
+/*!
+    This wakes all threads waiting on the TQWaitCondition. The order in
+    which the threads are woken up depends on the operating system's
+    scheduling policies, and cannot be controlled or predicted.
+
+    \sa wakeOne()
+*/
+void TQWaitCondition::wakeAll()
+{
+    int ret = pthread_cond_broadcast(&d->cond);
+
+#ifdef TQT_CHECK_RANGE
+    if (ret)
+	qWarning("Wait condition wakeAll failure: %s", strerror(ret));
+#endif
+}
+
+/*!
+    Wait on the thread event object. The thread calling this will
+    block until either of these conditions is met:
+    \list
+    \i Another thread Q_SIGNALS it using wakeOne() or wakeAll(). This
+       function will return TRUE in this case.
+    \i \a time milliseconds has elapsed. If \a time is ULONG_MAX (the
+       default), then the wait will never timeout (the event must be
+       signalled). This function will return FALSE if the wait timed
+       out.
+    \endlist
+
+    \sa wakeOne(), wakeAll()
+*/
+bool TQWaitCondition::wait(unsigned long time)
+{
+    static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+    pthread_mutex_lock( &mutex );
+
+    int ret;
+    if (time != ULONG_MAX) {
+	struct timeval tv;
+	gettimeofday(&tv, 0);
+
+	timespec ti;
+	ti.tv_nsec = ( tv.tv_usec + ( time % 1000 ) * 1000 ) * 1000;
+	ti.tv_sec = tv.tv_sec + (time / 1000) + ( ti.tv_nsec / 1000000000 );
+	ti.tv_nsec %= 1000000000;
+
+	ret = pthread_cond_timedwait(&d->cond, &mutex, &ti);
+    } else
+	ret = pthread_cond_wait(&d->cond, &mutex);
+
+#ifdef TQT_CHECK_RANGE
+    if (ret && ret != ETIMEDOUT)
+	qWarning("Wait condition wait failure: %s",strerror(ret));
+#endif
+
+    pthread_mutex_unlock( &mutex );
+
+    return (ret == 0);
+}
+
+/*!
+    \overload
+
+    Release the locked \a mutex and wait on the thread event object.
+    The \a mutex must be initially locked by the calling thread. If \a
+    mutex is not in a locked state, this function returns immediately.
+    If \a mutex is a recursive mutex, this function returns
+    immediately. The \a mutex will be unlocked, and the calling thread
+    will block until either of these conditions is met:
+    \list
+    \i Another thread Q_SIGNALS it using wakeOne() or wakeAll(). This
+       function will return TRUE in this case.
+    \i \a time milliseconds has elapsed. If \a time is ULONG_MAX (the
+       default), then the wait will never timeout (the event must be
+       signalled). This function will return FALSE if the wait timed
+       out.
+    \endlist
+
+    The mutex will be returned to the same locked state. This function
+    is provided to allow the atomic transition from the locked state
+    to the wait state.
+
+    \sa wakeOne(), wakeAll()
+*/
+bool TQWaitCondition::wait(TQMutex *mutex, unsigned long time)
+{
+    if (! mutex)
+	return FALSE;
+
+    if (mutex->d->type() == TQ_MUTEX_RECURSIVE) {
+#ifdef TQT_CHECK_RANGE
+	qWarning("Wait condition warning: using recursive mutexes with\n"
+		 "                        wait conditions is undefined!");
+#endif
+	return FALSE;
+    }
+
+    int ret;
+    if (time != ULONG_MAX) {
+	struct timeval tv;
+	gettimeofday(&tv, 0);
+
+	timespec ti;
+	ti.tv_nsec = ( tv.tv_usec + ( time % 1000 ) * 1000 ) * 1000;
+	ti.tv_sec = tv.tv_sec + (time / 1000) + ( ti.tv_nsec / 1000000000 );
+	ti.tv_nsec %= 1000000000;
+
+	ret = pthread_cond_timedwait(&d->cond, &mutex->d->handle, &ti);
+    } else
+	ret = pthread_cond_wait(&d->cond, &mutex->d->handle);
+
+#ifdef TQT_CHECK_RANGE
+    if (ret && ret != ETIMEDOUT)
+	qWarning("Wait condition wait failure: %s",strerror(ret));
+#endif
+
+    return (ret == 0);
+}
+
+#endif // TQT_THREAD_SUPPORT
diff --git a/tqtinterface/qt4/src/tools/tqwinexport.cpp b/tqtinterface/qt4/src/tools/tqwinexport.cpp
new file mode 100644
index 0000000..8fd0b31
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqwinexport.cpp
@@ -0,0 +1,31 @@
+#define TQ_EXPORT_TEMPLATES
+
+#include <tqcanvas.h>
+#include <tqaccessible.h>
+#include <tqconnection.h>
+#include <tqguardedptr.h>
+#include <tqobject.h>
+#include <tqpoint.h>
+#include <tqrect.h>
+#include <tqsignalslotimp.h>
+#include <tqwidget.h>
+#include <tqhttp.h>
+#include <private/tqsqlextension_p.h>
+#include <tqsqlindex.h>
+#include <tqtable.h>
+#include <tqtable.h>
+#include <tqtable.h>
+#include <tqasciidict.h>
+#include <tqcstring.h>
+#include <tqdict.h>
+#include <tqintdict.h>
+#include <tqlibrary.h>
+#include <tqmap.h>
+#include <tqmemarray.h>
+#include <tqptrlist.h>
+#include <tqptrvector.h>
+#include <tqstring.h>
+#include <tqvaluelist.h>
+#include <tqvaluevector.h>
+#include <tqdockarea.h>
+#include <tqdockwindow.h>
diff --git a/tqtinterface/qt4/src/tools/tqwinexport.h b/tqtinterface/qt4/src/tools/tqwinexport.h
new file mode 100644
index 0000000..0b40e59
--- /dev/null
+++ b/tqtinterface/qt4/src/tools/tqwinexport.h
@@ -0,0 +1,224 @@
+/****************************************************************************
+**
+** Global type declarations and definitions
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#if defined(TQ_TEMPLATEDLL) && ( !defined(TQ_CC_BOR) || !defined(TQT_MAKEDLL) || defined(TQ_EXPORT_TEMPLATES) )
+// TQMOC_SKIP_BEGIN
+
+#if defined(TQ_DEFINED_TQASCIIDICT) && defined(TQ_DEFINED_TQCONNECTION_LIST) && !defined(TQ_EXPORTED_TQASCIIDICT_TEMPLATES)
+#define TQ_EXPORTED_TQASCIIDICT_TEMPLATES
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQAsciiDictIterator<TQConnectionList>;
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQAsciiDict<TQConnectionList>;
+#endif
+
+#if defined(TQ_DEFINED_TQSTYLESHEET) && defined(TQ_DEFINED_TQDICT) && !defined(TQ_EXPORTED_TQSTYLESHEET_TEMPLATES)
+#define TQ_EXPORTED_TQSTYLESHEET_TEMPLATES
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQDict<TQStyleSheetItem>;
+#endif
+
+#if defined(TQ_DEFINED_TQLIBRARY) && defined(TQ_DEFINED_TQDICT) && !defined(TQ_EXPORTED_TQDICTLIBRARY_TEMPLATES)
+#define TQ_EXPORTED_TQDICTLIBRARY_TEMPLATES
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQDict<TQLibrary>; // for TQtopia
+#endif
+
+#if defined(TQ_DEFINED_TQGUARDEDPTR) && defined(TQ_DEFINED_TQOBJECT) && !defined(TQ_EXPORTED_TQGUARDEDPTROBJECT_TEMPLATES)
+#define TQ_EXPORTED_TQGUARDEDPTROBJECT_TEMPLATES
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQGuardedPtr<TQObject>;
+#endif
+
+// needed for TQtopia
+#if defined(TQ_DEFINED_TQGUARDEDPTR) && defined(TQ_DEFINED_TQWIDGET) && !defined(TQ_EXPORTED_TQGUARDEDPTRTQWIDGET_TEMPLATES)
+#define TQ_EXPORTED_TQGUARDEDPTRTQWIDGET_TEMPLATES
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQGuardedPtr<TQWidget>;
+#endif
+
+#if defined(TQ_DEFINED_TQGUARDEDPTR) && defined(TQ_DEFINED_TQACCESSIBLE_OBJECT) && !defined(TQ_EXPORTED_TQACCESSIBLEOBJECT_TEMPLATES)
+#define TQ_EXPORTED_TQACCESSIBLEOBJECT_TEMPLATES
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQGuardedPtr<TQAccessibleObject>;
+#endif
+
+#if defined(TQ_DEFINED_TQINTDICT) && !defined(TQ_EXPORTED_TQINTDICT_TEMPLATES)
+#define TQ_EXPORTED_TQINTDICT_TEMPLATES
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQIntDict<int>;
+#endif
+
+#if defined(TQ_DEFINED_TQINTDICT) && defined(TQ_DEFINED_TQWIDGET) && !defined(TQ_EXPORTED__TEMPLATES)
+#define TQ_EXPORTED__TEMPLATES
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQIntDictIterator<TQWidget>;
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQIntDict<TQWidget>;
+#endif
+
+#if defined(TQ_DEFINED_TQMAP) && !defined(TQ_EXPORTED_TQMAPBASIC_TEMPLATES)
+#define TQ_EXPORTED_TQMAPBASIC_TEMPLATES
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQMap<int, int>; // for TQtopia
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQMap<int, bool>; // for TQtopia
+#endif
+
+#if defined(TQ_DEFINED_TQMAP) && defined(TQ_DEFINED_TQSTRING) && !defined(TQ_EXPORTED_TQMAPTQSTRING_TEMPLATES)
+#define TQ_EXPORTED_TQMAPTQSTRING_TEMPLATES
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQMap<TQString, TQString>;
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQMap<TQString, int>; // for TQtopia
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQMap<int, TQString>; // for TQtopia
+#endif
+
+#if defined(TQ_DEFINED_TQMEMARRAY)  && !defined(TQ_EXPORTED_TQMEMARRAY_BASIC_TEMPLATES)
+#define TQ_EXPORTED_TQMEMARRAY_BASIC_TEMPLATES
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQMemArray<int>;
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQMemArray<bool>;
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQMemArray<char>;
+#endif
+
+#if defined(TQ_DEFINED_TQMEMARRAY) && defined(TQ_DEFINED_TQPOINT)  && !defined(TQ_EXPORTED_TQMEMARAYPOINT_TEMPLATES)
+#define TQ_EXPORTED_TQMEMARAYPOINT_TEMPLATES
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQMemArray<TQPoint>;
+#endif
+
+#if defined(TQ_DEFINED_TQPTRLIST)  && !defined(TQ_EXPORTED_TQPTRLIST_BASIC_TEMPLATES)
+#define TQ_EXPORTED_TQPTRLIST_BASIC_TEMPLATES
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQPtrListIterator<char>;
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQPtrList<char>;
+#endif
+
+#if defined(TQ_DEFINED_TQPTRLIST) && defined(TQ_DEFINED_TQWIDGET)  && !defined(TQ_EXPORTED_TQPTRLISTWIDGET_TEMPLATES)
+#define TQ_EXPORTED_TQPTRLISTWIDGET_TEMPLATES
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQPtrListIterator<TQWidget>;
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQPtrList<TQWidget>;
+#endif
+
+#if defined(TQ_DEFINED_TQPTRLIST) && defined(TQ_DEFINED_TQCONNECTION)  && !defined(TQ_EXPORTED_TQPTRLISTCONNECTION_TEMPLATES)
+#define TQ_EXPORTED_TQPTRLISTCONNECTION_TEMPLATES
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQPtrListIterator<TQConnection>;
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQPtrList<TQConnection>;
+#endif
+
+#if defined(TQ_DEFINED_TQPTRLIST) && defined(TQ_DEFINED_TQOBJECT)  && !defined(TQ_EXPORTED_TQPTRLISTOBJECT_TEMPLATES)
+#define TQ_EXPORTED_TQPTRLISTOBJECT_TEMPLATES
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQPtrListIterator<TQObject>;
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQPtrList<TQObject>;
+#endif
+
+#if defined(TQ_DEFINED_TQPTRLIST) && defined(TQ_DEFINED_TQDOCKWINDOW)  && !defined(TQ_EXPORTED_TQPTRLISTDOCWINDOW_TEMPLATES)
+#define TQ_EXPORTED_TQPTRLISTDOCWINDOW_TEMPLATES
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQPtrListIterator<TQDockWindow>;
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQPtrList<TQDockWindow>;
+#endif
+
+#if defined(TQ_DEFINED_TQPTRVECTOR)  && !defined(TQ_EXPORTED_TQPTRVECTOR_BASIC_TEMPLATES)
+#define TQ_EXPORTED_TQPTRVECTOR_BASIC_TEMPLATES
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQPtrVector<int>;
+#endif
+
+#if defined(TQ_DEFINED_TQPTRVECTOR) && defined(TQ_DEFINED_TQSTYLESHEET)  && !defined(TQ_EXPORTED_TQPTRVECTORSTYLESHEETITEM_TEMPLATES)
+#define TQ_EXPORTED_TQPTRVECTORSTYLESHEETITEM_TEMPLATES
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQPtrVector<TQStyleSheetItem>;
+#endif
+
+#if defined(TQ_DEFINED_TQPTRVECTOR) && defined(TQ_DEFINED_TQWIDGET)  && !defined(TQ_EXPORTED_TQPTRVECTORWIDGET_TEMPLATES)
+#define TQ_EXPORTED_TQPTRVECTORWIDGET_TEMPLATES
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQPtrVector<TQWidget>;
+#endif
+
+#if defined(TQ_DEFINED_TQPTRVECTOR) && defined(TQ_DEFINED_TQCONNECTION_LIST)  && !defined(TQ_EXPORTED_TQPTRVECTORCONNECTTIONLIST_TEMPLATES)
+#define TQ_EXPORTED_TQPTRVECTORCONNECTTIONLIST_TEMPLATES
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQPtrVector<TQConnectionList>;
+#endif
+
+#if defined(TQ_DEFINED_TQVALUELIST)  && !defined(TQ_EXPORTED_TQVALUELIST_BASIC_TEMPLATES)
+#define TQ_EXPORTED_TQVALUELIST_BASIC_TEMPLATES
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQValueListIterator<bool>;
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQValueList<bool>;
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQValueListIterator<int>;
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQValueList<int>;
+#endif
+
+#if defined(TQ_DEFINED_TQVALUELIST) && defined(TQ_DEFINED_TQRECT)  && !defined(TQ_EXPORTED_TQVALUELISTRECT_TEMPLATES)
+#define TQ_EXPORTED_TQVALUELISTRECT_TEMPLATES
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQValueListIterator<TQRect>;
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQValueList<TQRect>;
+#endif
+
+#if defined(TQ_DEFINED_TQVALUELIST) && defined(TQ_DEFINED_TQSTRING)  && !defined(TQ_EXPORTED_TQVALUELISTSTRING_TEMPLATES)
+#define TQ_EXPORTED_TQVALUELISTSTRING_TEMPLATES
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQValueListIterator<TQString>;
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQValueList<TQString>;
+#endif
+
+// TQStylesheet template exports
+#if defined(TQ_DEFINED_TQVALUELIST) && defined(TQ_DEFINED_TQPTRVECTOR) && defined(TQ_DEFINED_TQSTYLESHEET)  && !defined(TQ_EXPORTED_TQSTYLESHEETITEM1_TEMPLATES)
+#define TQ_EXPORTED_TQSTYLESHEETITEM1_TEMPLATES
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQValueList< TQPtrVector< TQStyleSheetItem> >;
+#endif
+
+#if defined(TQ_DEFINED_TQVALUELIST) && defined(TQ_DEFINED_TQSTYLESHEET)  && !defined(TQ_EXPORTED_TQSTYLESHEETITEM2_TEMPLATES)
+#define TQ_EXPORTED_TQSTYLESHEETITEM2_TEMPLATES
+TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQValueList<TQStyleSheetItem::ListStyle>;
+#endif
+
+// qcanvas template exports
+#if defined(TQ_DEFINED_TQPTRLIST)  && defined(TQ_DEFINED_TQCANVAS) && !defined(TQ_EXPORTED_TQCANVAS1_TEMPLATES)
+#define TQ_EXPORTED_TQCANVAS1_TEMPLATES
+TQM_TEMPLATE_EXTERN_CANVAS template class TQM_EXPORT_CANVAS TQPtrListIterator< TQCanvasItem >;
+TQM_TEMPLATE_EXTERN_CANVAS template class TQM_EXPORT_CANVAS TQPtrList< TQCanvasItem >;
+TQM_TEMPLATE_EXTERN_CANVAS template class TQM_EXPORT_CANVAS TQPtrListIterator< TQCanvasView >;
+TQM_TEMPLATE_EXTERN_CANVAS template class TQM_EXPORT_CANVAS TQPtrList< TQCanvasView >;
+#endif
+
+// qtable template exports
+#if defined(TQ_DEFINED_TQPTRLIST) && defined(TQ_DEFINED_TQTABLE_SELECTION) && !defined(TQ_EXPORTED_TQTABLESELECTION_TEMPLATES)
+#define TQ_EXPORTED_TQTABLESELECTION_TEMPLATES
+TQM_TEMPLATE_EXTERN_TABLE template class TQM_EXPORT_TABLE TQPtrList<TQTableSelection>;
+#endif
+
+#if defined(TQ_DEFINED_TQTABLE_ITEM) && defined(TQ_DEFINED_TQPTRVECTOR) && !defined(TQ_EXPORTED_TQTABLEITEM_TEMPLATES)
+#define TQ_EXPORTED_TQTABLEITEM_TEMPLATES
+TQM_TEMPLATE_EXTERN_TABLE template class TQM_EXPORT_TABLE TQPtrVector<TQTableItem>;
+#endif
+
+#if defined(TQ_DEFINED_TQTABLE) && defined(TQ_DEFINED_TQPTRVECTOR)
+//TQ_TEMPLATE_EXTERN template class TQ_EXPORT TQPtrVector<TQTable>;
+#endif
+
+// qsqlextension template exports
+#if defined(TQ_DEFINED_TQSQLEXTENSION) && defined(TQ_DEFINED_TQMAP) && defined(TQ_DEFINED_TQVALUEVECTOR) && defined(TQ_DEFINED_TQSTRING) && !defined(TQ_EXPORTED_TQSQLEXTENSION_TEMPLATES)
+#define TQ_EXPORTED_TQSQLEXTENSION_TEMPLATES
+TQM_TEMPLATE_EXTERN_SQL template class TQM_EXPORT_SQL TQMap<TQString,Param>;
+TQM_TEMPLATE_EXTERN_SQL template class TQM_EXPORT_SQL TQValueVector<Holder>;
+#endif
+
+
+// TQMOC_SKIP_END
+#endif // template defined