{-# LANGUAGE FlexibleContexts, FlexibleInstances, ForeignFunctionInterface, MonoLocalBinds, MultiParamTypeClasses, ScopedTypeVariables, TypeSynonymInstances, UndecidableInstances #-}
---------- GENERATED FILE, EDITS WILL BE LOST ----------

module Graphics.UI.Qtah.Generated.Core.QString (
  QStringValue (..),
  QStringConstPtr (..),
  arg,
  argWithSize,
  argWithSizeAndFill,
  argUlonglong,
  argUlonglongWithField,
  argUlonglongWithFieldAndBase,
  argUlonglongWithFieldAndBaseAndFill,
  argLonglong,
  argLonglongWithField,
  argLonglongWithFieldAndBase,
  argLonglongWithFieldAndBaseAndFill,
  argLong,
  argLongWithField,
  argLongWithFieldAndBase,
  argLongWithFieldAndBaseAndFill,
  argUlong,
  argUlongWithField,
  argUlongWithFieldAndBase,
  argUlongWithFieldAndBaseAndFill,
  argInt,
  argIntWithField,
  argIntWithFieldAndBase,
  argIntWithFieldAndBaseAndFill,
  argUintWith,
  argUintWithField,
  argUintWithFieldAndBase,
  argUintWithFieldAndBaseAndFill,
  argShortWith,
  argShortWithField,
  argShortWithFieldAndBase,
  argShortWithFieldAndBaseAndFill,
  argUshortWith,
  argUshortWithField,
  argUshortWithFieldAndBase,
  argUshortWithFieldAndBaseAndFill,
  argDoubleWith,
  argDoubleWithField,
  argDoubleWithFieldFormat,
  argDoubleWithFieldFormatPrecision,
  argDoubleWithFieldFormatPrecisionFill,
  argCharWith,
  argCharWithField,
  argCharWithFieldFill,
  argQCharWith,
  argQCharWithField,
  argQCharWithFieldFill,
  argTwoQStrings,
  argThreeQStrings,
  argFourQStrings,
  argFiveQStrings,
  argSixQStrings,
  argSevenQStrings,
  argEightQStrings,
  argNineQStrings,
  at,
  back,
  capacity,
  chopped,
  toHtmlEscaped,
  toLatin1,
  toLocal8Bit,
  toStdString,
  toUtf8,
  toCaseFolded,
  toDouble,
  toDoubleWithOk,
  toFloat,
  toFloatWithOk,
  toInt,
  toIntWithOk,
  toIntWithOkAndBase,
  toLong,
  toLongWithOk,
  toLongWithOkAndBase,
  toLonglong,
  toLonglongWithOk,
  toLonglongWithOkAndBase,
  toLower,
  toShort,
  toShortWithOk,
  toShortWithOkAndBase,
  toUInt,
  toUIntWithOk,
  toUIntWithOkAndBase,
  toULong,
  toULongWithOk,
  toULongWithOkAndBase,
  toUlonglong,
  toUlonglongWithOk,
  toUlonglongWithOkAndBase,
  toUshort,
  toUshortWithOk,
  toUshortWithOkAndBase,
  toUpper,
  trimmed,
  eQ,
  nE,
  lT,
  lE,
  gT,
  gE,
  QStringPtr (..),
  set,
  append,
  appendQChar,
  appendPtrConstChar,
  appendByteArray,
  chop,
  clear,
  truncate,
  aSSIGN,
  QStringConst (..),
  castQStringToConst,
  QString (..),
  castQStringToNonconst,
  new,
  newFromByteArray,
  newFromCString,
  newFromSizeQChar,
  newFromQChar,
  newCopy,
  QStringSuper (..),
  QStringSuperConst (..),
  QStringNormalizationForm (..),
  QStringSectionFlag (..),
  QStringSectionFlags,
  IsQStringSectionFlags (..),
  sectionCaseInsensitiveSeps,
  sectionDefault,
  sectionIncludeLeadingSep,
  sectionIncludeTrailingSep,
  sectionSkipEmpty,
  QStringSplitBehavior (..),
  ) where

import Data.Bits ((.&.), (.|.))
import qualified Data.Bits as QtahDB
import qualified Data.ByteString as QtahDBS
import qualified Data.Int as HoppyDI
import qualified Data.Word as HoppyDW
import qualified Foreign as HoppyF
import qualified Foreign.C as HoppyFC
import qualified Foreign.C as QtahFC
import qualified Foreign.Hoppy.Runtime as HoppyFHR
import qualified Foreign.Hoppy.Runtime as QtahFHR
import qualified Graphics.UI.Qtah.Flags as QtahFlags
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Core.QByteArray as M12
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Core.QChar as M16
import qualified Graphics.UI.Qtah.Std as M1
import Prelude (($), (.), (/=), (=<<), (==), (>>), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QString_new" new' ::  HoppyP.IO (HoppyF.Ptr QString)
foreign import ccall "genpop__QString_newFromByteArray" newFromByteArray' ::  HoppyF.Ptr M12.QByteArrayConst -> HoppyP.IO (HoppyF.Ptr QString)
foreign import ccall "genpop__QString_newFromCString" newFromCString' ::  HoppyF.Ptr HoppyFC.CChar -> HoppyP.IO (HoppyF.Ptr QString)
foreign import ccall "genpop__QString_newFromSizeQChar" newFromSizeQChar' ::  HoppyFC.CInt -> HoppyF.Ptr M16.QCharConst -> HoppyP.IO (HoppyF.Ptr QString)
foreign import ccall "genpop__QString_newFromQChar" newFromQChar' ::  HoppyF.Ptr M16.QChar -> HoppyP.IO (HoppyF.Ptr QString)
foreign import ccall "genpop__QString_newCopy" newCopy' ::  HoppyF.Ptr QStringConst -> HoppyP.IO (HoppyF.Ptr QString)
foreign import ccall "genpop__QString_set" set' ::  HoppyF.Ptr QString -> HoppyFC.CInt -> HoppyF.Ptr M16.QCharConst -> HoppyP.IO ()
foreign import ccall "genpop__QString_append" append' ::  HoppyF.Ptr QString -> HoppyF.Ptr QStringConst -> HoppyP.IO (HoppyF.Ptr QString)
foreign import ccall "genpop__QString_appendQChar" appendQChar' ::  HoppyF.Ptr QString -> HoppyF.Ptr M16.QCharConst -> HoppyP.IO (HoppyF.Ptr QString)
foreign import ccall "genpop__QString_appendPtrConstChar" appendPtrConstChar' ::  HoppyF.Ptr QString -> HoppyF.Ptr HoppyFC.CChar -> HoppyP.IO (HoppyF.Ptr QString)
foreign import ccall "genpop__QString_appendByteArray" appendByteArray' ::  HoppyF.Ptr QString -> HoppyF.Ptr M12.QByteArrayConst -> HoppyP.IO (HoppyF.Ptr QString)
foreign import ccall "genpop__QString_arg" arg' ::  HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argWithSize" argWithSize' ::  HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argWithSizeAndFill" argWithSizeAndFill' ::  HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyFC.CInt -> HoppyF.Ptr M16.QCharConst -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argUlonglong" argUlonglong' ::  HoppyF.Ptr QStringConst -> HoppyDW.Word64 -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argUlonglongWithField" argUlonglongWithField' ::  HoppyF.Ptr QStringConst -> HoppyDW.Word64 -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argUlonglongWithFieldAndBase" argUlonglongWithFieldAndBase' ::  HoppyF.Ptr QStringConst -> HoppyDW.Word64 -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argUlonglongWithFieldAndBaseAndFill" argUlonglongWithFieldAndBaseAndFill' ::  HoppyF.Ptr QStringConst -> HoppyDW.Word64 -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyF.Ptr M16.QCharConst -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argLonglong" argLonglong' ::  HoppyF.Ptr QStringConst -> HoppyDI.Int64 -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argLonglongWithField" argLonglongWithField' ::  HoppyF.Ptr QStringConst -> HoppyDI.Int64 -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argLonglongWithFieldAndBase" argLonglongWithFieldAndBase' ::  HoppyF.Ptr QStringConst -> HoppyDI.Int64 -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argLonglongWithFieldAndBaseAndFill" argLonglongWithFieldAndBaseAndFill' ::  HoppyF.Ptr QStringConst -> HoppyDI.Int64 -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyF.Ptr M16.QCharConst -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argLong" argLong' ::  HoppyF.Ptr QStringConst -> HoppyFC.CLong -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argLongWithField" argLongWithField' ::  HoppyF.Ptr QStringConst -> HoppyFC.CLong -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argLongWithFieldAndBase" argLongWithFieldAndBase' ::  HoppyF.Ptr QStringConst -> HoppyFC.CLong -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argLongWithFieldAndBaseAndFill" argLongWithFieldAndBaseAndFill' ::  HoppyF.Ptr QStringConst -> HoppyFC.CLong -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyF.Ptr M16.QCharConst -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argUlong" argUlong' ::  HoppyF.Ptr QStringConst -> HoppyFC.CULong -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argUlongWithField" argUlongWithField' ::  HoppyF.Ptr QStringConst -> HoppyFC.CULong -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argUlongWithFieldAndBase" argUlongWithFieldAndBase' ::  HoppyF.Ptr QStringConst -> HoppyFC.CULong -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argUlongWithFieldAndBaseAndFill" argUlongWithFieldAndBaseAndFill' ::  HoppyF.Ptr QStringConst -> HoppyFC.CULong -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyF.Ptr M16.QCharConst -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argInt" argInt' ::  HoppyF.Ptr QStringConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argIntWithField" argIntWithField' ::  HoppyF.Ptr QStringConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argIntWithFieldAndBase" argIntWithFieldAndBase' ::  HoppyF.Ptr QStringConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argIntWithFieldAndBaseAndFill" argIntWithFieldAndBaseAndFill' ::  HoppyF.Ptr QStringConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyF.Ptr M16.QCharConst -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argUintWith" argUintWith' ::  HoppyF.Ptr QStringConst -> HoppyFC.CUInt -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argUintWithField" argUintWithField' ::  HoppyF.Ptr QStringConst -> HoppyFC.CUInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argUintWithFieldAndBase" argUintWithFieldAndBase' ::  HoppyF.Ptr QStringConst -> HoppyFC.CUInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argUintWithFieldAndBaseAndFill" argUintWithFieldAndBaseAndFill' ::  HoppyF.Ptr QStringConst -> HoppyFC.CUInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyF.Ptr M16.QCharConst -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argShortWith" argShortWith' ::  HoppyF.Ptr QStringConst -> HoppyFC.CShort -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argShortWithField" argShortWithField' ::  HoppyF.Ptr QStringConst -> HoppyFC.CShort -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argShortWithFieldAndBase" argShortWithFieldAndBase' ::  HoppyF.Ptr QStringConst -> HoppyFC.CShort -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argShortWithFieldAndBaseAndFill" argShortWithFieldAndBaseAndFill' ::  HoppyF.Ptr QStringConst -> HoppyFC.CShort -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyF.Ptr M16.QCharConst -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argUshortWith" argUshortWith' ::  HoppyF.Ptr QStringConst -> HoppyFC.CUShort -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argUshortWithField" argUshortWithField' ::  HoppyF.Ptr QStringConst -> HoppyFC.CUShort -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argUshortWithFieldAndBase" argUshortWithFieldAndBase' ::  HoppyF.Ptr QStringConst -> HoppyFC.CUShort -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argUshortWithFieldAndBaseAndFill" argUshortWithFieldAndBaseAndFill' ::  HoppyF.Ptr QStringConst -> HoppyFC.CUShort -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyF.Ptr M16.QCharConst -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argDoubleWith" argDoubleWith' ::  HoppyF.Ptr QStringConst -> HoppyFC.CDouble -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argDoubleWithField" argDoubleWithField' ::  HoppyF.Ptr QStringConst -> HoppyFC.CDouble -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argDoubleWithFieldFormat" argDoubleWithFieldFormat' ::  HoppyF.Ptr QStringConst -> HoppyFC.CDouble -> HoppyFC.CInt -> HoppyFC.CChar -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argDoubleWithFieldFormatPrecision" argDoubleWithFieldFormatPrecision' ::  HoppyF.Ptr QStringConst -> HoppyFC.CDouble -> HoppyFC.CInt -> HoppyFC.CChar -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argDoubleWithFieldFormatPrecisionFill" argDoubleWithFieldFormatPrecisionFill' ::  HoppyF.Ptr QStringConst -> HoppyFC.CDouble -> HoppyFC.CInt -> HoppyFC.CChar -> HoppyFC.CInt -> HoppyF.Ptr M16.QCharConst -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argCharWith" argCharWith' ::  HoppyF.Ptr QStringConst -> HoppyFC.CChar -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argCharWithField" argCharWithField' ::  HoppyF.Ptr QStringConst -> HoppyFC.CChar -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argCharWithFieldFill" argCharWithFieldFill' ::  HoppyF.Ptr QStringConst -> HoppyFC.CChar -> HoppyFC.CInt -> HoppyF.Ptr M16.QCharConst -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argQCharWith" argQCharWith' ::  HoppyF.Ptr QStringConst -> HoppyF.Ptr M16.QCharConst -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argQCharWithField" argQCharWithField' ::  HoppyF.Ptr QStringConst -> HoppyF.Ptr M16.QCharConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argQCharWithFieldFill" argQCharWithFieldFill' ::  HoppyF.Ptr QStringConst -> HoppyF.Ptr M16.QCharConst -> HoppyFC.CInt -> HoppyF.Ptr M16.QCharConst -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argTwoQStrings" argTwoQStrings' ::  HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argThreeQStrings" argThreeQStrings' ::  HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argFourQStrings" argFourQStrings' ::  HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argFiveQStrings" argFiveQStrings' ::  HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argSixQStrings" argSixQStrings' ::  HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argSevenQStrings" argSevenQStrings' ::  HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argEightQStrings" argEightQStrings' ::  HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_argNineQStrings" argNineQStrings' ::  HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_at" at' ::  HoppyF.Ptr QStringConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M16.QCharConst)
foreign import ccall "genpop__QString_back" back' ::  HoppyF.Ptr QStringConst -> HoppyP.IO (HoppyF.Ptr M16.QCharConst)
foreign import ccall "genpop__QString_capacity" capacity' ::  HoppyF.Ptr QStringConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QString_chop" chop' ::  HoppyF.Ptr QString -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QString_chopped" chopped' ::  HoppyF.Ptr QStringConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_clear" clear' ::  HoppyF.Ptr QString -> HoppyP.IO ()
foreign import ccall "genpop__QString_toHtmlEscaped" toHtmlEscaped' ::  HoppyF.Ptr QStringConst -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_toLatin1" toLatin1' ::  HoppyF.Ptr QStringConst -> HoppyP.IO (HoppyF.Ptr M12.QByteArrayConst)
foreign import ccall "genpop__QString_toLocal8Bit" toLocal8Bit' ::  HoppyF.Ptr QStringConst -> HoppyP.IO (HoppyF.Ptr M12.QByteArrayConst)
foreign import ccall "genpop__QString_toStdString" toStdString' ::  HoppyF.Ptr QStringConst -> HoppyP.IO (HoppyF.Ptr M1.StdStringConst)
foreign import ccall "genpop__QString_toUtf8" toUtf8' ::  HoppyF.Ptr QStringConst -> HoppyP.IO (HoppyF.Ptr M12.QByteArrayConst)
foreign import ccall "genpop__QString_toCaseFolded" toCaseFolded' ::  HoppyF.Ptr QStringConst -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_toDouble" toDouble' ::  HoppyF.Ptr QStringConst -> HoppyP.IO HoppyFC.CDouble
foreign import ccall "genpop__QString_toDoubleWithOk" toDoubleWithOk' ::  HoppyF.Ptr QStringConst -> HoppyF.Ptr HoppyFC.CBool -> HoppyP.IO HoppyFC.CDouble
foreign import ccall "genpop__QString_toFloat" toFloat' ::  HoppyF.Ptr QStringConst -> HoppyP.IO HoppyFC.CFloat
foreign import ccall "genpop__QString_toFloatWithOk" toFloatWithOk' ::  HoppyF.Ptr QStringConst -> HoppyF.Ptr HoppyFC.CBool -> HoppyP.IO HoppyFC.CFloat
foreign import ccall "genpop__QString_toInt" toInt' ::  HoppyF.Ptr QStringConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QString_toIntWithOk" toIntWithOk' ::  HoppyF.Ptr QStringConst -> HoppyF.Ptr HoppyFC.CBool -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QString_toIntWithOkAndBase" toIntWithOkAndBase' ::  HoppyF.Ptr QStringConst -> HoppyF.Ptr HoppyFC.CBool -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QString_toLong" toLong' ::  HoppyF.Ptr QStringConst -> HoppyP.IO HoppyFC.CLong
foreign import ccall "genpop__QString_toLongWithOk" toLongWithOk' ::  HoppyF.Ptr QStringConst -> HoppyF.Ptr HoppyFC.CBool -> HoppyP.IO HoppyFC.CLong
foreign import ccall "genpop__QString_toLongWithOkAndBase" toLongWithOkAndBase' ::  HoppyF.Ptr QStringConst -> HoppyF.Ptr HoppyFC.CBool -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CLong
foreign import ccall "genpop__QString_toLonglong" toLonglong' ::  HoppyF.Ptr QStringConst -> HoppyP.IO HoppyDI.Int64
foreign import ccall "genpop__QString_toLonglongWithOk" toLonglongWithOk' ::  HoppyF.Ptr QStringConst -> HoppyF.Ptr HoppyFC.CBool -> HoppyP.IO HoppyDI.Int64
foreign import ccall "genpop__QString_toLonglongWithOkAndBase" toLonglongWithOkAndBase' ::  HoppyF.Ptr QStringConst -> HoppyF.Ptr HoppyFC.CBool -> HoppyFC.CInt -> HoppyP.IO HoppyDI.Int64
foreign import ccall "genpop__QString_toLower" toLower' ::  HoppyF.Ptr QStringConst -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_toShort" toShort' ::  HoppyF.Ptr QStringConst -> HoppyP.IO HoppyFC.CShort
foreign import ccall "genpop__QString_toShortWithOk" toShortWithOk' ::  HoppyF.Ptr QStringConst -> HoppyF.Ptr HoppyFC.CBool -> HoppyP.IO HoppyFC.CShort
foreign import ccall "genpop__QString_toShortWithOkAndBase" toShortWithOkAndBase' ::  HoppyF.Ptr QStringConst -> HoppyF.Ptr HoppyFC.CBool -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CShort
foreign import ccall "genpop__QString_toUInt" toUInt' ::  HoppyF.Ptr QStringConst -> HoppyP.IO HoppyFC.CUInt
foreign import ccall "genpop__QString_toUIntWithOk" toUIntWithOk' ::  HoppyF.Ptr QStringConst -> HoppyF.Ptr HoppyFC.CBool -> HoppyP.IO HoppyFC.CUInt
foreign import ccall "genpop__QString_toUIntWithOkAndBase" toUIntWithOkAndBase' ::  HoppyF.Ptr QStringConst -> HoppyF.Ptr HoppyFC.CBool -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CUInt
foreign import ccall "genpop__QString_toULong" toULong' ::  HoppyF.Ptr QStringConst -> HoppyP.IO HoppyFC.CULong
foreign import ccall "genpop__QString_toULongWithOk" toULongWithOk' ::  HoppyF.Ptr QStringConst -> HoppyF.Ptr HoppyFC.CBool -> HoppyP.IO HoppyFC.CULong
foreign import ccall "genpop__QString_toULongWithOkAndBase" toULongWithOkAndBase' ::  HoppyF.Ptr QStringConst -> HoppyF.Ptr HoppyFC.CBool -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CULong
foreign import ccall "genpop__QString_toUlonglong" toUlonglong' ::  HoppyF.Ptr QStringConst -> HoppyP.IO HoppyDW.Word64
foreign import ccall "genpop__QString_toUlonglongWithOk" toUlonglongWithOk' ::  HoppyF.Ptr QStringConst -> HoppyF.Ptr HoppyFC.CBool -> HoppyP.IO HoppyDW.Word64
foreign import ccall "genpop__QString_toUlonglongWithOkAndBase" toUlonglongWithOkAndBase' ::  HoppyF.Ptr QStringConst -> HoppyF.Ptr HoppyFC.CBool -> HoppyFC.CInt -> HoppyP.IO HoppyDW.Word64
foreign import ccall "genpop__QString_toUshort" toUshort' ::  HoppyF.Ptr QStringConst -> HoppyP.IO HoppyFC.CUShort
foreign import ccall "genpop__QString_toUshortWithOk" toUshortWithOk' ::  HoppyF.Ptr QStringConst -> HoppyF.Ptr HoppyFC.CBool -> HoppyP.IO HoppyFC.CUShort
foreign import ccall "genpop__QString_toUshortWithOkAndBase" toUshortWithOkAndBase' ::  HoppyF.Ptr QStringConst -> HoppyF.Ptr HoppyFC.CBool -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CUShort
foreign import ccall "genpop__QString_toUpper" toUpper' ::  HoppyF.Ptr QStringConst -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_trimmed" trimmed' ::  HoppyF.Ptr QStringConst -> HoppyP.IO (HoppyF.Ptr QStringConst)
foreign import ccall "genpop__QString_truncate" truncate' ::  HoppyF.Ptr QString -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QString_EQ" eQ' ::  HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QString_NE" nE' ::  HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QString_LT" lT' ::  HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QString_LE" lE' ::  HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QString_GT" gT' ::  HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QString_GE" gE' ::  HoppyF.Ptr QStringConst -> HoppyF.Ptr QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QString_ASSIGN" aSSIGN' ::  HoppyF.Ptr QString -> HoppyF.Ptr QStringConst -> HoppyP.IO (HoppyF.Ptr QString)
foreign import ccall "gendel__QString" delete'QString :: HoppyF.Ptr QStringConst -> HoppyP.IO ()
foreign import ccall "&gendel__QString" deletePtr'QString :: HoppyF.FunPtr (HoppyF.Ptr QStringConst -> HoppyP.IO ())

class QStringValue a where
  withQStringPtr :: a -> (QStringConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QStringConstPtr a => QStringValue a where
  withQStringPtr = HoppyP.flip ($) . toQStringConst

instance {-# OVERLAPPING #-} QStringValue (QtahP.String) where
  withQStringPtr = HoppyFHR.withCppObj

class (HoppyFHR.CppPtr this) => QStringConstPtr this where
  toQStringConst :: this -> QStringConst

arg :: (QStringValue this, QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QtahP.String)
arg arg'1 arg'2 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (arg' arg'1' arg'2')

argWithSize :: (QStringValue this, QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.Int) -> (HoppyP.IO QtahP.String)
argWithSize arg'1 arg'2 arg'3 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argWithSize' arg'1' arg'2' arg'3')

argWithSizeAndFill :: (QStringValue this, QStringValue arg'2, M16.QCharValue arg'4) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.Int) -> (arg'4) -> (HoppyP.IO QtahP.String)
argWithSizeAndFill arg'1 arg'2 arg'3 arg'4 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  M16.withQCharPtr arg'4 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'4' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argWithSizeAndFill' arg'1' arg'2' arg'3' arg'4')

argUlonglong :: (QStringValue this) => (this) {- ^ this -} -> (HoppyDW.Word64) -> (HoppyP.IO QtahP.String)
argUlonglong arg'1 arg'2 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argUlonglong' arg'1' arg'2')

argUlonglongWithField :: (QStringValue this) => (this) {- ^ this -} -> (HoppyDW.Word64) -> (HoppyP.Int) -> (HoppyP.IO QtahP.String)
argUlonglongWithField arg'1 arg'2 arg'3 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argUlonglongWithField' arg'1' arg'2' arg'3')

argUlonglongWithFieldAndBase :: (QStringValue this) => (this) {- ^ this -} -> (HoppyDW.Word64) -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO QtahP.String)
argUlonglongWithFieldAndBase arg'1 arg'2 arg'3 arg'4 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'4 >>= \arg'4' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argUlonglongWithFieldAndBase' arg'1' arg'2' arg'3' arg'4')

