Add flags for annotating Generic{,1} methods INLINE[1] (#11068)

Makes it possible for GHC to optimize away intermediate Generic representation
for more types.

Metric Increase:
    T12227

compiler/GHC/Driver/Flags.hs

@@ -158,6 +158,8 @@ data GeneralFlag
    | Opt_Specialise
    | Opt_SpecialiseAggressively
    | Opt_CrossModuleSpecialise
+   | Opt_InlineGenerics
+   | Opt_InlineGenericsAggressively
    | Opt_StaticArgumentTransformation
    | Opt_CSE
    | Opt_StgCSE

compiler/GHC/Driver/Session.hs

@@ -3468,6 +3468,8 @@ fFlagsDeps = [
   flagSpec "specialize-aggressively"          Opt_SpecialiseAggressively,
   flagSpec "cross-module-specialise"          Opt_CrossModuleSpecialise,
   flagSpec "cross-module-specialize"          Opt_CrossModuleSpecialise,
+  flagSpec "inline-generics"                  Opt_InlineGenerics,
+  flagSpec "inline-generics-aggressively"     Opt_InlineGenericsAggressively,
   flagSpec "static-argument-transformation"   Opt_StaticArgumentTransformation,
   flagSpec "strictness"                       Opt_Strictness,
   flagSpec "use-rpaths"                       Opt_RPath,
@@ -3981,6 +3983,7 @@ optLevelFlags -- see Note [Documenting optimisation flags]
 
     , ([1,2],   Opt_Specialise)
     , ([1,2],   Opt_CrossModuleSpecialise)
+    , ([1,2],   Opt_InlineGenerics)
     , ([1,2],   Opt_Strictness)
     , ([1,2],   Opt_UnboxSmallStrictFields)
     , ([1,2],   Opt_CprAnal)

compiler/GHC/Tc/Deriv.hs

@@ -2049,8 +2049,7 @@ genDerivStuff mechanism loc clas inst_tys tyvars
                         , dit_rep_tc_args = rep_tc_args
                         }
                      , dsm_stock_gen_fn = gen_fn }
-        -> do (binds, faminsts, field_names) <- gen_fn loc rep_tc rep_tc_args inst_tys
-              pure (binds, [], faminsts, field_names)
+        -> gen_fn loc rep_tc rep_tc_args inst_tys
 
       -- Try DeriveAnyClass
       DerivSpecAnyClass -> do

compiler/GHC/Tc/Deriv/Generics.hs

@@ -43,6 +43,7 @@ import GHC.Builtin.Types
 import GHC.Builtin.Names
 import GHC.Tc.Utils.Env
 import GHC.Tc.Utils.Monad
+import GHC.Driver.Session
 import GHC.Driver.Types
 import GHC.Utils.Error( Validity(..), andValid )
 import GHC.Types.SrcLoc
@@ -76,10 +77,12 @@ For the generic representation we need to generate:
 -}
 
 gen_Generic_binds :: GenericKind -> TyCon -> [Type]
-                 -> TcM (LHsBinds GhcPs, FamInst)
+                 -> TcM (LHsBinds GhcPs, [LSig GhcPs], FamInst)
 gen_Generic_binds gk tc inst_tys = do
+  dflags <- getDynFlags
   repTyInsts <- tc_mkRepFamInsts gk tc inst_tys