argUlonglongWithFieldAndBaseAndFill :: (QStringValue this, M16.QCharValue arg'5) => (this) {- ^ this -} -> (HoppyDW.Word64) -> (HoppyP.Int) -> (HoppyP.Int) -> (arg'5) -> (HoppyP.IO QtahP.String)
argUlonglongWithFieldAndBaseAndFill arg'1 arg'2 arg'3 arg'4 arg'5 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'4 >>= \arg'4' ->
  M16.withQCharPtr arg'5 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'5' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argUlonglongWithFieldAndBaseAndFill' arg'1' arg'2' arg'3' arg'4' arg'5')

argLonglong :: (QStringValue this) => (this) {- ^ this -} -> (HoppyDI.Int64) -> (HoppyP.IO QtahP.String)
argLonglong arg'1 arg'2 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argLonglong' arg'1' arg'2')

argLonglongWithField :: (QStringValue this) => (this) {- ^ this -} -> (HoppyDI.Int64) -> (HoppyP.Int) -> (HoppyP.IO QtahP.String)
argLonglongWithField arg'1 arg'2 arg'3 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argLonglongWithField' arg'1' arg'2' arg'3')

argLonglongWithFieldAndBase :: (QStringValue this) => (this) {- ^ this -} -> (HoppyDI.Int64) -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO QtahP.String)
argLonglongWithFieldAndBase arg'1 arg'2 arg'3 arg'4 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'4 >>= \arg'4' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argLonglongWithFieldAndBase' arg'1' arg'2' arg'3' arg'4')

argLonglongWithFieldAndBaseAndFill :: (QStringValue this, M16.QCharValue arg'5) => (this) {- ^ this -} -> (HoppyDI.Int64) -> (HoppyP.Int) -> (HoppyP.Int) -> (arg'5) -> (HoppyP.IO QtahP.String)
argLonglongWithFieldAndBaseAndFill arg'1 arg'2 arg'3 arg'4 arg'5 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'4 >>= \arg'4' ->
  M16.withQCharPtr arg'5 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'5' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argLonglongWithFieldAndBaseAndFill' arg'1' arg'2' arg'3' arg'4' arg'5')

argLong :: (QStringValue this) => (this) {- ^ this -} -> (HoppyFC.CLong) -> (HoppyP.IO QtahP.String)
argLong arg'1 arg'2 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argLong' arg'1' arg'2')

argLongWithField :: (QStringValue this) => (this) {- ^ this -} -> (HoppyFC.CLong) -> (HoppyP.Int) -> (HoppyP.IO QtahP.String)
argLongWithField arg'1 arg'2 arg'3 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argLongWithField' arg'1' arg'2' arg'3')

argLongWithFieldAndBase :: (QStringValue this) => (this) {- ^ this -} -> (HoppyFC.CLong) -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO QtahP.String)
argLongWithFieldAndBase arg'1 arg'2 arg'3 arg'4 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'4 >>= \arg'4' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argLongWithFieldAndBase' arg'1' arg'2' arg'3' arg'4')