-  return (mkBindsRep gk tc, repTyInsts)
+  let (binds, sigs) = mkBindsRep dflags gk tc
+  return (binds, sigs, repTyInsts)
 
 {-
 ************************************************************************
@@ -332,12 +335,33 @@ gk2gkDC Gen1_{} d = Gen1_DC $ last $ dataConUnivTyVars d
 
 
 -- Bindings for the Generic instance
-mkBindsRep :: GenericKind -> TyCon -> LHsBinds GhcPs
-mkBindsRep gk tycon =
-    unitBag (mkRdrFunBind (L loc from01_RDR) [from_eqn])
-  `unionBags`
-    unitBag (mkRdrFunBind (L loc to01_RDR) [to_eqn])
+mkBindsRep :: DynFlags -> GenericKind -> TyCon -> (LHsBinds GhcPs, [LSig GhcPs])
+mkBindsRep dflags gk tycon = (binds, sigs)
       where
+        binds = unitBag (mkRdrFunBind (L loc from01_RDR) [from_eqn])
+              `unionBags`
+                unitBag (mkRdrFunBind (L loc to01_RDR) [to_eqn])
+
+        -- See Note [Generics performance tricks]
+        sigs = if     gopt Opt_InlineGenericsAggressively dflags
+                  || (gopt Opt_InlineGenerics dflags && inlining_useful)
+               then [inline1 from01_RDR, inline1 to01_RDR]
+               else []
+         where
+           inlining_useful
+             | cons <= 1  = True
+             | cons <= 4  = max_fields <= 5
+             | cons <= 8  = max_fields <= 2
+             | cons <= 16 = max_fields <= 1
+             | cons <= 24 = max_fields == 0
+             | otherwise  = False
+             where
+               cons       = length datacons
+               max_fields = maximum $ map dataConSourceArity datacons
+
+           inline1 f = L loc . InlineSig noExtField (L loc f)
+                     $ alwaysInlinePragma { inl_act = ActiveAfter NoSourceText 1 }
+
         -- The topmost M1 (the datatype metadata) has the exact same type
         -- across all cases of a from/to definition, and can be factored out
         -- to save some allocations during typechecking.
@@ -1039,4 +1063,48 @@ factor it out reduce the typechecker's burden:
 
 A simple change, but one that pays off, since it goes turns an O(n) amount of
 coercions to an O(1) amount.
+
+Note [Generics performance tricks]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Generics-based algorithms tend to rely on GHC optimizing away the intermediate
+representation for optimal performance. However, the default unfolding threshold
+is usually too small for GHC to do that.
+
+The recommended approach thus far was to increase unfolding threshold, but this
+makes GHC inline more aggressively in general, whereas it should only be more
+aggresive with generics-based code.
+
+The solution is to use a heuristic that'll annotate Generic class methods with
+INLINE[1] pragmas (the explicit phase is used to give users phase control as
+they can annotate their functions with INLINE[2] or INLINE[0] if appropriate).
+
+The current heuristic was chosen by looking at how annotating Generic methods
+INLINE[1] helps with optimal code generation for several types of generic
+algorithms:
+
+* Round trip through the generic representation.
+
+* Generation of NFData instances.
+
+* Generation of field lenses.
+
+The experimentation was done by picking data types having N constructors with M
+fields each and using their derived Generic instances to generate code with the
+above algorithms.
+
+The results are threshold values for N and M (contained in
+`mkBindsRep.inlining_useful`) for which inlining is beneficial, i.e. it usually
+leads to performance improvements at both compile time (the simplifier has to do
+more work, but then there's much less code left for subsequent phases to work
+with) and run time (the generic representation of a data type is optimized
+away).
+
+The T11068 test case, which includes the algorithms mentioned above, tests that
+the generic representations of several data types optimize away using the
+threshold values in `mkBindsRep.inlining_useful`.
+
+If one uses threshold values higher what is found in
+`mkBindsRep.inlining_useful`, then annotating Generic class methods with INLINE
+pragmas tends to be at best useless and at worst lead to code size blowup
+without runtime performance improvements.
 -}

compiler/GHC/Tc/Deriv/Utils.hs

@@ -222,19 +222,22 @@ data DerivSpecMechanism
         SrcSpan -> TyCon  -- dit_rep_tc
                 -> [Type] -- dit_rep_tc_args
                 -> [Type] -- inst_tys
-                -> TcM (LHsBinds GhcPs, BagDerivStuff, [Name])
-      -- ^ This function returns three things:
+                -> TcM (LHsBinds GhcPs, [LSig GhcPs], BagDerivStuff, [Name])
+      -- ^ This function returns four things:
       --
       -- 1. @LHsBinds GhcPs@: The derived instance's function bindings
       --    (e.g., @compare (T x) (T y) = compare x y@)
       --
-      -- 2. @BagDerivStuff@: Auxiliary bindings needed to support the derived
+      -- 2. @[LSig GhcPs]@: A list of instance specific signatures/pragmas.
+      --    Most likely INLINE pragmas for class methods.
+      --
+      -- 3. @BagDerivStuff@: Auxiliary bindings needed to support the derived
       --    instance. As examples, derived 'Generic' instances require
       --    associated type family instances, and derived 'Eq' and 'Ord'
       --    instances require top-level @con2tag@ functions.
       --    See @Note [Auxiliary binders]@ in "GHC.Tc.Deriv.Generate".
       --
-      -- 3. @[Name]@: A list of Names for which @-Wunused-binds@ should be
+      -- 4. @[Name]@: A list of Names for which @-Wunused-binds@ should be
       --    suppressed. This is used to suppress unused warnings for record
       --    selectors when deriving 'Read', 'Show', or 'Generic'.
       --    See @Note [Deriving and unused record selectors]@.
@@ -427,7 +430,7 @@ instance Outputable DerivContext where
 data OriginativeDerivStatus
   = CanDeriveStock            -- Stock class, can derive
       (SrcSpan -> TyCon -> [Type] -> [Type]
-               -> TcM (LHsBinds GhcPs, BagDerivStuff, [Name]))
+               -> TcM (LHsBinds GhcPs, [LSig GhcPs], BagDerivStuff, [Name]))
   | StockClassError SDoc      -- Stock class, but can't do it
   | CanDeriveAnyClass         -- See Note [Deriving any class]
   | NonDerivableClass SDoc    -- Cannot derive with either stock or anyclass
@@ -566,7 +569,7 @@ hasStockDeriving
                      -> TyCon
                      -> [Type]
                      -> [Type]
-                     -> TcM (LHsBinds GhcPs, BagDerivStuff, [Name]))
+                     -> TcM (LHsBinds GhcPs, [LSig GhcPs], BagDerivStuff, [Name]))
 hasStockDeriving clas
   = assocMaybe gen_list (getUnique clas)
   where
@@ -575,7 +578,7 @@ hasStockDeriving clas
                    -> TyCon
                    -> [Type]
                    -> [Type]
-                   -> TcM (LHsBinds GhcPs, BagDerivStuff, [Name]))]
+                   -> TcM (LHsBinds GhcPs, [LSig GhcPs], BagDerivStuff, [Name]))]
     gen_list = [ (eqClassKey,          simpleM gen_Eq_binds)
                , (ordClassKey,         simpleM gen_Ord_binds)
                , (enumClassKey,        simpleM gen_Enum_binds)
@@ -593,7 +596,7 @@ hasStockDeriving clas
 
     simple gen_fn loc tc tc_args _
       = let (binds, deriv_stuff) = gen_fn loc tc tc_args
-        in return (binds, deriv_stuff, [])
+        in return (binds, [], deriv_stuff, [])
 
     -- Like `simple`, but monadic. The only monadic thing that these functions
     -- do is allocate new Uniques, which are used for generating the names of
@@ -601,18 +604,18 @@ hasStockDeriving clas
     -- See Note [Auxiliary binders] in GHC.Tc.Deriv.Generate.
     simpleM gen_fn loc tc tc_args _
       = do { (binds, deriv_stuff) <- gen_fn loc tc tc_args
-           ; return (binds, deriv_stuff, []) }
+           ; return (binds, [], deriv_stuff, []) }
 
     read_or_show gen_fn loc tc tc_args _
       = do { fix_env <- getDataConFixityFun tc
            ; let (binds, deriv_stuff) = gen_fn fix_env loc tc tc_args
                  field_names          = all_field_names tc
-           ; return (binds, deriv_stuff, field_names) }
+           ; return (binds, [], deriv_stuff, field_names) }
 
     generic gen_fn _ tc _ inst_tys
-      = do { (binds, faminst) <- gen_fn tc inst_tys
+      = do { (binds, sigs, faminst) <- gen_fn tc inst_tys
            ; let field_names = all_field_names tc
-           ; return (binds, unitBag (DerivFamInst faminst), field_names) }
+           ; return (binds, sigs, unitBag (DerivFamInst faminst), field_names) }
 
     -- See Note [Deriving and unused record selectors]
     all_field_names = map flSelector . concatMap dataConFieldLabels

docs/users_guide/9.2.1-notes.rst

@@ -28,6 +28,12 @@ Compiler
   since the argument was already forced in the first equation. For more
   details see :ghc-flag:`-Wredundant-bang-patterns`.
 
+- New ``-finline-generics`` and ``-finline-generics-aggressively`` flags for
+  improving performance of generics-based algorithms.
+
+  For more details see :ghc-flag:`-finline-generics` and
+  :ghc-flag:`-finline-generics-aggressively`.
+
 - Type checker plugins which work with the natural numbers now
   should use ``naturalTy`` kind instead of ``typeNatKind``, which has been removed.
 

docs/users_guide/using-optimisation.rst

@@ -979,6 +979,50 @@ by saying ``-fno-wombat``.
     which returns a constrained type. For example, a type class where one
     of the methods implements a traversal.
 