argLongWithFieldAndBaseAndFill :: (QStringValue this, M16.QCharValue arg'5) => (this) {- ^ this -} -> (HoppyFC.CLong) -> (HoppyP.Int) -> (HoppyP.Int) -> (arg'5) -> (HoppyP.IO QtahP.String)
argLongWithFieldAndBaseAndFill arg'1 arg'2 arg'3 arg'4 arg'5 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'4 >>= \arg'4' ->
  M16.withQCharPtr arg'5 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'5' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argLongWithFieldAndBaseAndFill' arg'1' arg'2' arg'3' arg'4' arg'5')

argUlong :: (QStringValue this) => (this) {- ^ this -} -> (HoppyFC.CULong) -> (HoppyP.IO QtahP.String)
argUlong arg'1 arg'2 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argUlong' arg'1' arg'2')

argUlongWithField :: (QStringValue this) => (this) {- ^ this -} -> (HoppyFC.CULong) -> (HoppyP.Int) -> (HoppyP.IO QtahP.String)
argUlongWithField arg'1 arg'2 arg'3 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argUlongWithField' arg'1' arg'2' arg'3')

argUlongWithFieldAndBase :: (QStringValue this) => (this) {- ^ this -} -> (HoppyFC.CULong) -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO QtahP.String)
argUlongWithFieldAndBase arg'1 arg'2 arg'3 arg'4 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'4 >>= \arg'4' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argUlongWithFieldAndBase' arg'1' arg'2' arg'3' arg'4')

argUlongWithFieldAndBaseAndFill :: (QStringValue this, M16.QCharValue arg'5) => (this) {- ^ this -} -> (HoppyFC.CULong) -> (HoppyP.Int) -> (HoppyP.Int) -> (arg'5) -> (HoppyP.IO QtahP.String)
argUlongWithFieldAndBaseAndFill arg'1 arg'2 arg'3 arg'4 arg'5 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'4 >>= \arg'4' ->
  M16.withQCharPtr arg'5 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'5' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argUlongWithFieldAndBaseAndFill' arg'1' arg'2' arg'3' arg'4' arg'5')

argInt :: (QStringValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO QtahP.String)
argInt arg'1 arg'2 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argInt' arg'1' arg'2')

argIntWithField :: (QStringValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO QtahP.String)
argIntWithField arg'1 arg'2 arg'3 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argIntWithField' arg'1' arg'2' arg'3')

argIntWithFieldAndBase :: (QStringValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO QtahP.String)
argIntWithFieldAndBase arg'1 arg'2 arg'3 arg'4 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'4 >>= \arg'4' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argIntWithFieldAndBase' arg'1' arg'2' arg'3' arg'4')

argIntWithFieldAndBaseAndFill :: (QStringValue this, M16.QCharValue arg'5) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.Int) -> (arg'5) -> (HoppyP.IO QtahP.String)
argIntWithFieldAndBaseAndFill arg'1 arg'2 arg'3 arg'4 arg'5 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'4 >>= \arg'4' ->
  M16.withQCharPtr arg'5 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'5' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argIntWithFieldAndBaseAndFill' arg'1' arg'2' arg'3' arg'4' arg'5')

argUintWith :: (QStringValue this) => (this) {- ^ this -} -> (HoppyFC.CUInt) -> (HoppyP.IO QtahP.String)
argUintWith arg'1 arg'2 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argUintWith' arg'1' arg'2')

argUintWithField :: (QStringValue this) => (this) {- ^ this -} -> (HoppyFC.CUInt) -> (HoppyP.Int) -> (HoppyP.IO QtahP.String)
argUintWithField arg'1 arg'2 arg'3 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argUintWithField' arg'1' arg'2' arg'3')

argUintWithFieldAndBase :: (QStringValue this) => (this) {- ^ this -} -> (HoppyFC.CUInt) -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO QtahP.String)
argUintWithFieldAndBase arg'1 arg'2 arg'3 arg'4 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'4 >>= \arg'4' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argUintWithFieldAndBase' arg'1' arg'2' arg'3' arg'4')

argUintWithFieldAndBaseAndFill :: (QStringValue this, M16.QCharValue arg'5) => (this) {- ^ this -} -> (HoppyFC.CUInt) -> (HoppyP.Int) -> (HoppyP.Int) -> (arg'5) -> (HoppyP.IO QtahP.String)
argUintWithFieldAndBaseAndFill arg'1 arg'2 arg'3 arg'4 arg'5 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'4 >>= \arg'4' ->
  M16.withQCharPtr arg'5 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'5' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argUintWithFieldAndBaseAndFill' arg'1' arg'2' arg'3' arg'4' arg'5')

argShortWith :: (QStringValue this) => (this) {- ^ this -} -> (HoppyFC.CShort) -> (HoppyP.IO QtahP.String)
argShortWith arg'1 arg'2 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argShortWith' arg'1' arg'2')

argShortWithField :: (QStringValue this) => (this) {- ^ this -} -> (HoppyFC.CShort) -> (HoppyP.Int) -> (HoppyP.IO QtahP.String)
argShortWithField arg'1 arg'2 arg'3 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argShortWithField' arg'1' arg'2' arg'3')

argShortWithFieldAndBase :: (QStringValue this) => (this) {- ^ this -} -> (HoppyFC.CShort) -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO QtahP.String)
argShortWithFieldAndBase arg'1 arg'2 arg'3 arg'4 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'4 >>= \arg'4' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argShortWithFieldAndBase' arg'1' arg'2' arg'3' arg'4')

argShortWithFieldAndBaseAndFill :: (QStringValue this, M16.QCharValue arg'5) => (this) {- ^ this -} -> (HoppyFC.CShort) -> (HoppyP.Int) -> (HoppyP.Int) -> (arg'5) -> (HoppyP.IO QtahP.String)
argShortWithFieldAndBaseAndFill arg'1 arg'2 arg'3 arg'4 arg'5 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'4 >>= \arg'4' ->
  M16.withQCharPtr arg'5 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'5' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argShortWithFieldAndBaseAndFill' arg'1' arg'2' arg'3' arg'4' arg'5')

argUshortWith :: (QStringValue this) => (this) {- ^ this -} -> (HoppyFC.CUShort) -> (HoppyP.IO QtahP.String)
argUshortWith arg'1 arg'2 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argUshortWith' arg'1' arg'2')

argUshortWithField :: (QStringValue this) => (this) {- ^ this -} -> (HoppyFC.CUShort) -> (HoppyP.Int) -> (HoppyP.IO QtahP.String)
argUshortWithField arg'1 arg'2 arg'3 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argUshortWithField' arg'1' arg'2' arg'3')

argUshortWithFieldAndBase :: (QStringValue this) => (this) {- ^ this -} -> (HoppyFC.CUShort) -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO QtahP.String)
argUshortWithFieldAndBase arg'1 arg'2 arg'3 arg'4 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'4 >>= \arg'4' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argUshortWithFieldAndBase' arg'1' arg'2' arg'3' arg'4')

argUshortWithFieldAndBaseAndFill :: (QStringValue this, M16.QCharValue arg'5) => (this) {- ^ this -} -> (HoppyFC.CUShort) -> (HoppyP.Int) -> (HoppyP.Int) -> (arg'5) -> (HoppyP.IO QtahP.String)
argUshortWithFieldAndBaseAndFill arg'1 arg'2 arg'3 arg'4 arg'5 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'4 >>= \arg'4' ->
  M16.withQCharPtr arg'5 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'5' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argUshortWithFieldAndBaseAndFill' arg'1' arg'2' arg'3' arg'4' arg'5')

argDoubleWith :: (QStringValue this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.IO QtahP.String)
argDoubleWith arg'1 arg'2 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argDoubleWith' arg'1' arg'2')

argDoubleWithField :: (QStringValue this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.Int) -> (HoppyP.IO QtahP.String)
argDoubleWithField arg'1 arg'2 arg'3 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argDoubleWithField' arg'1' arg'2' arg'3')

argDoubleWithFieldFormat :: (QStringValue this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.Int) -> (HoppyFC.CChar) -> (HoppyP.IO QtahP.String)
argDoubleWithFieldFormat arg'1 arg'2 arg'3 arg'4 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  let arg'4' = arg'4 in
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argDoubleWithFieldFormat' arg'1' arg'2' arg'3' arg'4')

argDoubleWithFieldFormatPrecision :: (QStringValue this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.Int) -> (HoppyFC.CChar) -> (HoppyP.Int) -> (HoppyP.IO QtahP.String)
argDoubleWithFieldFormatPrecision arg'1 arg'2 arg'3 arg'4 arg'5 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  let arg'4' = arg'4 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'5 >>= \arg'5' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argDoubleWithFieldFormatPrecision' arg'1' arg'2' arg'3' arg'4' arg'5')

argDoubleWithFieldFormatPrecisionFill :: (QStringValue this, M16.QCharValue arg'6) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.Int) -> (HoppyFC.CChar) -> (HoppyP.Int) -> (arg'6) -> (HoppyP.IO QtahP.String)
argDoubleWithFieldFormatPrecisionFill arg'1 arg'2 arg'3 arg'4 arg'5 arg'6 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  let arg'4' = arg'4 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'5 >>= \arg'5' ->
  M16.withQCharPtr arg'6 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'6' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argDoubleWithFieldFormatPrecisionFill' arg'1' arg'2' arg'3' arg'4' arg'5' arg'6')

argCharWith :: (QStringValue this) => (this) {- ^ this -} -> (HoppyFC.CChar) -> (HoppyP.IO QtahP.String)
argCharWith arg'1 arg'2 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argCharWith' arg'1' arg'2')

argCharWithField :: (QStringValue this) => (this) {- ^ this -} -> (HoppyFC.CChar) -> (HoppyP.Int) -> (HoppyP.IO QtahP.String)
argCharWithField arg'1 arg'2 arg'3 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argCharWithField' arg'1' arg'2' arg'3')

argCharWithFieldFill :: (QStringValue this, M16.QCharValue arg'4) => (this) {- ^ this -} -> (HoppyFC.CChar) -> (HoppyP.Int) -> (arg'4) -> (HoppyP.IO QtahP.String)
argCharWithFieldFill arg'1 arg'2 arg'3 arg'4 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  M16.withQCharPtr arg'4 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'4' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argCharWithFieldFill' arg'1' arg'2' arg'3' arg'4')

argQCharWith :: (QStringValue this, M16.QCharValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QtahP.String)
argQCharWith arg'1 arg'2 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M16.withQCharPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argQCharWith' arg'1' arg'2')

argQCharWithField :: (QStringValue this, M16.QCharValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.Int) -> (HoppyP.IO QtahP.String)
argQCharWithField arg'1 arg'2 arg'3 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M16.withQCharPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argQCharWithField' arg'1' arg'2' arg'3')

argQCharWithFieldFill :: (QStringValue this, M16.QCharValue arg'2, M16.QCharValue arg'4) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.Int) -> (arg'4) -> (HoppyP.IO QtahP.String)
argQCharWithFieldFill arg'1 arg'2 arg'3 arg'4 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M16.withQCharPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  M16.withQCharPtr arg'4 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'4' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argQCharWithFieldFill' arg'1' arg'2' arg'3' arg'4')

argTwoQStrings :: (QStringValue this, QStringValue arg'2, QStringValue arg'3) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (HoppyP.IO QtahP.String)
argTwoQStrings arg'1 arg'2 arg'3 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argTwoQStrings' arg'1' arg'2' arg'3')

argThreeQStrings :: (QStringValue this, QStringValue arg'2, QStringValue arg'3, QStringValue arg'4) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (arg'4) -> (HoppyP.IO QtahP.String)
argThreeQStrings arg'1 arg'2 arg'3 arg'4 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  withQStringPtr arg'4 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'4' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argThreeQStrings' arg'1' arg'2' arg'3' arg'4')

argFourQStrings :: (QStringValue this, QStringValue arg'2, QStringValue arg'3, QStringValue arg'4, QStringValue arg'5) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (arg'4) -> (arg'5) -> (HoppyP.IO QtahP.String)
argFourQStrings arg'1 arg'2 arg'3 arg'4 arg'5 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  withQStringPtr arg'4 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'4' ->
  withQStringPtr arg'5 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'5' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argFourQStrings' arg'1' arg'2' arg'3' arg'4' arg'5')

argFiveQStrings :: (QStringValue this, QStringValue arg'2, QStringValue arg'3, QStringValue arg'4, QStringValue arg'5, QStringValue arg'6) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (arg'4) -> (arg'5) -> (arg'6) -> (HoppyP.IO QtahP.String)
argFiveQStrings arg'1 arg'2 arg'3 arg'4 arg'5 arg'6 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  withQStringPtr arg'4 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'4' ->
  withQStringPtr arg'5 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'5' ->
  withQStringPtr arg'6 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'6' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argFiveQStrings' arg'1' arg'2' arg'3' arg'4' arg'5' arg'6')

argSixQStrings :: (QStringValue this, QStringValue arg'2, QStringValue arg'3, QStringValue arg'4, QStringValue arg'5, QStringValue arg'6, QStringValue arg'7) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (arg'4) -> (arg'5) -> (arg'6) -> (arg'7) -> (HoppyP.IO QtahP.String)
argSixQStrings arg'1 arg'2 arg'3 arg'4 arg'5 arg'6 arg'7 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  withQStringPtr arg'4 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'4' ->
  withQStringPtr arg'5 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'5' ->
  withQStringPtr arg'6 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'6' ->
  withQStringPtr arg'7 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'7' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argSixQStrings' arg'1' arg'2' arg'3' arg'4' arg'5' arg'6' arg'7')