+.. ghc-flag:: -finline-generics
+    :shortdesc: Annotate methods of derived Generic and Generic1 instances with
+        INLINE[1] pragmas based on heuristics. Implied by :ghc-flag:`-O`.
+    :type: dynamic
+    :reverse: -fno-inline-generics
+    :category:
+
+    :default: on
+    :since: 9.2.1
+
+    .. index::
+       single: inlining, controlling
+       single: unfolding, controlling
+
+    Annotate methods of derived Generic and Generic1 instances with INLINE[1]
+    pragmas based on heuristics dependent on the size of the data type in
+    question. Improves performance of generics-based algorithms as GHC is able
+    to optimize away intermediate representation more often.
+
+.. ghc-flag:: -finline-generics-aggressively
+    :shortdesc: Annotate methods of all derived Generic and Generic1 instances
+        with INLINE[1] pragmas.
+    :type: dynamic
+    :reverse: -fno-inline-generics-aggressively
+    :category:
+
+    :default: off
+    :since: 9.2.1
+
+    .. index::
+       single: inlining, controlling
+       single: unfolding, controlling
+
+    Annotate methods of all derived Generic and Generic1 instances with
+    INLINE[1] pragmas.
+
+    This flag should only be used in modules deriving Generic instances that
+    weren't considered appropriate for INLINE[1] annotations by heuristics of
+    :ghc-flag:`-finline-generics`, yet you know that doing so would be
+    beneficial.
+
+    When enabled globally it will most likely lead to worse compile times and
+    code size blowup without runtime performance gains.
+
 .. ghc-flag:: -fsolve-constant-dicts
     :shortdesc: When solving constraints, try to eagerly solve
         super classes using available dictionaries.

testsuite/tests/deriving/should_compile/T11068_aggressive.hs