argSevenQStrings :: (QStringValue this, QStringValue arg'2, QStringValue arg'3, QStringValue arg'4, QStringValue arg'5, QStringValue arg'6, QStringValue arg'7, QStringValue arg'8) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (arg'4) -> (arg'5) -> (arg'6) -> (arg'7) -> (arg'8) -> (HoppyP.IO QtahP.String)
argSevenQStrings arg'1 arg'2 arg'3 arg'4 arg'5 arg'6 arg'7 arg'8 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  withQStringPtr arg'4 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'4' ->
  withQStringPtr arg'5 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'5' ->
  withQStringPtr arg'6 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'6' ->
  withQStringPtr arg'7 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'7' ->
  withQStringPtr arg'8 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'8' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argSevenQStrings' arg'1' arg'2' arg'3' arg'4' arg'5' arg'6' arg'7' arg'8')

argEightQStrings :: (QStringValue this, QStringValue arg'2, QStringValue arg'3, QStringValue arg'4, QStringValue arg'5, QStringValue arg'6, QStringValue arg'7, QStringValue arg'8, QStringValue arg'9) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (arg'4) -> (arg'5) -> (arg'6) -> (arg'7) -> (arg'8) -> (arg'9) -> (HoppyP.IO QtahP.String)
argEightQStrings arg'1 arg'2 arg'3 arg'4 arg'5 arg'6 arg'7 arg'8 arg'9 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  withQStringPtr arg'4 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'4' ->
  withQStringPtr arg'5 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'5' ->
  withQStringPtr arg'6 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'6' ->
  withQStringPtr arg'7 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'7' ->
  withQStringPtr arg'8 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'8' ->
  withQStringPtr arg'9 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'9' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argEightQStrings' arg'1' arg'2' arg'3' arg'4' arg'5' arg'6' arg'7' arg'8' arg'9')

argNineQStrings :: (QStringValue this, QStringValue arg'2, QStringValue arg'3, QStringValue arg'4, QStringValue arg'5, QStringValue arg'6, QStringValue arg'7, QStringValue arg'8, QStringValue arg'9, QStringValue arg'10) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (arg'4) -> (arg'5) -> (arg'6) -> (arg'7) -> (arg'8) -> (arg'9) -> (arg'10) -> (HoppyP.IO QtahP.String)
argNineQStrings arg'1 arg'2 arg'3 arg'4 arg'5 arg'6 arg'7 arg'8 arg'9 arg'10 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  withQStringPtr arg'4 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'4' ->
  withQStringPtr arg'5 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'5' ->
  withQStringPtr arg'6 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'6' ->
  withQStringPtr arg'7 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'7' ->
  withQStringPtr arg'8 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'8' ->
  withQStringPtr arg'9 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'9' ->
  withQStringPtr arg'10 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'10' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (argNineQStrings' arg'1' arg'2' arg'3' arg'4' arg'5' arg'6' arg'7' arg'8' arg'9' arg'10')

at :: (QStringValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO QtahP.Char)
at arg'1 arg'2 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M16.QCharConst) =<<
  (at' arg'1' arg'2')

back :: (QStringValue this) => (this) {- ^ this -} -> (HoppyP.IO QtahP.Char)
back arg'1 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M16.QCharConst) =<<
  (back' arg'1')

capacity :: (QStringValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Int)
capacity arg'1 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (capacity' arg'1')

chopped :: (QStringValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO QtahP.String)
chopped arg'1 arg'2 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (chopped' arg'1' arg'2')

toHtmlEscaped :: (QStringValue this) => (this) {- ^ this -} -> (HoppyP.IO QtahP.String)
toHtmlEscaped arg'1 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (toHtmlEscaped' arg'1')

toLatin1 :: (QStringValue this) => (this) {- ^ this -} -> (HoppyP.IO QtahDBS.ByteString)
toLatin1 arg'1 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M12.QByteArrayConst) =<<
  (toLatin1' arg'1')

toLocal8Bit :: (QStringValue this) => (this) {- ^ this -} -> (HoppyP.IO QtahDBS.ByteString)
toLocal8Bit arg'1 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M12.QByteArrayConst) =<<
  (toLocal8Bit' arg'1')

toStdString :: (QStringValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.String)
toStdString arg'1 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M1.StdStringConst) =<<
  (toStdString' arg'1')

toUtf8 :: (QStringValue this) => (this) {- ^ this -} -> (HoppyP.IO QtahDBS.ByteString)
toUtf8 arg'1 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M12.QByteArrayConst) =<<
  (toUtf8' arg'1')

toCaseFolded :: (QStringValue this) => (this) {- ^ this -} -> (HoppyP.IO QtahP.String)
toCaseFolded arg'1 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (toCaseFolded' arg'1')

toDouble :: (QStringValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Double)
toDouble arg'1 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) =<<
  (toDouble' arg'1')

toDoubleWithOk :: (QStringValue this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CBool) -> (HoppyP.IO HoppyP.Double)
toDoubleWithOk arg'1 arg'2 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyP.realToFrac
  ) =<<
  (toDoubleWithOk' arg'1' arg'2')

toFloat :: (QStringValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Float)
toFloat arg'1 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) =<<
  (toFloat' arg'1')

toFloatWithOk :: (QStringValue this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CBool) -> (HoppyP.IO HoppyP.Float)
toFloatWithOk arg'1 arg'2 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyP.realToFrac
  ) =<<
  (toFloatWithOk' arg'1' arg'2')

toInt :: (QStringValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Int)
toInt arg'1 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (toInt' arg'1')

toIntWithOk :: (QStringValue this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CBool) -> (HoppyP.IO HoppyP.Int)
toIntWithOk arg'1 arg'2 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (toIntWithOk' arg'1' arg'2')

toIntWithOkAndBase :: (QStringValue this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CBool) -> (HoppyP.Int) -> (HoppyP.IO HoppyP.Int)
toIntWithOkAndBase arg'1 arg'2 arg'3 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (toIntWithOkAndBase' arg'1' arg'2' arg'3')

toLong :: (QStringValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyFC.CLong)
toLong arg'1 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (toLong' arg'1')

toLongWithOk :: (QStringValue this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CBool) -> (HoppyP.IO HoppyFC.CLong)
toLongWithOk arg'1 arg'2 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (toLongWithOk' arg'1' arg'2')

toLongWithOkAndBase :: (QStringValue this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CBool) -> (HoppyP.Int) -> (HoppyP.IO HoppyFC.CLong)
toLongWithOkAndBase arg'1 arg'2 arg'3 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (toLongWithOkAndBase' arg'1' arg'2' arg'3')

toLonglong :: (QStringValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyDI.Int64)
toLonglong arg'1 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (toLonglong' arg'1')

toLonglongWithOk :: (QStringValue this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CBool) -> (HoppyP.IO HoppyDI.Int64)
toLonglongWithOk arg'1 arg'2 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (toLonglongWithOk' arg'1' arg'2')

toLonglongWithOkAndBase :: (QStringValue this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CBool) -> (HoppyP.Int) -> (HoppyP.IO HoppyDI.Int64)
toLonglongWithOkAndBase arg'1 arg'2 arg'3 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (toLonglongWithOkAndBase' arg'1' arg'2' arg'3')

toLower :: (QStringValue this) => (this) {- ^ this -} -> (HoppyP.IO QtahP.String)
toLower arg'1 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (toLower' arg'1')

toShort :: (QStringValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyFC.CShort)
toShort arg'1 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (toShort' arg'1')

toShortWithOk :: (QStringValue this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CBool) -> (HoppyP.IO HoppyFC.CShort)
toShortWithOk arg'1 arg'2 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (toShortWithOk' arg'1' arg'2')

toShortWithOkAndBase :: (QStringValue this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CBool) -> (HoppyP.Int) -> (HoppyP.IO HoppyFC.CShort)
toShortWithOkAndBase arg'1 arg'2 arg'3 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (toShortWithOkAndBase' arg'1' arg'2' arg'3')

toUInt :: (QStringValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyFC.CUInt)
toUInt arg'1 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (toUInt' arg'1')

toUIntWithOk :: (QStringValue this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CBool) -> (HoppyP.IO HoppyFC.CUInt)
toUIntWithOk arg'1 arg'2 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (toUIntWithOk' arg'1' arg'2')

toUIntWithOkAndBase :: (QStringValue this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CBool) -> (HoppyP.Int) -> (HoppyP.IO HoppyFC.CUInt)
toUIntWithOkAndBase arg'1 arg'2 arg'3 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (toUIntWithOkAndBase' arg'1' arg'2' arg'3')

toULong :: (QStringValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyFC.CULong)
toULong arg'1 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (toULong' arg'1')

toULongWithOk :: (QStringValue this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CBool) -> (HoppyP.IO HoppyFC.CULong)
toULongWithOk arg'1 arg'2 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (toULongWithOk' arg'1' arg'2')

toULongWithOkAndBase :: (QStringValue this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CBool) -> (HoppyP.Int) -> (HoppyP.IO HoppyFC.CULong)
toULongWithOkAndBase arg'1 arg'2 arg'3 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (toULongWithOkAndBase' arg'1' arg'2' arg'3')

toUlonglong :: (QStringValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyDW.Word64)
toUlonglong arg'1 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (toUlonglong' arg'1')

toUlonglongWithOk :: (QStringValue this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CBool) -> (HoppyP.IO HoppyDW.Word64)
toUlonglongWithOk arg'1 arg'2 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (toUlonglongWithOk' arg'1' arg'2')

toUlonglongWithOkAndBase :: (QStringValue this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CBool) -> (HoppyP.Int) -> (HoppyP.IO HoppyDW.Word64)
toUlonglongWithOkAndBase arg'1 arg'2 arg'3 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (toUlonglongWithOkAndBase' arg'1' arg'2' arg'3')

toUshort :: (QStringValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyFC.CUShort)
toUshort arg'1 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (toUshort' arg'1')

toUshortWithOk :: (QStringValue this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CBool) -> (HoppyP.IO HoppyFC.CUShort)
toUshortWithOk arg'1 arg'2 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (toUshortWithOk' arg'1' arg'2')

toUshortWithOkAndBase :: (QStringValue this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CBool) -> (HoppyP.Int) -> (HoppyP.IO HoppyFC.CUShort)
toUshortWithOkAndBase arg'1 arg'2 arg'3 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (toUshortWithOkAndBase' arg'1' arg'2' arg'3')

toUpper :: (QStringValue this) => (this) {- ^ this -} -> (HoppyP.IO QtahP.String)
toUpper arg'1 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (toUpper' arg'1')