+{-# LANGUAGE DeriveGeneric #-}
+{-# OPTIONS_GHC -finline-generics-aggressively #-}
+module T11068_aggressive where
+
+import GHC.Generics
+
+-- For 2 data constructors -finline-generics annotates class methods of the
+-- derived Generic instance as INLINE[1] only if each has at most 5 fields.
+data X
+  = X1 Int Int Int Int Int Int Int Int Int Int
+  | X2 Int Int Int Int Int Int Int Int Int Int
+  deriving Generic

testsuite/tests/deriving/should_compile/all.T

@@ -65,6 +65,7 @@ test('T7947', [], multimod_compile, ['T7947', '-v0'])
 test('T10561', normal, compile, [''])
 test('T10487', [], multimod_compile, ['T10487', '-v0'])
 test('T10524', normal, compile, [''])
+test('T11068_aggressive', [normalise_errmsg_fun(just_the_deriving)], compile, ['-ddump-deriv -dsuppress-uniques'])
 test('T11148', normal, makefile_test, [])
 test('T9968', normal, compile, [''])
 test('T9968a', normal, compile, [''])

testsuite/tests/perf/compiler/Makefile

@@ -7,3 +7,8 @@ T4007:
 	$(RM) -f T4007.hi T4007.o
 	'$(TEST_HC)' $(TEST_HC_OPTS) -c -O -ddump-rule-firings T4007.hs
 
+T11068:
+	$(RM) -f T11068a.hi T11068a.o T11068b.hi T11068b.o T11068.hi T11068.o
+	'$(TEST_HC)' $(TEST_HC_OPTS) -c -O T11068a.hs
+	'$(TEST_HC)' $(TEST_HC_OPTS) -c -O T11068b.hs
+	-'$(TEST_HC)' $(TEST_HC_OPTS) -c -O T11068.hs -ddump-simpl | grep 'Generic'

testsuite/tests/perf/compiler/T11068.hs

+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE TypeApplications #-}
+module T11068 where
+
+import Control.DeepSeq
+import GHC.Generics
+
+import T11068a
+import T11068b
+
+-- X1
+
+instance NFData X1
+
+x1_id :: X1 -> X1
+x1_id = to . from
+
+x1_lens :: Lens' X1 Integer
+x1_lens = gfield @"x1_f1"
+
+-- X1'
+
+instance NFData X1'
+
+x1'_id :: X1' -> X1'
+x1'_id = to . from
+
+x1'_lens :: Lens' X1' Integer
+x1'_lens = gfield @"x1'_f1"
+
+-- X4
+
+instance NFData X4
+
+x4_id :: X4 -> X4
+x4_id = to . from
+
+x4_lens :: Lens' X4 Integer
+x4_lens = gfield @"x4_f1"
+
+-- X4'
+
+instance NFData X4'
+
+x4'_id :: X4' -> X4'
+x4'_id = to . from
+
+x4'_lens :: Lens' X4' Integer
+x4'_lens = gfield @"x4'_f1"
+
+-- X8
+
+instance NFData X8
+
+x8_id :: X8 -> X8
+x8_id = to . from
+
+x8_lens :: Lens' X8 Integer
+x8_lens = gfield @"x8_f1"
+
+-- X8'
+
+instance NFData X8'
+
+x8'_id :: X8' -> X8'
+x8'_id = to . from
+
+x8'_lens :: Lens' X8' Integer
+x8'_lens = gfield @"x8'_f1"
+
+-- X12'
+
+instance NFData X12'
+
+-- id for data types with strict fields fully optimizes up to 12x1
+x12'_id :: X12' -> X12'
+x12'_id = to . from
+
+x12'_lens :: Lens' X12' Integer
+x12'_lens = gfield @"x12'_f1"
+
+-- X16
+
+instance NFData X16
+
+x16_id :: X16 -> X16
+x16_id = to . from
+
+x16_lens :: Lens' X16 Integer
+x16_lens = gfield @"x16_f1"
+
+-- X16'
+
+instance NFData X16'
+
+x16'_lens :: Lens' X16' Integer
+x16'_lens = gfield @"x16'_f1"
+
+-- X24
+
+instance NFData X24
+
+x24_id :: X24 -> X24
+x24_id = to . from

testsuite/tests/perf/compiler/T11068a.hs

+{-# LANGUAGE DeriveGeneric #-}
+module T11068a where
+
+import GHC.Generics
+
+data X1
+  = X11 { x1_f1 :: Integer
+        , x1_f2 :: Integer
+        , x1_f3 :: Integer
+        , x1_f4 :: Integer
+        , x1_f5 :: Integer
+        , x1_f6 :: Integer
+        , x1_f7 :: Integer
+        , x1_f8 :: Integer
+        , x1_f9 :: Integer
+        , x1_f10 :: Integer
+        , x1_f11 :: Integer
+        , x1_f12 :: Integer
+        , x1_f13 :: Integer
+        , x1_f14 :: Integer
+        , x1_f15 :: Integer
+        , x1_f16 :: Integer
+        , x1_f17 :: Integer
+        , x1_f18 :: Integer
+        , x1_f19 :: Integer
+        , x1_f20 :: Integer
+        , x1_f21 :: Integer
+        , x1_f22 :: Integer
+        , x1_f23 :: Integer
+        , x1_f24 :: Integer
+        , x1_f25 :: Integer
+        , x1_f26 :: Integer
+        , x1_f27 :: Integer
+        , x1_f28 :: Integer
+        , x1_f29 :: Integer
+        , x1_f30 :: Integer
+        , x1_f31 :: Integer
+        , x1_f32 :: Integer
+        , x1_f33 :: Integer
+        , x1_f34 :: Integer
+        , x1_f35 :: Integer
+        , x1_f36 :: Integer
+        , x1_f37 :: Integer
+        , x1_f38 :: Integer
+        , x1_f39 :: Integer
+        , x1_f40 :: Integer
+        , x1_f41 :: Integer
+        , x1_f42 :: Integer
+        , x1_f43 :: Integer
+        , x1_f44 :: Integer
+        , x1_f45 :: Integer
+        , x1_f46 :: Integer
+        , x1_f47 :: Integer
+        , x1_f48 :: Integer
+        , x1_f49 :: Integer
+        , x1_f50 :: Integer
+        , x1_f51 :: Integer
+        , x1_f52 :: Integer
+        , x1_f53 :: Integer
+        , x1_f54 :: Integer
+        , x1_f55 :: Integer
+        , x1_f56 :: Integer
+        , x1_f57 :: Integer
+        , x1_f58 :: Integer
+        , x1_f59 :: Integer
+        , x1_f60 :: Integer
+        , x1_f61 :: Integer
+        , x1_f62 :: Integer
+        , x1_f63 :: Integer
+        , x1_f64 :: Integer
+        , x1_f65 :: Integer
+        , x1_f66 :: Integer
+        , x1_f67 :: Integer
+        , x1_f68 :: Integer
+        , x1_f69 :: Integer
+        , x1_f70 :: Integer
+        , x1_f71 :: Integer
+        , x1_f72 :: Integer
+        , x1_f73 :: Integer
+        , x1_f74 :: Integer
+        , x1_f75 :: Integer
+        , x1_f76 :: Integer
+        , x1_f77 :: Integer
+        , x1_f78 :: Integer
+        , x1_f79 :: Integer
+        , x1_f80 :: Integer
+        , x1_f81 :: Integer
+        , x1_f82 :: Integer
+        , x1_f83 :: Integer
+        , x1_f84 :: Integer
+        , x1_f85 :: Integer
+        , x1_f86 :: Integer
+        , x1_f87 :: Integer
+        , x1_f88 :: Integer
+        , x1_f89 :: Integer
+        , x1_f90 :: Integer
+        , x1_f91 :: Integer
+        , x1_f92 :: Integer
+        , x1_f93 :: Integer
+        , x1_f94 :: Integer
+        , x1_f95 :: Integer
+        , x1_f96 :: Integer
+        , x1_f97 :: Integer
+        , x1_f98 :: Integer
+        , x1_f99 :: Integer
+        , x1_f100 :: Integer
+        } deriving Generic
+
+data X1'
+  = X1'1 { x1'_f1 :: !Integer
+         , x1'_f2 :: !Integer
+         , x1'_f3 :: !Integer
+         , x1'_f4 :: !Integer
+         , x1'_f5 :: !Integer
+         , x1'_f6 :: !Integer
+         , x1'_f7 :: !Integer
+         , x1'_f8 :: !Integer
+         , x1'_f9 :: !Integer
+         , x1'_f10 :: !Integer
+         , x1'_f11 :: !Integer
+         , x1'_f12 :: !Integer
+         , x1'_f13 :: !Integer
+         , x1'_f14 :: !Integer
+         , x1'_f15 :: !Integer
+         , x1'_f16 :: !Integer
+         , x1'_f17 :: !Integer
+         , x1'_f18 :: !Integer
+         , x1'_f19 :: !Integer
+         , x1'_f20 :: !Integer
+         , x1'_f21 :: !Integer
+         , x1'_f22 :: !Integer
+         , x1'_f23 :: !Integer
+         , x1'_f24 :: !Integer
+         , x1'_f25 :: !Integer
+         , x1'_f26 :: !Integer
+         , x1'_f27 :: !Integer
+         , x1'_f28 :: !Integer
+         , x1'_f29 :: !Integer
+         , x1'_f30 :: !Integer
+         , x1'_f31 :: !Integer
+         , x1'_f32 :: !Integer
+         , x1'_f33 :: !Integer
+         , x1'_f34 :: !Integer
+         , x1'_f35 :: !Integer
+         , x1'_f36 :: !Integer
+         , x1'_f37 :: !Integer
+         , x1'_f38 :: !Integer
+         , x1'_f39 :: !Integer
+         , x1'_f40 :: !Integer
+         , x1'_f41 :: !Integer
+         , x1'_f42 :: !Integer
+         , x1'_f43 :: !Integer
+         , x1'_f44 :: !Integer
+         , x1'_f45 :: !Integer
+         , x1'_f46 :: !Integer
+         , x1'_f47 :: !Integer
+         , x1'_f48 :: !Integer
+         , x1'_f49 :: !Integer
+         , x1'_f50 :: !Integer
+         , x1'_f51 :: !Integer
+         , x1'_f52 :: !Integer
+         , x1'_f53 :: !Integer
+         , x1'_f54 :: !Integer
+         , x1'_f55 :: !Integer
+         , x1'_f56 :: !Integer
+         , x1'_f57 :: !Integer
+         , x1'_f58 :: !Integer
+         , x1'_f59 :: !Integer
+         , x1'_f60 :: !Integer
+         , x1'_f61 :: !Integer
+         , x1'_f62 :: !Integer
+         , x1'_f63 :: !Integer
+         , x1'_f64 :: !Integer
+         , x1'_f65 :: !Integer
+         , x1'_f66 :: !Integer
+         , x1'_f67 :: !Integer
+         , x1'_f68 :: !Integer
+         , x1'_f69 :: !Integer
+         , x1'_f70 :: !Integer
+         , x1'_f71 :: !Integer
+         , x1'_f72 :: !Integer
+         , x1'_f73 :: !Integer
+         , x1'_f74 :: !Integer
+         , x1'_f75 :: !Integer
+         , x1'_f76 :: !Integer
+         , x1'_f77 :: !Integer
+         , x1'_f78 :: !Integer
+         , x1'_f79 :: !Integer
+         , x1'_f80 :: !Integer
+         , x1'_f81 :: !Integer
+         , x1'_f82 :: !Integer
+         , x1'_f83 :: !Integer
+         , x1'_f84 :: !Integer
+         , x1'_f85 :: !Integer
+         , x1'_f86 :: !Integer
+         , x1'_f87 :: !Integer