trimmed :: (QStringValue this) => (this) {- ^ this -} -> (HoppyP.IO QtahP.String)
trimmed arg'1 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . QStringConst) =<<
  (trimmed' arg'1')

eQ :: (QStringValue this, QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
eQ arg'1 arg'2 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (eQ' arg'1' arg'2')

nE :: (QStringValue this, QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
nE arg'1 arg'2 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (nE' arg'1' arg'2')

lT :: (QStringValue this, QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
lT arg'1 arg'2 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (lT' arg'1' arg'2')

lE :: (QStringValue this, QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
lE arg'1 arg'2 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (lE' arg'1' arg'2')

gT :: (QStringValue this, QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
gT arg'1 arg'2 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (gT' arg'1' arg'2')

gE :: (QStringValue this, QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
gE arg'1 arg'2 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (gE' arg'1' arg'2')

class (QStringConstPtr this) => QStringPtr this where
  toQString :: this -> QString

set :: (QStringPtr arg'1, M16.QCharValue arg'3) => (arg'1) -> (HoppyP.Int) -> (arg'3) -> (HoppyP.IO ())
set arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQString arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  M16.withQCharPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (set' arg'1' arg'2' arg'3')

append :: (QStringPtr this, QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QString)
append arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQString arg'1) $ \arg'1' ->
  withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QString
  (append' arg'1' arg'2')

appendQChar :: (QStringPtr this, M16.QCharValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QString)
appendQChar arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQString arg'1) $ \arg'1' ->
  M16.withQCharPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QString
  (appendQChar' arg'1' arg'2')

appendPtrConstChar :: (QStringPtr this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.IO QString)
appendPtrConstChar arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQString arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  HoppyP.fmap QString
  (appendPtrConstChar' arg'1' arg'2')

appendByteArray :: (QStringPtr this, M12.QByteArrayValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QString)
appendByteArray arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQString arg'1) $ \arg'1' ->
  M12.withQByteArrayPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QString
  (appendByteArray' arg'1' arg'2')

chop :: (QStringPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO ())
chop arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQString arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (chop' arg'1' arg'2')

clear :: (QStringPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
clear arg'1 =
  HoppyFHR.withCppPtr (toQString arg'1) $ \arg'1' ->
  (clear' arg'1')

truncate :: (QStringPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO ())
truncate arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQString arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (truncate' arg'1' arg'2')

aSSIGN :: (QStringPtr this, QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QString)
aSSIGN arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQString arg'1) $ \arg'1' ->
  withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QString
  (aSSIGN' arg'1' arg'2')

data QStringConst =
    QStringConst (HoppyF.Ptr QStringConst)
  | QStringConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QStringConst)
  deriving (HoppyP.Show)

instance HoppyP.Eq QStringConst where
  x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y

instance HoppyP.Ord QStringConst where
  compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)

castQStringToConst :: QString -> QStringConst
castQStringToConst (QString ptr') = QStringConst $ HoppyF.castPtr ptr'
castQStringToConst (QStringGc fptr' ptr') = QStringConstGc fptr' $ HoppyF.castPtr ptr'

instance HoppyFHR.CppPtr QStringConst where
  nullptr = QStringConst HoppyF.nullPtr
  
  withCppPtr (QStringConst ptr') f' = f' ptr'
  withCppPtr (QStringConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
  
  toPtr (QStringConst ptr') = ptr'
  toPtr (QStringConstGc _ ptr') = ptr'
  
  touchCppPtr (QStringConst _) = HoppyP.return ()
  touchCppPtr (QStringConstGc fptr' _) = HoppyF.touchForeignPtr fptr'

instance HoppyFHR.Deletable QStringConst where
  delete (QStringConst ptr') = delete'QString ptr'
  delete (QStringConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "QStringConst", " object."]
  
  toGc this'@(QStringConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip QStringConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'QString :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
  toGc this'@(QStringConstGc {}) = HoppyP.return this'

instance HoppyFHR.Copyable QStringConst QString where copy = newCopy

instance QStringConstPtr QStringConst where
  toQStringConst = HoppyP.id

data QString =
    QString (HoppyF.Ptr QString)
  | QStringGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QString)
  deriving (HoppyP.Show)

instance HoppyP.Eq QString where
  x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y

instance HoppyP.Ord QString where
  compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)

castQStringToNonconst :: QStringConst -> QString
castQStringToNonconst (QStringConst ptr') = QString $ HoppyF.castPtr ptr'
castQStringToNonconst (QStringConstGc fptr' ptr') = QStringGc fptr' $ HoppyF.castPtr ptr'

instance HoppyFHR.CppPtr QString where
  nullptr = QString HoppyF.nullPtr
  
  withCppPtr (QString ptr') f' = f' ptr'
  withCppPtr (QStringGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
  
  toPtr (QString ptr') = ptr'
  toPtr (QStringGc _ ptr') = ptr'
  
  touchCppPtr (QString _) = HoppyP.return ()
  touchCppPtr (QStringGc fptr' _) = HoppyF.touchForeignPtr fptr'

instance HoppyFHR.Deletable QString where
  delete (QString ptr') = delete'QString $ (HoppyF.castPtr ptr' :: HoppyF.Ptr QStringConst)
  delete (QStringGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "QString", " object."]
  
  toGc this'@(QString ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip QStringGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'QString :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
  toGc this'@(QStringGc {}) = HoppyP.return this'

instance HoppyFHR.Copyable QString QString where copy = newCopy

instance QStringConstPtr QString where
  toQStringConst (QString ptr') = QStringConst $ (HoppyF.castPtr :: HoppyF.Ptr QString -> HoppyF.Ptr QStringConst) ptr'
  toQStringConst (QStringGc fptr' ptr') = QStringConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QString -> HoppyF.Ptr QStringConst) ptr'

instance QStringPtr QString where
  toQString = HoppyP.id

new :: (HoppyP.IO QString)
new =
  HoppyP.fmap QString
  (new')

newFromByteArray :: (M12.QByteArrayValue arg'1) => (arg'1) -> (HoppyP.IO QString)
newFromByteArray arg'1 =
  M12.withQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QString
  (newFromByteArray' arg'1')

newFromCString :: (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.IO QString)
newFromCString arg'1 =
  let arg'1' = arg'1 in
  HoppyP.fmap QString
  (newFromCString' arg'1')

newFromSizeQChar :: (M16.QCharValue arg'2) => (HoppyP.Int) -> (arg'2) -> (HoppyP.IO QString)
newFromSizeQChar arg'1 arg'2 =
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'1 >>= \arg'1' ->
  M16.withQCharPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QString
  (newFromSizeQChar' arg'1' arg'2')

newFromQChar :: (M16.QCharPtr arg'1) => (arg'1) -> (HoppyP.IO QString)
newFromQChar arg'1 =
  HoppyFHR.withCppPtr (M16.toQChar arg'1) $ \arg'1' ->
  HoppyP.fmap QString
  (newFromQChar' arg'1')

newCopy :: (QStringValue arg'1) => (arg'1) -> (HoppyP.IO QString)
newCopy arg'1 =
  withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QString
  (newCopy' arg'1')

class QStringSuper a where
  downToQString :: a -> QString


class QStringSuperConst a where
  downToQStringConst :: a -> QStringConst


instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr QString)) QString where
  assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'

instance QStringValue a => HoppyFHR.Assignable QString a where
  assign x' y' = aSSIGN x' y' >> HoppyP.return ()

instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr QString)) QString where
  decode = HoppyP.fmap QString . HoppyF.peek

instance HoppyFHR.Encodable QString (QtahP.String) where
  encode =
    QtahP.flip QtahFC.withCString newFromCString

instance HoppyFHR.Encodable QStringConst (QtahP.String) where
  encode = HoppyP.fmap (toQStringConst) . HoppyFHR.encodeAs (HoppyP.undefined :: QString)

instance HoppyFHR.Decodable QString (QtahP.String) where
  decode = HoppyFHR.decode . toQStringConst

instance HoppyFHR.Decodable QStringConst (QtahP.String) where
  decode =
    toStdString

data QStringNormalizationForm =
  NormalizationFormD
  | NormalizationFormC
  | NormalizationFormKd
  | NormalizationFormKc
  | UnknownQStringNormalizationForm (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QStringNormalizationForm where
  fromCppEnum NormalizationFormD = 0
  fromCppEnum NormalizationFormC = 1
  fromCppEnum NormalizationFormKd = 2
  fromCppEnum NormalizationFormKc = 3
  fromCppEnum (UnknownQStringNormalizationForm n) = n
  
  toCppEnum (0) = NormalizationFormD
  toCppEnum (1) = NormalizationFormC
  toCppEnum (2) = NormalizationFormKd
  toCppEnum (3) = NormalizationFormKc
  toCppEnum n = UnknownQStringNormalizationForm n

instance HoppyP.Eq QStringNormalizationForm where
  x == y = HoppyFHR.fromCppEnum x == HoppyFHR.fromCppEnum y

instance HoppyP.Ord QStringNormalizationForm where
  compare x y = HoppyP.compare (HoppyFHR.fromCppEnum x) (HoppyFHR.fromCppEnum y)

data QStringSectionFlag =
  SectionDefault
  | SectionSkipEmpty
  | SectionIncludeLeadingSep
  | SectionIncludeTrailingSep
  | SectionCaseInsensitiveSeps
  | UnknownQStringSectionFlag (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QStringSectionFlag where
  fromCppEnum SectionDefault = 0
  fromCppEnum SectionSkipEmpty = 1
  fromCppEnum SectionIncludeLeadingSep = 2
  fromCppEnum SectionIncludeTrailingSep = 4
  fromCppEnum SectionCaseInsensitiveSeps = 8
  fromCppEnum (UnknownQStringSectionFlag n) = n
  
  toCppEnum (0) = SectionDefault
  toCppEnum (1) = SectionSkipEmpty
  toCppEnum (2) = SectionIncludeLeadingSep
  toCppEnum (4) = SectionIncludeTrailingSep
  toCppEnum (8) = SectionCaseInsensitiveSeps
  toCppEnum n = UnknownQStringSectionFlag n

instance HoppyP.Eq QStringSectionFlag where
  x == y = HoppyFHR.fromCppEnum x == HoppyFHR.fromCppEnum y

instance HoppyP.Ord QStringSectionFlag where
  compare x y = HoppyP.compare (HoppyFHR.fromCppEnum x) (HoppyFHR.fromCppEnum y)

newtype QStringSectionFlags = QStringSectionFlags (HoppyFC.CInt) deriving (QtahP.Eq, QtahP.Ord, QtahP.Show)

instance QtahFlags.Flags (HoppyFC.CInt) QStringSectionFlag QStringSectionFlags where
  enumToFlags = QStringSectionFlags . QtahFHR.fromCppEnum
  flagsToEnum (QStringSectionFlags x') = QtahFHR.toCppEnum x'

class IsQStringSectionFlags a where
  toQStringSectionFlags :: a -> QStringSectionFlags

instance IsQStringSectionFlags QStringSectionFlags where toQStringSectionFlags = QtahP.id
instance IsQStringSectionFlags QStringSectionFlag where toQStringSectionFlags = QtahFlags.enumToFlags
instance IsQStringSectionFlags (HoppyFC.CInt) where toQStringSectionFlags = QtahFlags.numToFlags

sectionCaseInsensitiveSeps :: QStringSectionFlags
sectionCaseInsensitiveSeps = QStringSectionFlags (8)

sectionDefault :: QStringSectionFlags
sectionDefault = QStringSectionFlags (0)

sectionIncludeLeadingSep :: QStringSectionFlags
sectionIncludeLeadingSep = QStringSectionFlags (2)

sectionIncludeTrailingSep :: QStringSectionFlags
sectionIncludeTrailingSep = QStringSectionFlags (4)

sectionSkipEmpty :: QStringSectionFlags
sectionSkipEmpty = QStringSectionFlags (1)

instance QtahDB.Bits QStringSectionFlags where
  x .&. y = QtahFlags.numToFlags (QtahFlags.flagsToNum x .&. QtahFlags.flagsToNum y)
  x .|. y = QtahFlags.numToFlags (QtahFlags.flagsToNum x .|. QtahFlags.flagsToNum y)
  xor x y = QtahFlags.numToFlags $ QtahDB.xor (QtahFlags.flagsToNum x) (QtahFlags.flagsToNum y)
  complement x = QtahFlags.numToFlags $ QtahDB.complement $ QtahFlags.flagsToNum x
  shift x i = QtahFlags.numToFlags $ QtahDB.shift (QtahFlags.flagsToNum x) i
  rotate x i = QtahFlags.numToFlags $ QtahDB.rotate (QtahFlags.flagsToNum x) i
  bitSize x = case QtahDB.bitSizeMaybe x of
      QtahP.Just n -> n
      QtahP.Nothing -> QtahP.error "bitSize is undefined"
  bitSizeMaybe = QtahDB.bitSizeMaybe . QtahFlags.flagsToNum
  isSigned = QtahDB.isSigned . QtahFlags.flagsToNum
  testBit x i = QtahDB.testBit (QtahFlags.flagsToNum x) i
  bit = QtahFlags.numToFlags . QtahDB.bit
  popCount = QtahDB.popCount . QtahFlags.flagsToNum

data QStringSplitBehavior =
  KeepEmptyParts
  | SkipEmptyParts
  | UnknownQStringSplitBehavior (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QStringSplitBehavior where
  fromCppEnum KeepEmptyParts = 0
  fromCppEnum SkipEmptyParts = 1
  fromCppEnum (UnknownQStringSplitBehavior n) = n
  
  toCppEnum (0) = KeepEmptyParts
  toCppEnum (1) = SkipEmptyParts
  toCppEnum n = UnknownQStringSplitBehavior n

instance HoppyP.Eq QStringSplitBehavior where
  x == y = HoppyFHR.fromCppEnum x == HoppyFHR.fromCppEnum y

instance HoppyP.Ord QStringSplitBehavior where
  compare x y = HoppyP.compare (HoppyFHR.fromCppEnum x) (HoppyFHR.fromCppEnum y)