From bb742b3f0600408a9f2c6df1a7358500d3997252 Mon Sep 17 00:00:00 2001 From: Nathan Maxson Date: Tue, 13 Jun 2023 19:33:18 +0300 Subject: [PATCH 01/18] resolve for overloaded-record-dot (checkpoint) --- hls-plugin-api/src/Ide/Types.hs | 64 ++++++++--- .../hls-overloaded-record-dot-plugin.cabal | 1 + .../src/Ide/Plugin/OverloadedRecordDot.hs | 107 ++++++++++++++---- 3 files changed, 135 insertions(+), 37 deletions(-) diff --git a/hls-plugin-api/src/Ide/Types.hs b/hls-plugin-api/src/Ide/Types.hs index c32b7173d0..460a890201 100644 --- a/hls-plugin-api/src/Ide/Types.hs +++ b/hls-plugin-api/src/Ide/Types.hs @@ -403,19 +403,8 @@ instance PluginMethod Request Method_TextDocumentCodeAction where where uri = msgParams ^. L.textDocument . L.uri -instance PluginRequestMethod Method_TextDocumentCodeAction where - combineResponses _method _config (ClientCapabilities _ textDocCaps _ _ _ _) (CodeActionParams _ _ _ _ context) resps = - InL $ fmap compat $ filter wasRequested $ concat $ mapMaybe nullToMaybe $ toList resps - where - compat :: (Command |? CodeAction) -> (Command |? CodeAction) - compat x@(InL _) = x - compat x@(InR action) - | Just _ <- textDocCaps >>= _codeAction >>= _codeActionLiteralSupport - = x - | otherwise = InL cmd - where - cmd = mkLspCommand "hls" "fallbackCodeAction" (action ^. L.title) (Just cmdParams) - cmdParams = [toJSON (FallbackCodeActionParams (action ^. L.edit) (action ^. L.command))] +instance PluginMethod Request Method_CodeActionResolve where + pluginEnabled _ msgParams pluginDesc config = pluginEnabledConfig plcCodeActionsOn (configForPlugin config pluginDesc) wasRequested :: (Command |? CodeAction) -> Bool wasRequested (InL _) = True @@ -464,6 +453,10 @@ instance PluginMethod Request Method_TextDocumentCodeLens where where uri = msgParams ^. L.textDocument . L.uri +instance PluginMethod Request Method_CodeLensResolve where + pluginEnabled _ msgParams pluginDesc config = pluginEnabledConfig plcCodeLensOn (configForPlugin config pluginDesc) + + instance PluginMethod Request Method_TextDocumentRename where pluginEnabled _ msgParams pluginDesc config = pluginResponsible uri pluginDesc && pluginEnabledConfig plcRenameOn (configForPlugin config pluginDesc) @@ -535,6 +528,44 @@ instance PluginMethod Request (Method_CustomMethod m) where pluginEnabled _ _ _ _ = True --- +instance PluginRequestMethod Method_TextDocumentCodeAction where + combineResponses _method _config (ClientCapabilities _ textDocCaps _ _ _ _) (CodeActionParams _ _ _ _ context) resps = + InL $ fmap compat $ filter wasRequested $ concat $ mapMaybe nullToMaybe $ toList resps + where + compat :: (Command |? CodeAction) -> (Command |? CodeAction) + compat x@(InL _) = x + compat x@(InR action) + | Just _ <- textDocCaps >>= _codeAction >>= _codeActionLiteralSupport + = x + | otherwise = InL cmd + where + cmd = mkLspCommand "hls" "fallbackCodeAction" (action ^. L.title) (Just cmdParams) + cmdParams = [toJSON (FallbackCodeActionParams (action ^. L.edit) (action ^. L.command))] + + wasRequested :: (Command |? CodeAction) -> Bool + wasRequested (InL _) = True + wasRequested (InR ca) + | Nothing <- _only context = True + | Just allowed <- _only context + -- See https://github.com/microsoft/language-server-protocol/issues/970 + -- This is somewhat vague, but due to the hierarchical nature of action kinds, we + -- should check whether the requested kind is a *prefix* of the action kind. + -- That means, for example, we will return actions with kinds `quickfix.import` and + -- `quickfix.somethingElse` if the requested kind is `quickfix`. + , Just caKind <- ca ^. L.kind = any (\k -> k `codeActionKindSubsumes` caKind) allowed + | otherwise = False + + -- Copied form lsp-types 1.6 to get compilation working. May make more + -- sense to add it back to lsp-types 2.0 + -- | Does the first 'CodeActionKind' subsume the other one, hierarchically. Reflexive. + codeActionKindSubsumes :: CodeActionKind -> CodeActionKind -> Bool + -- Simple but ugly implementation: prefix on the string representation + codeActionKindSubsumes parent child = toEnumBaseType parent `T.isPrefixOf` toEnumBaseType child + +instance PluginRequestMethod Method_CodeActionResolve where + -- TODO: Make a more serious combineResponses function + combineResponses _ _ _ _ (x :| _) = x + instance PluginRequestMethod Method_TextDocumentDefinition where combineResponses _ _ _ _ (x :| _) = x @@ -552,6 +583,10 @@ instance PluginRequestMethod Method_WorkspaceSymbol where instance PluginRequestMethod Method_TextDocumentCodeLens where +instance PluginRequestMethod Method_CodeLensResolve where + -- TODO: Make a more serious combineResponses function + combineResponses _ _ _ _ (x :| _) = x + instance PluginRequestMethod Method_TextDocumentRename where instance PluginRequestMethod Method_TextDocumentHover where @@ -949,7 +984,8 @@ instance HasTracing WorkspaceSymbolParams where instance HasTracing CallHierarchyIncomingCallsParams instance HasTracing CallHierarchyOutgoingCallsParams instance HasTracing CompletionItem - +instance HasTracing CodeLens +instance HasTracing CodeAction -- --------------------------------------------------------------------- {-# NOINLINE pROCESS_ID #-} diff --git a/plugins/hls-overloaded-record-dot-plugin/hls-overloaded-record-dot-plugin.cabal b/plugins/hls-overloaded-record-dot-plugin/hls-overloaded-record-dot-plugin.cabal index 8010c90f26..65022f0193 100644 --- a/plugins/hls-overloaded-record-dot-plugin/hls-overloaded-record-dot-plugin.cabal +++ b/plugins/hls-overloaded-record-dot-plugin/hls-overloaded-record-dot-plugin.cabal @@ -30,6 +30,7 @@ library exposed-modules: Ide.Plugin.OverloadedRecordDot build-depends: , base >=4.16 && <5 + , aeson , ghcide , hls-plugin-api , lsp diff --git a/plugins/hls-overloaded-record-dot-plugin/src/Ide/Plugin/OverloadedRecordDot.hs b/plugins/hls-overloaded-record-dot-plugin/src/Ide/Plugin/OverloadedRecordDot.hs index 5dc7ea586b..05f324ed5d 100644 --- a/plugins/hls-overloaded-record-dot-plugin/src/Ide/Plugin/OverloadedRecordDot.hs +++ b/plugins/hls-overloaded-record-dot-plugin/src/Ide/Plugin/OverloadedRecordDot.hs @@ -13,16 +13,24 @@ module Ide.Plugin.OverloadedRecordDot -- based off of Berk Okzuturk's hls-explicit-records-fields-plugin -import Control.Lens ((^.)) +import Control.Lens (_Just, (^.), (^?)) +import Control.Monad (replicateM) import Control.Monad.IO.Class (MonadIO, liftIO) +import Control.Monad.Trans.Class (lift) import Control.Monad.Trans.Except (ExceptT) +import Data.Aeson (FromJSON, ToJSON, decode, + encode, fromJSON, toJSON) import Data.Generics (GenericQ, everything, everythingBut, mkQ) +import qualified Data.IntMap.Strict as IntMap import qualified Data.Map as Map -import Data.Maybe (mapMaybe, maybeToList) +import Data.Maybe (fromJust, mapMaybe, + maybeToList) import Data.Text (Text) +import Data.Unique import Development.IDE (IdeState, NormalizedFilePath, + NormalizedUri, Pretty (..), Range, Recorder (..), Rules, WithPriority (..), @@ -76,6 +84,7 @@ import Ide.Types (PluginDescriptor (..), PluginMethodHandler, defaultPluginDescriptor, mkPluginHandler) +import Language.LSP.Protocol.Lens (HasChanges (changes)) import qualified Language.LSP.Protocol.Lens as L import Language.LSP.Protocol.Message (Method (..), SMethod (..)) @@ -83,10 +92,12 @@ import Language.LSP.Protocol.Types (CodeAction (..), CodeActionKind (CodeActionKind_RefactorRewrite), CodeActionParams (..), Command, TextEdit (..), + Uri (..), WorkspaceEdit (WorkspaceEdit), fromNormalizedUri, normalizedFilePathToUri, type (|?) (..)) +import Language.LSP.Server (getClientCapabilities) data Log = LogShake Shake.Log | LogCollectedRecordSelectors [RecordSelectorExpr] @@ -105,7 +116,8 @@ instance Hashable CollectRecordSelectors instance NFData CollectRecordSelectors data CollectRecordSelectorsResult = CRSR - { recordInfos :: RangeMap RecordSelectorExpr + { records :: RangeMap Int + , recordInfos :: IntMap.IntMap RecordSelectorExpr , enabledExtensions :: [Extension] } deriving (Generic) @@ -135,56 +147,102 @@ instance Pretty RecordSelectorExpr where instance NFData RecordSelectorExpr where rnf = rwhnf +data ORDResolveData = ORDRD { + uri :: NormalizedFilePath +, uniqueID :: Int +} deriving (Generic, Show) +instance ToJSON ORDResolveData +instance FromJSON ORDResolveData + +-- TODO: move the orphans to their packages +instance ToJSON NormalizedFilePath +instance FromJSON NormalizedFilePath +instance ToJSON NormalizedUri +instance FromJSON NormalizedUri descriptor :: Recorder (WithPriority Log) -> PluginId -> PluginDescriptor IdeState descriptor recorder plId = (defaultPluginDescriptor plId) { pluginHandlers = - mkPluginHandler SMethod_TextDocumentCodeAction codeActionProvider + mkPluginHandler SMethod_TextDocumentCodeAction codeActionProvider <> mkPluginHandler SMethod_CodeActionResolve resolveProvider , pluginRules = collectRecSelsRule recorder } +resolveProvider :: PluginMethodHandler IdeState 'Method_CodeActionResolve +resolveProvider ideState pId ca@(CodeAction _ _ _ _ _ _ _ (Just resData)) = + pluginResponse $ do + case decode . encode $ resData of + Just (ORDRD nfp int) -> do + CRSR _ crsDetails exts <- collectRecSelResult ideState nfp + pragma <- getFirstPragma pId ideState nfp + let pragmaEdit = + if OverloadedRecordDot `elem` exts + then Nothing + else Just $ insertNewPragma pragma OverloadedRecordDot + edits (Just crs) = convertRecordSelectors crs : maybeToList pragmaEdit + edits _ = [] + changes = Just $ WorkspaceEdit + (Just (Map.singleton (fromNormalizedUri + (normalizedFilePathToUri nfp)) + (edits (IntMap.lookup int crsDetails)))) + Nothing Nothing + pure $ ca {_edit = changes} + _ -> pure ca + codeActionProvider :: PluginMethodHandler IdeState 'Method_TextDocumentCodeAction codeActionProvider ideState pId (CodeActionParams _ _ caDocId caRange _) = pluginResponse $ do nfp <- getNormalizedFilePath (caDocId ^. L.uri) pragma <- getFirstPragma pId ideState nfp - CRSR crsMap exts <- collectRecSelResult ideState nfp - let pragmaEdit = + caps <- lift getClientCapabilities + CRSR crsMap crsDetails exts <- collectRecSelResult ideState nfp + let supportsResolve :: Maybe Bool + supportsResolve = caps ^? L.textDocument . _Just . L.codeAction . _Just . L.dataSupport . _Just + pragmaEdit = if OverloadedRecordDot `elem` exts then Nothing else Just $ insertNewPragma pragma OverloadedRecordDot - edits crs = convertRecordSelectors crs : maybeToList pragmaEdit - changes crs = - Just $ Map.singleton (fromNormalizedUri + edits (Just crs) = convertRecordSelectors crs : maybeToList pragmaEdit + edits _ = [] + changes crsM crsD = + case supportsResolve of + Just True -> Just $ WorkspaceEdit + (Just (Map.singleton (fromNormalizedUri (normalizedFilePathToUri nfp)) - (edits crs) - mkCodeAction crs = InR CodeAction + (edits (IntMap.lookup crsM crsD)))) + Nothing Nothing + _ -> Nothing + resolveData crsM = + case supportsResolve of + Just True -> Just $ toJSON $ ORDRD nfp crsM + _ -> Nothing + mkCodeAction crsD crsM = InR CodeAction { -- We pass the record selector to the title function, so that -- we can have the name of the record selector in the title of -- the codeAction. This allows the user can easily distinguish -- between the different codeActions when using nested record -- selectors, the disadvantage is we need to print out the -- name of the record selector which will decrease performance - _title = mkCodeActionTitle exts crs + _title = mkCodeActionTitle exts crsM crsD , _kind = Just CodeActionKind_RefactorRewrite , _diagnostics = Nothing , _isPreferred = Nothing , _disabled = Nothing - , _edit = Just $ WorkspaceEdit (changes crs) Nothing Nothing + , _edit = changes crsM crsD , _command = Nothing - , _data_ = Nothing + , _data_ = resolveData crsM } - actions = map mkCodeAction (RangeMap.filterByRange caRange crsMap) + actions = map (mkCodeAction crsDetails) (RangeMap.filterByRange caRange crsMap) pure $ InL actions where - mkCodeActionTitle :: [Extension] -> RecordSelectorExpr-> Text - mkCodeActionTitle exts (RecordSelectorExpr _ se _) = + mkCodeActionTitle :: [Extension] -> Int -> IntMap.IntMap RecordSelectorExpr-> Text + mkCodeActionTitle exts crsM crsD = if OverloadedRecordDot `elem` exts then title else title <> " (needs extension: OverloadedRecordDot)" where - title = "Convert `" <> name <> "` to record dot syntax" - name = printOutputable se + title = "Convert `" <> name (IntMap.lookup crsM crsD) <> "` to record dot syntax" + name (Just (RecordSelectorExpr _ se _)) = printOutputable se + name _ = "" collectRecSelsRule :: Recorder (WithPriority Log) -> Rules () collectRecSelsRule recorder = define (cmapWithPrio LogShake recorder) $ @@ -201,11 +259,14 @@ collectRecSelsRule recorder = define (cmapWithPrio LogShake recorder) $ -- the OverloadedRecordDot pragma exts = getEnabledExtensions tmr recSels = mapMaybe (rewriteRange pm) (getRecordSelectors tmr) + uniques <- liftIO $ replicateM (length recSels) (hashUnique <$> newUnique) logWith recorder Debug (LogCollectedRecordSelectors recSels) - let -- We need the rangeMap to be able to filter by range later - crsMap :: RangeMap RecordSelectorExpr - crsMap = RangeMap.fromList location recSels - pure ([], CRSR <$> Just crsMap <*> Just exts) + let crsDetails = IntMap.fromList $ zip uniques recSels + -- We need the rangeMap to be able to filter by range later + crsMap :: RangeMap Int + crsMap = RangeMap.fromList (location . (\x-> fromJust $ IntMap.lookup x crsDetails)) uniques + crsDetails :: IntMap.IntMap RecordSelectorExpr + pure ([], CRSR <$> Just crsMap <*> Just crsDetails <*> Just exts) where getEnabledExtensions :: TcModuleResult -> [Extension] getEnabledExtensions = getExtensions . tmrParsed getRecordSelectors :: TcModuleResult -> [RecordSelectorExpr] From be71eb9e858409d93dca3933076559cfa6cc19ed Mon Sep 17 00:00:00 2001 From: Nathan Maxson Date: Wed, 14 Jun 2023 15:17:46 +0300 Subject: [PATCH 02/18] resolve support works on VSCode (tests need to be redone) --- .../src/Ide/Plugin/OverloadedRecordDot.hs | 24 +++++++++---------- 1 file changed, 11 insertions(+), 13 deletions(-) diff --git a/plugins/hls-overloaded-record-dot-plugin/src/Ide/Plugin/OverloadedRecordDot.hs b/plugins/hls-overloaded-record-dot-plugin/src/Ide/Plugin/OverloadedRecordDot.hs index 05f324ed5d..fafeefed9d 100644 --- a/plugins/hls-overloaded-record-dot-plugin/src/Ide/Plugin/OverloadedRecordDot.hs +++ b/plugins/hls-overloaded-record-dot-plugin/src/Ide/Plugin/OverloadedRecordDot.hs @@ -18,8 +18,8 @@ import Control.Monad (replicateM) import Control.Monad.IO.Class (MonadIO, liftIO) import Control.Monad.Trans.Class (lift) import Control.Monad.Trans.Except (ExceptT) -import Data.Aeson (FromJSON, ToJSON, decode, - encode, fromJSON, toJSON) +import Data.Aeson (FromJSON, Result (..), + ToJSON, fromJSON, toJSON) import Data.Generics (GenericQ, everything, everythingBut, mkQ) import qualified Data.IntMap.Strict as IntMap @@ -148,30 +148,28 @@ instance NFData RecordSelectorExpr where rnf = rwhnf data ORDResolveData = ORDRD { - uri :: NormalizedFilePath + uri :: Uri , uniqueID :: Int } deriving (Generic, Show) instance ToJSON ORDResolveData instance FromJSON ORDResolveData --- TODO: move the orphans to their packages -instance ToJSON NormalizedFilePath -instance FromJSON NormalizedFilePath -instance ToJSON NormalizedUri -instance FromJSON NormalizedUri descriptor :: Recorder (WithPriority Log) -> PluginId -> PluginDescriptor IdeState descriptor recorder plId = (defaultPluginDescriptor plId) { pluginHandlers = - mkPluginHandler SMethod_TextDocumentCodeAction codeActionProvider <> mkPluginHandler SMethod_CodeActionResolve resolveProvider + mkPluginHandler SMethod_TextDocumentCodeAction codeActionProvider + <> mkPluginHandler SMethod_CodeActionResolve resolveProvider + , pluginRules = collectRecSelsRule recorder } resolveProvider :: PluginMethodHandler IdeState 'Method_CodeActionResolve resolveProvider ideState pId ca@(CodeAction _ _ _ _ _ _ _ (Just resData)) = pluginResponse $ do - case decode . encode $ resData of - Just (ORDRD nfp int) -> do + case fromJSON $ resData of + Success (ORDRD uri int) -> do + nfp <- getNormalizedFilePath uri CRSR _ crsDetails exts <- collectRecSelResult ideState nfp pragma <- getFirstPragma pId ideState nfp let pragmaEdit = @@ -205,7 +203,7 @@ codeActionProvider ideState pId (CodeActionParams _ _ caDocId caRange _) = edits _ = [] changes crsM crsD = case supportsResolve of - Just True -> Just $ WorkspaceEdit + Just False -> Just $ WorkspaceEdit (Just (Map.singleton (fromNormalizedUri (normalizedFilePathToUri nfp)) (edits (IntMap.lookup crsM crsD)))) @@ -213,7 +211,7 @@ codeActionProvider ideState pId (CodeActionParams _ _ caDocId caRange _) = _ -> Nothing resolveData crsM = case supportsResolve of - Just True -> Just $ toJSON $ ORDRD nfp crsM + Just True -> Just $ toJSON $ ORDRD (caDocId ^. L.uri) crsM _ -> Nothing mkCodeAction crsD crsM = InR CodeAction { -- We pass the record selector to the title function, so that From fb21134e885929e16de159106f8da0ae3da00358 Mon Sep 17 00:00:00 2001 From: Nathan Maxson Date: Thu, 15 Jun 2023 19:21:24 +0300 Subject: [PATCH 03/18] Tests for both resolve and non resolve variants --- .../hls-overloaded-record-dot-plugin.cabal | 3 + .../src/Ide/Plugin/OverloadedRecordDot.hs | 2 +- .../test/Main.hs | 76 +++++++++++++++++-- 3 files changed, 73 insertions(+), 8 deletions(-) diff --git a/plugins/hls-overloaded-record-dot-plugin/hls-overloaded-record-dot-plugin.cabal b/plugins/hls-overloaded-record-dot-plugin/hls-overloaded-record-dot-plugin.cabal index 65022f0193..40789fedea 100644 --- a/plugins/hls-overloaded-record-dot-plugin/hls-overloaded-record-dot-plugin.cabal +++ b/plugins/hls-overloaded-record-dot-plugin/hls-overloaded-record-dot-plugin.cabal @@ -59,8 +59,11 @@ test-suite tests build-depends: , base , filepath + , ghcide , text , hls-overloaded-record-dot-plugin + , lens , lsp-test + , lsp-types , hls-test-utils diff --git a/plugins/hls-overloaded-record-dot-plugin/src/Ide/Plugin/OverloadedRecordDot.hs b/plugins/hls-overloaded-record-dot-plugin/src/Ide/Plugin/OverloadedRecordDot.hs index fafeefed9d..440067ac17 100644 --- a/plugins/hls-overloaded-record-dot-plugin/src/Ide/Plugin/OverloadedRecordDot.hs +++ b/plugins/hls-overloaded-record-dot-plugin/src/Ide/Plugin/OverloadedRecordDot.hs @@ -27,7 +27,7 @@ import qualified Data.Map as Map import Data.Maybe (fromJust, mapMaybe, maybeToList) import Data.Text (Text) -import Data.Unique +import Data.Unique (hashUnique, newUnique) import Development.IDE (IdeState, NormalizedFilePath, NormalizedUri, diff --git a/plugins/hls-overloaded-record-dot-plugin/test/Main.hs b/plugins/hls-overloaded-record-dot-plugin/test/Main.hs index 7780c83acd..643113f4f6 100644 --- a/plugins/hls-overloaded-record-dot-plugin/test/Main.hs +++ b/plugins/hls-overloaded-record-dot-plugin/test/Main.hs @@ -5,22 +5,34 @@ module Main ( main ) where +import Control.Lens (_Just, set, (^.)) import Data.Either (rights) +import Data.Functor (void) import qualified Data.Text as T +import qualified Data.Text.Lazy as TL +import qualified Data.Text.Lazy.Encoding as TL +import Development.IDE.Types.Logger (Doc, Logger (Logger), + Pretty (pretty), + Priority (Debug), + Recorder (Recorder, logger_), + WithPriority (WithPriority, priority), + cfilter, cmapWithPrio, + makeDefaultStderrRecorder) import qualified Ide.Plugin.OverloadedRecordDot as OverloadedRecordDot -import System.FilePath (()) +import Language.LSP.Protocol.Lens as L +import System.FilePath ((<.>), ()) import Test.Hls - main :: IO () -main = defaultTestRunner test +main = + defaultTestRunner test plugin :: PluginTestDescriptor OverloadedRecordDot.Log plugin = mkPluginTestDescriptor OverloadedRecordDot.descriptor "overloaded-record-dot" test :: TestTree -test = testGroup "overloaded-record-dot" - [ mkTest "Simple" "Simple" "name" 10 7 10 15, +test = testGroup "overloaded-record-dot" $ + [testGroup "without resolve" [ mkTest "Simple" "Simple" "name" 10 7 10 15, mkTest "NoPragmaNeeded" "NoPragmaNeeded" "name" 11 7 11 15, mkTest "NestedParens" "NestedParens" "name" 15 7 15 24, mkTest "NestedDot" "NestedDot" "name" 17 7 17 22, @@ -28,13 +40,29 @@ test = testGroup "overloaded-record-dot" mkTest "MultilineCase" "MultilineCase" "name" 10 7 12 15, mkTest "Multiline" "Multiline" "name" 10 7 11 15, mkTest "MultilineExpanded" "MultilineExpanded" "owner" 28 8 28 19 - ] + ], + testGroup "with Resolve" [ mkResolveTest "Simple" "Simple" "name" 10 7 10 15, + mkResolveTest "NoPragmaNeeded" "NoPragmaNeeded" "name" 11 7 11 15, + mkResolveTest "NestedParens" "NestedParens" "name" 15 7 15 24, + mkResolveTest "NestedDot" "NestedDot" "name" 17 7 17 22, + mkResolveTest "NestedDollar" "NestedDollar" "name" 15 7 15 24, + mkResolveTest "MultilineCase" "MultilineCase" "name" 10 7 12 15, + mkResolveTest "Multiline" "Multiline" "name" 10 7 11 15, + mkResolveTest "MultilineExpanded" "MultilineExpanded" "owner" 28 8 28 19 + ]] mkTest :: TestName -> FilePath -> T.Text -> UInt -> UInt -> UInt -> UInt -> TestTree mkTest title fp selectorName x1 y1 x2 y2 = - goldenWithHaskellDoc plugin title testDataDir fp "expected" "hs" $ \doc -> do + goldenWithHaskellAndCaps noResolveCaps plugin title testDataDir fp "expected" "hs" $ \doc -> do (act:_) <- getExplicitFieldsActions doc selectorName x1 y1 x2 y2 executeCodeAction act + where noResolveCaps = set (L.textDocument . _Just . L.codeAction . _Just . L.dataSupport . _Just) False fullCaps + +mkResolveTest :: TestName -> FilePath -> T.Text -> UInt -> UInt -> UInt -> UInt -> TestTree +mkResolveTest title fp selectorName x1 y1 x2 y2 = + goldenWithHaskellDoc plugin title testDataDir fp "expected" "hs" $ \doc -> do + ((Right act):_) <- getAndResolveExplicitFieldsActions doc selectorName x1 y1 x2 y2 + executeCodeAction act getExplicitFieldsActions :: TextDocumentIdentifier @@ -46,6 +74,19 @@ getExplicitFieldsActions doc selectorName x1 y1 x2 y2 = where range = Range (Position x1 y1) (Position x2 y2) +getAndResolveExplicitFieldsActions + :: TextDocumentIdentifier + -> T.Text + -> UInt -> UInt -> UInt -> UInt + -> Session [Either ResponseError CodeAction] +getAndResolveExplicitFieldsActions doc selectorName x1 y1 x2 y2 = do + actions <- findExplicitFieldsAction selectorName <$> getCodeActions doc range + rsp <- mapM (request SMethod_CodeActionResolve) actions + pure $ (^. L.result) <$> rsp + + where + range = Range (Position x1 y1) (Position x2 y2) + findExplicitFieldsAction :: T.Text -> [a |? CodeAction] -> [CodeAction] findExplicitFieldsAction selectorName = filter (isExplicitFieldsCodeAction selectorName) . rights . map toEither @@ -55,3 +96,24 @@ isExplicitFieldsCodeAction selectorName CodeAction {_title} = testDataDir :: FilePath testDataDir = "test" "testdata" + +goldenWithHaskellAndCaps + :: Pretty b + => ClientCapabilities + -> PluginTestDescriptor b + -> TestName + -> FilePath + -> FilePath + -> FilePath + -> FilePath + -> (TextDocumentIdentifier -> Session ()) + -> TestTree +goldenWithHaskellAndCaps clientCaps plugin title testDataDir path desc ext act = + goldenGitDiff title (testDataDir path <.> desc <.> ext) + $ runSessionWithServerAndCaps plugin clientCaps testDataDir + $ TL.encodeUtf8 . TL.fromStrict + <$> do + doc <- openDoc (path <.> ext) "haskell" + void waitForBuildQueue + act doc + documentContents doc From f347ebc85f00e0ecd24157c6438028b4c1647429 Mon Sep 17 00:00:00 2001 From: Nathan Maxson Date: Mon, 19 Jun 2023 15:37:20 +0300 Subject: [PATCH 04/18] Added more tests --- .../test/Main.hs | 15 +- .../test/testdata/Benchmark.expected.hs | 1805 +++++++++++++++++ .../test/testdata/Benchmark.hs | 1804 ++++++++++++++++ 3 files changed, 3621 insertions(+), 3 deletions(-) create mode 100644 plugins/hls-overloaded-record-dot-plugin/test/testdata/Benchmark.expected.hs create mode 100644 plugins/hls-overloaded-record-dot-plugin/test/testdata/Benchmark.hs diff --git a/plugins/hls-overloaded-record-dot-plugin/test/Main.hs b/plugins/hls-overloaded-record-dot-plugin/test/Main.hs index 643113f4f6..f943d0e7e4 100644 --- a/plugins/hls-overloaded-record-dot-plugin/test/Main.hs +++ b/plugins/hls-overloaded-record-dot-plugin/test/Main.hs @@ -31,8 +31,10 @@ plugin :: PluginTestDescriptor OverloadedRecordDot.Log plugin = mkPluginTestDescriptor OverloadedRecordDot.descriptor "overloaded-record-dot" test :: TestTree -test = testGroup "overloaded-record-dot" $ - [testGroup "without resolve" [ mkTest "Simple" "Simple" "name" 10 7 10 15, +test = testGroup "overloaded-record-dot" + [testGroup + "without resolve" + [ mkTest "Simple" "Simple" "name" 10 7 10 15, mkTest "NoPragmaNeeded" "NoPragmaNeeded" "name" 11 7 11 15, mkTest "NestedParens" "NestedParens" "name" 15 7 15 24, mkTest "NestedDot" "NestedDot" "name" 17 7 17 22, @@ -41,7 +43,9 @@ test = testGroup "overloaded-record-dot" $ mkTest "Multiline" "Multiline" "name" 10 7 11 15, mkTest "MultilineExpanded" "MultilineExpanded" "owner" 28 8 28 19 ], - testGroup "with Resolve" [ mkResolveTest "Simple" "Simple" "name" 10 7 10 15, + testGroup + "with Resolve" + [ mkResolveTest "Simple" "Simple" "name" 10 7 10 15, mkResolveTest "NoPragmaNeeded" "NoPragmaNeeded" "name" 11 7 11 15, mkResolveTest "NestedParens" "NestedParens" "name" 15 7 15 24, mkResolveTest "NestedDot" "NestedDot" "name" 17 7 17 22, @@ -49,6 +53,11 @@ test = testGroup "overloaded-record-dot" $ mkResolveTest "MultilineCase" "MultilineCase" "name" 10 7 12 15, mkResolveTest "Multiline" "Multiline" "name" 10 7 11 15, mkResolveTest "MultilineExpanded" "MultilineExpanded" "owner" 28 8 28 19 + ], + testGroup + "benchmark" + [ mkTest "Benchmark without resolve" "Benchmark" "name1298" 1797 11 1797 27, + mkResolveTest "Benchmark with resolve" "Benchmark" "name1298" 1797 11 1797 27 ]] mkTest :: TestName -> FilePath -> T.Text -> UInt -> UInt -> UInt -> UInt -> TestTree diff --git a/plugins/hls-overloaded-record-dot-plugin/test/testdata/Benchmark.expected.hs b/plugins/hls-overloaded-record-dot-plugin/test/testdata/Benchmark.expected.hs new file mode 100644 index 0000000000..3f9bba1011 --- /dev/null +++ b/plugins/hls-overloaded-record-dot-plugin/test/testdata/Benchmark.expected.hs @@ -0,0 +1,1805 @@ +{-# LANGUAGE OverloadedRecordDot #-} + +main :: IO () +main = do + putStrLn test1000 + +data Happy1000 = Happy1000 {name1000 :: String, age1000 :: Int, happy1000 :: Bool} +man1000 :: Happy1000 +man1000 = Happy1000 {name1000 = "Happy", age1000 = 1, happy1000 = True} +test1000 :: String +test1000 = name1000 man1000 + +data Happy1001 = Happy1001 {name1001 :: String, age1001 :: Int, happy1001 :: Bool} +man1001 :: Happy1001 +man1001 = Happy1001 {name1001 = "Happy", age1001 = 1, happy1001 = True} +test1001 :: String +test1001 = name1001 man1001 + +data Happy1002 = Happy1002 {name1002 :: String, age1002 :: Int, happy1002 :: Bool} +man1002 :: Happy1002 +man1002 = Happy1002 {name1002 = "Happy", age1002 = 1, happy1002 = True} +test1002 :: String +test1002 = name1002 man1002 + +data Happy1003 = Happy1003 {name1003 :: String, age1003 :: Int, happy1003 :: Bool} +man1003 :: Happy1003 +man1003 = Happy1003 {name1003 = "Happy", age1003 = 1, happy1003 = True} +test1003 :: String +test1003 = name1003 man1003 + +data Happy1004 = Happy1004 {name1004 :: String, age1004 :: Int, happy1004 :: Bool} +man1004 :: Happy1004 +man1004 = Happy1004 {name1004 = "Happy", age1004 = 1, happy1004 = True} +test1004 :: String +test1004 = name1004 man1004 + +data Happy1005 = Happy1005 {name1005 :: String, age1005 :: Int, happy1005 :: Bool} +man1005 :: Happy1005 +man1005 = Happy1005 {name1005 = "Happy", age1005 = 1, happy1005 = True} +test1005 :: String +test1005 = name1005 man1005 + +data Happy1006 = Happy1006 {name1006 :: String, age1006 :: Int, happy1006 :: Bool} +man1006 :: Happy1006 +man1006 = Happy1006 {name1006 = "Happy", age1006 = 1, happy1006 = True} +test1006 :: String +test1006 = name1006 man1006 + +data Happy1007 = Happy1007 {name1007 :: String, age1007 :: Int, happy1007 :: Bool} +man1007 :: Happy1007 +man1007 = Happy1007 {name1007 = "Happy", age1007 = 1, happy1007 = True} +test1007 :: String +test1007 = name1007 man1007 + +data Happy1008 = Happy1008 {name1008 :: String, age1008 :: Int, happy1008 :: Bool} +man1008 :: Happy1008 +man1008 = Happy1008 {name1008 = "Happy", age1008 = 1, happy1008 = True} +test1008 :: String +test1008 = name1008 man1008 + +data Happy1009 = Happy1009 {name1009 :: String, age1009 :: Int, happy1009 :: Bool} +man1009 :: Happy1009 +man1009 = Happy1009 {name1009 = "Happy", age1009 = 1, happy1009 = True} +test1009 :: String +test1009 = name1009 man1009 + +data Happy1010 = Happy1010 {name1010 :: String, age1010 :: Int, happy1010 :: Bool} +man1010 :: Happy1010 +man1010 = Happy1010 {name1010 = "Happy", age1010 = 1, happy1010 = True} +test1010 :: String +test1010 = name1010 man1010 + +data Happy1011 = Happy1011 {name1011 :: String, age1011 :: Int, happy1011 :: Bool} +man1011 :: Happy1011 +man1011 = Happy1011 {name1011 = "Happy", age1011 = 1, happy1011 = True} +test1011 :: String +test1011 = name1011 man1011 + +data Happy1012 = Happy1012 {name1012 :: String, age1012 :: Int, happy1012 :: Bool} +man1012 :: Happy1012 +man1012 = Happy1012 {name1012 = "Happy", age1012 = 1, happy1012 = True} +test1012 :: String +test1012 = name1012 man1012 + +data Happy1013 = Happy1013 {name1013 :: String, age1013 :: Int, happy1013 :: Bool} +man1013 :: Happy1013 +man1013 = Happy1013 {name1013 = "Happy", age1013 = 1, happy1013 = True} +test1013 :: String +test1013 = name1013 man1013 + +data Happy1014 = Happy1014 {name1014 :: String, age1014 :: Int, happy1014 :: Bool} +man1014 :: Happy1014 +man1014 = Happy1014 {name1014 = "Happy", age1014 = 1, happy1014 = True} +test1014 :: String +test1014 = name1014 man1014 + +data Happy1015 = Happy1015 {name1015 :: String, age1015 :: Int, happy1015 :: Bool} +man1015 :: Happy1015 +man1015 = Happy1015 {name1015 = "Happy", age1015 = 1, happy1015 = True} +test1015 :: String +test1015 = name1015 man1015 + +data Happy1016 = Happy1016 {name1016 :: String, age1016 :: Int, happy1016 :: Bool} +man1016 :: Happy1016 +man1016 = Happy1016 {name1016 = "Happy", age1016 = 1, happy1016 = True} +test1016 :: String +test1016 = name1016 man1016 + +data Happy1017 = Happy1017 {name1017 :: String, age1017 :: Int, happy1017 :: Bool} +man1017 :: Happy1017 +man1017 = Happy1017 {name1017 = "Happy", age1017 = 1, happy1017 = True} +test1017 :: String +test1017 = name1017 man1017 + +data Happy1018 = Happy1018 {name1018 :: String, age1018 :: Int, happy1018 :: Bool} +man1018 :: Happy1018 +man1018 = Happy1018 {name1018 = "Happy", age1018 = 1, happy1018 = True} +test1018 :: String +test1018 = name1018 man1018 + +data Happy1019 = Happy1019 {name1019 :: String, age1019 :: Int, happy1019 :: Bool} +man1019 :: Happy1019 +man1019 = Happy1019 {name1019 = "Happy", age1019 = 1, happy1019 = True} +test1019 :: String +test1019 = name1019 man1019 + +data Happy1020 = Happy1020 {name1020 :: String, age1020 :: Int, happy1020 :: Bool} +man1020 :: Happy1020 +man1020 = Happy1020 {name1020 = "Happy", age1020 = 1, happy1020 = True} +test1020 :: String +test1020 = name1020 man1020 + +data Happy1021 = Happy1021 {name1021 :: String, age1021 :: Int, happy1021 :: Bool} +man1021 :: Happy1021 +man1021 = Happy1021 {name1021 = "Happy", age1021 = 1, happy1021 = True} +test1021 :: String +test1021 = name1021 man1021 + +data Happy1022 = Happy1022 {name1022 :: String, age1022 :: Int, happy1022 :: Bool} +man1022 :: Happy1022 +man1022 = Happy1022 {name1022 = "Happy", age1022 = 1, happy1022 = True} +test1022 :: String +test1022 = name1022 man1022 + +data Happy1023 = Happy1023 {name1023 :: String, age1023 :: Int, happy1023 :: Bool} +man1023 :: Happy1023 +man1023 = Happy1023 {name1023 = "Happy", age1023 = 1, happy1023 = True} +test1023 :: String +test1023 = name1023 man1023 + +data Happy1024 = Happy1024 {name1024 :: String, age1024 :: Int, happy1024 :: Bool} +man1024 :: Happy1024 +man1024 = Happy1024 {name1024 = "Happy", age1024 = 1, happy1024 = True} +test1024 :: String +test1024 = name1024 man1024 + +data Happy1025 = Happy1025 {name1025 :: String, age1025 :: Int, happy1025 :: Bool} +man1025 :: Happy1025 +man1025 = Happy1025 {name1025 = "Happy", age1025 = 1, happy1025 = True} +test1025 :: String +test1025 = name1025 man1025 + +data Happy1026 = Happy1026 {name1026 :: String, age1026 :: Int, happy1026 :: Bool} +man1026 :: Happy1026 +man1026 = Happy1026 {name1026 = "Happy", age1026 = 1, happy1026 = True} +test1026 :: String +test1026 = name1026 man1026 + +data Happy1027 = Happy1027 {name1027 :: String, age1027 :: Int, happy1027 :: Bool} +man1027 :: Happy1027 +man1027 = Happy1027 {name1027 = "Happy", age1027 = 1, happy1027 = True} +test1027 :: String +test1027 = name1027 man1027 + +data Happy1028 = Happy1028 {name1028 :: String, age1028 :: Int, happy1028 :: Bool} +man1028 :: Happy1028 +man1028 = Happy1028 {name1028 = "Happy", age1028 = 1, happy1028 = True} +test1028 :: String +test1028 = name1028 man1028 + +data Happy1029 = Happy1029 {name1029 :: String, age1029 :: Int, happy1029 :: Bool} +man1029 :: Happy1029 +man1029 = Happy1029 {name1029 = "Happy", age1029 = 1, happy1029 = True} +test1029 :: String +test1029 = name1029 man1029 + +data Happy1030 = Happy1030 {name1030 :: String, age1030 :: Int, happy1030 :: Bool} +man1030 :: Happy1030 +man1030 = Happy1030 {name1030 = "Happy", age1030 = 1, happy1030 = True} +test1030 :: String +test1030 = name1030 man1030 + +data Happy1031 = Happy1031 {name1031 :: String, age1031 :: Int, happy1031 :: Bool} +man1031 :: Happy1031 +man1031 = Happy1031 {name1031 = "Happy", age1031 = 1, happy1031 = True} +test1031 :: String +test1031 = name1031 man1031 + +data Happy1032 = Happy1032 {name1032 :: String, age1032 :: Int, happy1032 :: Bool} +man1032 :: Happy1032 +man1032 = Happy1032 {name1032 = "Happy", age1032 = 1, happy1032 = True} +test1032 :: String +test1032 = name1032 man1032 + +data Happy1033 = Happy1033 {name1033 :: String, age1033 :: Int, happy1033 :: Bool} +man1033 :: Happy1033 +man1033 = Happy1033 {name1033 = "Happy", age1033 = 1, happy1033 = True} +test1033 :: String +test1033 = name1033 man1033 + +data Happy1034 = Happy1034 {name1034 :: String, age1034 :: Int, happy1034 :: Bool} +man1034 :: Happy1034 +man1034 = Happy1034 {name1034 = "Happy", age1034 = 1, happy1034 = True} +test1034 :: String +test1034 = name1034 man1034 + +data Happy1035 = Happy1035 {name1035 :: String, age1035 :: Int, happy1035 :: Bool} +man1035 :: Happy1035 +man1035 = Happy1035 {name1035 = "Happy", age1035 = 1, happy1035 = True} +test1035 :: String +test1035 = name1035 man1035 + +data Happy1036 = Happy1036 {name1036 :: String, age1036 :: Int, happy1036 :: Bool} +man1036 :: Happy1036 +man1036 = Happy1036 {name1036 = "Happy", age1036 = 1, happy1036 = True} +test1036 :: String +test1036 = name1036 man1036 + +data Happy1037 = Happy1037 {name1037 :: String, age1037 :: Int, happy1037 :: Bool} +man1037 :: Happy1037 +man1037 = Happy1037 {name1037 = "Happy", age1037 = 1, happy1037 = True} +test1037 :: String +test1037 = name1037 man1037 + +data Happy1038 = Happy1038 {name1038 :: String, age1038 :: Int, happy1038 :: Bool} +man1038 :: Happy1038 +man1038 = Happy1038 {name1038 = "Happy", age1038 = 1, happy1038 = True} +test1038 :: String +test1038 = name1038 man1038 + +data Happy1039 = Happy1039 {name1039 :: String, age1039 :: Int, happy1039 :: Bool} +man1039 :: Happy1039 +man1039 = Happy1039 {name1039 = "Happy", age1039 = 1, happy1039 = True} +test1039 :: String +test1039 = name1039 man1039 + +data Happy1040 = Happy1040 {name1040 :: String, age1040 :: Int, happy1040 :: Bool} +man1040 :: Happy1040 +man1040 = Happy1040 {name1040 = "Happy", age1040 = 1, happy1040 = True} +test1040 :: String +test1040 = name1040 man1040 + +data Happy1041 = Happy1041 {name1041 :: String, age1041 :: Int, happy1041 :: Bool} +man1041 :: Happy1041 +man1041 = Happy1041 {name1041 = "Happy", age1041 = 1, happy1041 = True} +test1041 :: String +test1041 = name1041 man1041 + +data Happy1042 = Happy1042 {name1042 :: String, age1042 :: Int, happy1042 :: Bool} +man1042 :: Happy1042 +man1042 = Happy1042 {name1042 = "Happy", age1042 = 1, happy1042 = True} +test1042 :: String +test1042 = name1042 man1042 + +data Happy1043 = Happy1043 {name1043 :: String, age1043 :: Int, happy1043 :: Bool} +man1043 :: Happy1043 +man1043 = Happy1043 {name1043 = "Happy", age1043 = 1, happy1043 = True} +test1043 :: String +test1043 = name1043 man1043 + +data Happy1044 = Happy1044 {name1044 :: String, age1044 :: Int, happy1044 :: Bool} +man1044 :: Happy1044 +man1044 = Happy1044 {name1044 = "Happy", age1044 = 1, happy1044 = True} +test1044 :: String +test1044 = name1044 man1044 + +data Happy1045 = Happy1045 {name1045 :: String, age1045 :: Int, happy1045 :: Bool} +man1045 :: Happy1045 +man1045 = Happy1045 {name1045 = "Happy", age1045 = 1, happy1045 = True} +test1045 :: String +test1045 = name1045 man1045 + +data Happy1046 = Happy1046 {name1046 :: String, age1046 :: Int, happy1046 :: Bool} +man1046 :: Happy1046 +man1046 = Happy1046 {name1046 = "Happy", age1046 = 1, happy1046 = True} +test1046 :: String +test1046 = name1046 man1046 + +data Happy1047 = Happy1047 {name1047 :: String, age1047 :: Int, happy1047 :: Bool} +man1047 :: Happy1047 +man1047 = Happy1047 {name1047 = "Happy", age1047 = 1, happy1047 = True} +test1047 :: String +test1047 = name1047 man1047 + +data Happy1048 = Happy1048 {name1048 :: String, age1048 :: Int, happy1048 :: Bool} +man1048 :: Happy1048 +man1048 = Happy1048 {name1048 = "Happy", age1048 = 1, happy1048 = True} +test1048 :: String +test1048 = name1048 man1048 + +data Happy1049 = Happy1049 {name1049 :: String, age1049 :: Int, happy1049 :: Bool} +man1049 :: Happy1049 +man1049 = Happy1049 {name1049 = "Happy", age1049 = 1, happy1049 = True} +test1049 :: String +test1049 = name1049 man1049 + +data Happy1050 = Happy1050 {name1050 :: String, age1050 :: Int, happy1050 :: Bool} +man1050 :: Happy1050 +man1050 = Happy1050 {name1050 = "Happy", age1050 = 1, happy1050 = True} +test1050 :: String +test1050 = name1050 man1050 + +data Happy1051 = Happy1051 {name1051 :: String, age1051 :: Int, happy1051 :: Bool} +man1051 :: Happy1051 +man1051 = Happy1051 {name1051 = "Happy", age1051 = 1, happy1051 = True} +test1051 :: String +test1051 = name1051 man1051 + +data Happy1052 = Happy1052 {name1052 :: String, age1052 :: Int, happy1052 :: Bool} +man1052 :: Happy1052 +man1052 = Happy1052 {name1052 = "Happy", age1052 = 1, happy1052 = True} +test1052 :: String +test1052 = name1052 man1052 + +data Happy1053 = Happy1053 {name1053 :: String, age1053 :: Int, happy1053 :: Bool} +man1053 :: Happy1053 +man1053 = Happy1053 {name1053 = "Happy", age1053 = 1, happy1053 = True} +test1053 :: String +test1053 = name1053 man1053 + +data Happy1054 = Happy1054 {name1054 :: String, age1054 :: Int, happy1054 :: Bool} +man1054 :: Happy1054 +man1054 = Happy1054 {name1054 = "Happy", age1054 = 1, happy1054 = True} +test1054 :: String +test1054 = name1054 man1054 + +data Happy1055 = Happy1055 {name1055 :: String, age1055 :: Int, happy1055 :: Bool} +man1055 :: Happy1055 +man1055 = Happy1055 {name1055 = "Happy", age1055 = 1, happy1055 = True} +test1055 :: String +test1055 = name1055 man1055 + +data Happy1056 = Happy1056 {name1056 :: String, age1056 :: Int, happy1056 :: Bool} +man1056 :: Happy1056 +man1056 = Happy1056 {name1056 = "Happy", age1056 = 1, happy1056 = True} +test1056 :: String +test1056 = name1056 man1056 + +data Happy1057 = Happy1057 {name1057 :: String, age1057 :: Int, happy1057 :: Bool} +man1057 :: Happy1057 +man1057 = Happy1057 {name1057 = "Happy", age1057 = 1, happy1057 = True} +test1057 :: String +test1057 = name1057 man1057 + +data Happy1058 = Happy1058 {name1058 :: String, age1058 :: Int, happy1058 :: Bool} +man1058 :: Happy1058 +man1058 = Happy1058 {name1058 = "Happy", age1058 = 1, happy1058 = True} +test1058 :: String +test1058 = name1058 man1058 + +data Happy1059 = Happy1059 {name1059 :: String, age1059 :: Int, happy1059 :: Bool} +man1059 :: Happy1059 +man1059 = Happy1059 {name1059 = "Happy", age1059 = 1, happy1059 = True} +test1059 :: String +test1059 = name1059 man1059 + +data Happy1060 = Happy1060 {name1060 :: String, age1060 :: Int, happy1060 :: Bool} +man1060 :: Happy1060 +man1060 = Happy1060 {name1060 = "Happy", age1060 = 1, happy1060 = True} +test1060 :: String +test1060 = name1060 man1060 + +data Happy1061 = Happy1061 {name1061 :: String, age1061 :: Int, happy1061 :: Bool} +man1061 :: Happy1061 +man1061 = Happy1061 {name1061 = "Happy", age1061 = 1, happy1061 = True} +test1061 :: String +test1061 = name1061 man1061 + +data Happy1062 = Happy1062 {name1062 :: String, age1062 :: Int, happy1062 :: Bool} +man1062 :: Happy1062 +man1062 = Happy1062 {name1062 = "Happy", age1062 = 1, happy1062 = True} +test1062 :: String +test1062 = name1062 man1062 + +data Happy1063 = Happy1063 {name1063 :: String, age1063 :: Int, happy1063 :: Bool} +man1063 :: Happy1063 +man1063 = Happy1063 {name1063 = "Happy", age1063 = 1, happy1063 = True} +test1063 :: String +test1063 = name1063 man1063 + +data Happy1064 = Happy1064 {name1064 :: String, age1064 :: Int, happy1064 :: Bool} +man1064 :: Happy1064 +man1064 = Happy1064 {name1064 = "Happy", age1064 = 1, happy1064 = True} +test1064 :: String +test1064 = name1064 man1064 + +data Happy1065 = Happy1065 {name1065 :: String, age1065 :: Int, happy1065 :: Bool} +man1065 :: Happy1065 +man1065 = Happy1065 {name1065 = "Happy", age1065 = 1, happy1065 = True} +test1065 :: String +test1065 = name1065 man1065 + +data Happy1066 = Happy1066 {name1066 :: String, age1066 :: Int, happy1066 :: Bool} +man1066 :: Happy1066 +man1066 = Happy1066 {name1066 = "Happy", age1066 = 1, happy1066 = True} +test1066 :: String +test1066 = name1066 man1066 + +data Happy1067 = Happy1067 {name1067 :: String, age1067 :: Int, happy1067 :: Bool} +man1067 :: Happy1067 +man1067 = Happy1067 {name1067 = "Happy", age1067 = 1, happy1067 = True} +test1067 :: String +test1067 = name1067 man1067 + +data Happy1068 = Happy1068 {name1068 :: String, age1068 :: Int, happy1068 :: Bool} +man1068 :: Happy1068 +man1068 = Happy1068 {name1068 = "Happy", age1068 = 1, happy1068 = True} +test1068 :: String +test1068 = name1068 man1068 + +data Happy1069 = Happy1069 {name1069 :: String, age1069 :: Int, happy1069 :: Bool} +man1069 :: Happy1069 +man1069 = Happy1069 {name1069 = "Happy", age1069 = 1, happy1069 = True} +test1069 :: String +test1069 = name1069 man1069 + +data Happy1070 = Happy1070 {name1070 :: String, age1070 :: Int, happy1070 :: Bool} +man1070 :: Happy1070 +man1070 = Happy1070 {name1070 = "Happy", age1070 = 1, happy1070 = True} +test1070 :: String +test1070 = name1070 man1070 + +data Happy1071 = Happy1071 {name1071 :: String, age1071 :: Int, happy1071 :: Bool} +man1071 :: Happy1071 +man1071 = Happy1071 {name1071 = "Happy", age1071 = 1, happy1071 = True} +test1071 :: String +test1071 = name1071 man1071 + +data Happy1072 = Happy1072 {name1072 :: String, age1072 :: Int, happy1072 :: Bool} +man1072 :: Happy1072 +man1072 = Happy1072 {name1072 = "Happy", age1072 = 1, happy1072 = True} +test1072 :: String +test1072 = name1072 man1072 + +data Happy1073 = Happy1073 {name1073 :: String, age1073 :: Int, happy1073 :: Bool} +man1073 :: Happy1073 +man1073 = Happy1073 {name1073 = "Happy", age1073 = 1, happy1073 = True} +test1073 :: String +test1073 = name1073 man1073 + +data Happy1074 = Happy1074 {name1074 :: String, age1074 :: Int, happy1074 :: Bool} +man1074 :: Happy1074 +man1074 = Happy1074 {name1074 = "Happy", age1074 = 1, happy1074 = True} +test1074 :: String +test1074 = name1074 man1074 + +data Happy1075 = Happy1075 {name1075 :: String, age1075 :: Int, happy1075 :: Bool} +man1075 :: Happy1075 +man1075 = Happy1075 {name1075 = "Happy", age1075 = 1, happy1075 = True} +test1075 :: String +test1075 = name1075 man1075 + +data Happy1076 = Happy1076 {name1076 :: String, age1076 :: Int, happy1076 :: Bool} +man1076 :: Happy1076 +man1076 = Happy1076 {name1076 = "Happy", age1076 = 1, happy1076 = True} +test1076 :: String +test1076 = name1076 man1076 + +data Happy1077 = Happy1077 {name1077 :: String, age1077 :: Int, happy1077 :: Bool} +man1077 :: Happy1077 +man1077 = Happy1077 {name1077 = "Happy", age1077 = 1, happy1077 = True} +test1077 :: String +test1077 = name1077 man1077 + +data Happy1078 = Happy1078 {name1078 :: String, age1078 :: Int, happy1078 :: Bool} +man1078 :: Happy1078 +man1078 = Happy1078 {name1078 = "Happy", age1078 = 1, happy1078 = True} +test1078 :: String +test1078 = name1078 man1078 + +data Happy1079 = Happy1079 {name1079 :: String, age1079 :: Int, happy1079 :: Bool} +man1079 :: Happy1079 +man1079 = Happy1079 {name1079 = "Happy", age1079 = 1, happy1079 = True} +test1079 :: String +test1079 = name1079 man1079 + +data Happy1080 = Happy1080 {name1080 :: String, age1080 :: Int, happy1080 :: Bool} +man1080 :: Happy1080 +man1080 = Happy1080 {name1080 = "Happy", age1080 = 1, happy1080 = True} +test1080 :: String +test1080 = name1080 man1080 + +data Happy1081 = Happy1081 {name1081 :: String, age1081 :: Int, happy1081 :: Bool} +man1081 :: Happy1081 +man1081 = Happy1081 {name1081 = "Happy", age1081 = 1, happy1081 = True} +test1081 :: String +test1081 = name1081 man1081 + +data Happy1082 = Happy1082 {name1082 :: String, age1082 :: Int, happy1082 :: Bool} +man1082 :: Happy1082 +man1082 = Happy1082 {name1082 = "Happy", age1082 = 1, happy1082 = True} +test1082 :: String +test1082 = name1082 man1082 + +data Happy1083 = Happy1083 {name1083 :: String, age1083 :: Int, happy1083 :: Bool} +man1083 :: Happy1083 +man1083 = Happy1083 {name1083 = "Happy", age1083 = 1, happy1083 = True} +test1083 :: String +test1083 = name1083 man1083 + +data Happy1084 = Happy1084 {name1084 :: String, age1084 :: Int, happy1084 :: Bool} +man1084 :: Happy1084 +man1084 = Happy1084 {name1084 = "Happy", age1084 = 1, happy1084 = True} +test1084 :: String +test1084 = name1084 man1084 + +data Happy1085 = Happy1085 {name1085 :: String, age1085 :: Int, happy1085 :: Bool} +man1085 :: Happy1085 +man1085 = Happy1085 {name1085 = "Happy", age1085 = 1, happy1085 = True} +test1085 :: String +test1085 = name1085 man1085 + +data Happy1086 = Happy1086 {name1086 :: String, age1086 :: Int, happy1086 :: Bool} +man1086 :: Happy1086 +man1086 = Happy1086 {name1086 = "Happy", age1086 = 1, happy1086 = True} +test1086 :: String +test1086 = name1086 man1086 + +data Happy1087 = Happy1087 {name1087 :: String, age1087 :: Int, happy1087 :: Bool} +man1087 :: Happy1087 +man1087 = Happy1087 {name1087 = "Happy", age1087 = 1, happy1087 = True} +test1087 :: String +test1087 = name1087 man1087 + +data Happy1088 = Happy1088 {name1088 :: String, age1088 :: Int, happy1088 :: Bool} +man1088 :: Happy1088 +man1088 = Happy1088 {name1088 = "Happy", age1088 = 1, happy1088 = True} +test1088 :: String +test1088 = name1088 man1088 + +data Happy1089 = Happy1089 {name1089 :: String, age1089 :: Int, happy1089 :: Bool} +man1089 :: Happy1089 +man1089 = Happy1089 {name1089 = "Happy", age1089 = 1, happy1089 = True} +test1089 :: String +test1089 = name1089 man1089 + +data Happy1090 = Happy1090 {name1090 :: String, age1090 :: Int, happy1090 :: Bool} +man1090 :: Happy1090 +man1090 = Happy1090 {name1090 = "Happy", age1090 = 1, happy1090 = True} +test1090 :: String +test1090 = name1090 man1090 + +data Happy1091 = Happy1091 {name1091 :: String, age1091 :: Int, happy1091 :: Bool} +man1091 :: Happy1091 +man1091 = Happy1091 {name1091 = "Happy", age1091 = 1, happy1091 = True} +test1091 :: String +test1091 = name1091 man1091 + +data Happy1092 = Happy1092 {name1092 :: String, age1092 :: Int, happy1092 :: Bool} +man1092 :: Happy1092 +man1092 = Happy1092 {name1092 = "Happy", age1092 = 1, happy1092 = True} +test1092 :: String +test1092 = name1092 man1092 + +data Happy1093 = Happy1093 {name1093 :: String, age1093 :: Int, happy1093 :: Bool} +man1093 :: Happy1093 +man1093 = Happy1093 {name1093 = "Happy", age1093 = 1, happy1093 = True} +test1093 :: String +test1093 = name1093 man1093 + +data Happy1094 = Happy1094 {name1094 :: String, age1094 :: Int, happy1094 :: Bool} +man1094 :: Happy1094 +man1094 = Happy1094 {name1094 = "Happy", age1094 = 1, happy1094 = True} +test1094 :: String +test1094 = name1094 man1094 + +data Happy1095 = Happy1095 {name1095 :: String, age1095 :: Int, happy1095 :: Bool} +man1095 :: Happy1095 +man1095 = Happy1095 {name1095 = "Happy", age1095 = 1, happy1095 = True} +test1095 :: String +test1095 = name1095 man1095 + +data Happy1096 = Happy1096 {name1096 :: String, age1096 :: Int, happy1096 :: Bool} +man1096 :: Happy1096 +man1096 = Happy1096 {name1096 = "Happy", age1096 = 1, happy1096 = True} +test1096 :: String +test1096 = name1096 man1096 + +data Happy1097 = Happy1097 {name1097 :: String, age1097 :: Int, happy1097 :: Bool} +man1097 :: Happy1097 +man1097 = Happy1097 {name1097 = "Happy", age1097 = 1, happy1097 = True} +test1097 :: String +test1097 = name1097 man1097 + +data Happy1098 = Happy1098 {name1098 :: String, age1098 :: Int, happy1098 :: Bool} +man1098 :: Happy1098 +man1098 = Happy1098 {name1098 = "Happy", age1098 = 1, happy1098 = True} +test1098 :: String +test1098 = name1098 man1098 + +data Happy1099 = Happy1099 {name1099 :: String, age1099 :: Int, happy1099 :: Bool} +man1099 :: Happy1099 +man1099 = Happy1099 {name1099 = "Happy", age1099 = 1, happy1099 = True} +test1099 :: String +test1099 = name1099 man1099 + +data Happy1100 = Happy1100 {name1100 :: String, age1100 :: Int, happy1100 :: Bool} +man1100 :: Happy1100 +man1100 = Happy1100 {name1100 = "Happy", age1100 = 1, happy1100 = True} +test1100 :: String +test1100 = name1100 man1100 + +data Happy1101 = Happy1101 {name1101 :: String, age1101 :: Int, happy1101 :: Bool} +man1101 :: Happy1101 +man1101 = Happy1101 {name1101 = "Happy", age1101 = 1, happy1101 = True} +test1101 :: String +test1101 = name1101 man1101 + +data Happy1102 = Happy1102 {name1102 :: String, age1102 :: Int, happy1102 :: Bool} +man1102 :: Happy1102 +man1102 = Happy1102 {name1102 = "Happy", age1102 = 1, happy1102 = True} +test1102 :: String +test1102 = name1102 man1102 + +data Happy1103 = Happy1103 {name1103 :: String, age1103 :: Int, happy1103 :: Bool} +man1103 :: Happy1103 +man1103 = Happy1103 {name1103 = "Happy", age1103 = 1, happy1103 = True} +test1103 :: String +test1103 = name1103 man1103 + +data Happy1104 = Happy1104 {name1104 :: String, age1104 :: Int, happy1104 :: Bool} +man1104 :: Happy1104 +man1104 = Happy1104 {name1104 = "Happy", age1104 = 1, happy1104 = True} +test1104 :: String +test1104 = name1104 man1104 + +data Happy1105 = Happy1105 {name1105 :: String, age1105 :: Int, happy1105 :: Bool} +man1105 :: Happy1105 +man1105 = Happy1105 {name1105 = "Happy", age1105 = 1, happy1105 = True} +test1105 :: String +test1105 = name1105 man1105 + +data Happy1106 = Happy1106 {name1106 :: String, age1106 :: Int, happy1106 :: Bool} +man1106 :: Happy1106 +man1106 = Happy1106 {name1106 = "Happy", age1106 = 1, happy1106 = True} +test1106 :: String +test1106 = name1106 man1106 + +data Happy1107 = Happy1107 {name1107 :: String, age1107 :: Int, happy1107 :: Bool} +man1107 :: Happy1107 +man1107 = Happy1107 {name1107 = "Happy", age1107 = 1, happy1107 = True} +test1107 :: String +test1107 = name1107 man1107 + +data Happy1108 = Happy1108 {name1108 :: String, age1108 :: Int, happy1108 :: Bool} +man1108 :: Happy1108 +man1108 = Happy1108 {name1108 = "Happy", age1108 = 1, happy1108 = True} +test1108 :: String +test1108 = name1108 man1108 + +data Happy1109 = Happy1109 {name1109 :: String, age1109 :: Int, happy1109 :: Bool} +man1109 :: Happy1109 +man1109 = Happy1109 {name1109 = "Happy", age1109 = 1, happy1109 = True} +test1109 :: String +test1109 = name1109 man1109 + +data Happy1110 = Happy1110 {name1110 :: String, age1110 :: Int, happy1110 :: Bool} +man1110 :: Happy1110 +man1110 = Happy1110 {name1110 = "Happy", age1110 = 1, happy1110 = True} +test1110 :: String +test1110 = name1110 man1110 + +data Happy1111 = Happy1111 {name1111 :: String, age1111 :: Int, happy1111 :: Bool} +man1111 :: Happy1111 +man1111 = Happy1111 {name1111 = "Happy", age1111 = 1, happy1111 = True} +test1111 :: String +test1111 = name1111 man1111 + +data Happy1112 = Happy1112 {name1112 :: String, age1112 :: Int, happy1112 :: Bool} +man1112 :: Happy1112 +man1112 = Happy1112 {name1112 = "Happy", age1112 = 1, happy1112 = True} +test1112 :: String +test1112 = name1112 man1112 + +data Happy1113 = Happy1113 {name1113 :: String, age1113 :: Int, happy1113 :: Bool} +man1113 :: Happy1113 +man1113 = Happy1113 {name1113 = "Happy", age1113 = 1, happy1113 = True} +test1113 :: String +test1113 = name1113 man1113 + +data Happy1114 = Happy1114 {name1114 :: String, age1114 :: Int, happy1114 :: Bool} +man1114 :: Happy1114 +man1114 = Happy1114 {name1114 = "Happy", age1114 = 1, happy1114 = True} +test1114 :: String +test1114 = name1114 man1114 + +data Happy1115 = Happy1115 {name1115 :: String, age1115 :: Int, happy1115 :: Bool} +man1115 :: Happy1115 +man1115 = Happy1115 {name1115 = "Happy", age1115 = 1, happy1115 = True} +test1115 :: String +test1115 = name1115 man1115 + +data Happy1116 = Happy1116 {name1116 :: String, age1116 :: Int, happy1116 :: Bool} +man1116 :: Happy1116 +man1116 = Happy1116 {name1116 = "Happy", age1116 = 1, happy1116 = True} +test1116 :: String +test1116 = name1116 man1116 + +data Happy1117 = Happy1117 {name1117 :: String, age1117 :: Int, happy1117 :: Bool} +man1117 :: Happy1117 +man1117 = Happy1117 {name1117 = "Happy", age1117 = 1, happy1117 = True} +test1117 :: String +test1117 = name1117 man1117 + +data Happy1118 = Happy1118 {name1118 :: String, age1118 :: Int, happy1118 :: Bool} +man1118 :: Happy1118 +man1118 = Happy1118 {name1118 = "Happy", age1118 = 1, happy1118 = True} +test1118 :: String +test1118 = name1118 man1118 + +data Happy1119 = Happy1119 {name1119 :: String, age1119 :: Int, happy1119 :: Bool} +man1119 :: Happy1119 +man1119 = Happy1119 {name1119 = "Happy", age1119 = 1, happy1119 = True} +test1119 :: String +test1119 = name1119 man1119 + +data Happy1120 = Happy1120 {name1120 :: String, age1120 :: Int, happy1120 :: Bool} +man1120 :: Happy1120 +man1120 = Happy1120 {name1120 = "Happy", age1120 = 1, happy1120 = True} +test1120 :: String +test1120 = name1120 man1120 + +data Happy1121 = Happy1121 {name1121 :: String, age1121 :: Int, happy1121 :: Bool} +man1121 :: Happy1121 +man1121 = Happy1121 {name1121 = "Happy", age1121 = 1, happy1121 = True} +test1121 :: String +test1121 = name1121 man1121 + +data Happy1122 = Happy1122 {name1122 :: String, age1122 :: Int, happy1122 :: Bool} +man1122 :: Happy1122 +man1122 = Happy1122 {name1122 = "Happy", age1122 = 1, happy1122 = True} +test1122 :: String +test1122 = name1122 man1122 + +data Happy1123 = Happy1123 {name1123 :: String, age1123 :: Int, happy1123 :: Bool} +man1123 :: Happy1123 +man1123 = Happy1123 {name1123 = "Happy", age1123 = 1, happy1123 = True} +test1123 :: String +test1123 = name1123 man1123 + +data Happy1124 = Happy1124 {name1124 :: String, age1124 :: Int, happy1124 :: Bool} +man1124 :: Happy1124 +man1124 = Happy1124 {name1124 = "Happy", age1124 = 1, happy1124 = True} +test1124 :: String +test1124 = name1124 man1124 + +data Happy1125 = Happy1125 {name1125 :: String, age1125 :: Int, happy1125 :: Bool} +man1125 :: Happy1125 +man1125 = Happy1125 {name1125 = "Happy", age1125 = 1, happy1125 = True} +test1125 :: String +test1125 = name1125 man1125 + +data Happy1126 = Happy1126 {name1126 :: String, age1126 :: Int, happy1126 :: Bool} +man1126 :: Happy1126 +man1126 = Happy1126 {name1126 = "Happy", age1126 = 1, happy1126 = True} +test1126 :: String +test1126 = name1126 man1126 + +data Happy1127 = Happy1127 {name1127 :: String, age1127 :: Int, happy1127 :: Bool} +man1127 :: Happy1127 +man1127 = Happy1127 {name1127 = "Happy", age1127 = 1, happy1127 = True} +test1127 :: String +test1127 = name1127 man1127 + +data Happy1128 = Happy1128 {name1128 :: String, age1128 :: Int, happy1128 :: Bool} +man1128 :: Happy1128 +man1128 = Happy1128 {name1128 = "Happy", age1128 = 1, happy1128 = True} +test1128 :: String +test1128 = name1128 man1128 + +data Happy1129 = Happy1129 {name1129 :: String, age1129 :: Int, happy1129 :: Bool} +man1129 :: Happy1129 +man1129 = Happy1129 {name1129 = "Happy", age1129 = 1, happy1129 = True} +test1129 :: String +test1129 = name1129 man1129 + +data Happy1130 = Happy1130 {name1130 :: String, age1130 :: Int, happy1130 :: Bool} +man1130 :: Happy1130 +man1130 = Happy1130 {name1130 = "Happy", age1130 = 1, happy1130 = True} +test1130 :: String +test1130 = name1130 man1130 + +data Happy1131 = Happy1131 {name1131 :: String, age1131 :: Int, happy1131 :: Bool} +man1131 :: Happy1131 +man1131 = Happy1131 {name1131 = "Happy", age1131 = 1, happy1131 = True} +test1131 :: String +test1131 = name1131 man1131 + +data Happy1132 = Happy1132 {name1132 :: String, age1132 :: Int, happy1132 :: Bool} +man1132 :: Happy1132 +man1132 = Happy1132 {name1132 = "Happy", age1132 = 1, happy1132 = True} +test1132 :: String +test1132 = name1132 man1132 + +data Happy1133 = Happy1133 {name1133 :: String, age1133 :: Int, happy1133 :: Bool} +man1133 :: Happy1133 +man1133 = Happy1133 {name1133 = "Happy", age1133 = 1, happy1133 = True} +test1133 :: String +test1133 = name1133 man1133 + +data Happy1134 = Happy1134 {name1134 :: String, age1134 :: Int, happy1134 :: Bool} +man1134 :: Happy1134 +man1134 = Happy1134 {name1134 = "Happy", age1134 = 1, happy1134 = True} +test1134 :: String +test1134 = name1134 man1134 + +data Happy1135 = Happy1135 {name1135 :: String, age1135 :: Int, happy1135 :: Bool} +man1135 :: Happy1135 +man1135 = Happy1135 {name1135 = "Happy", age1135 = 1, happy1135 = True} +test1135 :: String +test1135 = name1135 man1135 + +data Happy1136 = Happy1136 {name1136 :: String, age1136 :: Int, happy1136 :: Bool} +man1136 :: Happy1136 +man1136 = Happy1136 {name1136 = "Happy", age1136 = 1, happy1136 = True} +test1136 :: String +test1136 = name1136 man1136 + +data Happy1137 = Happy1137 {name1137 :: String, age1137 :: Int, happy1137 :: Bool} +man1137 :: Happy1137 +man1137 = Happy1137 {name1137 = "Happy", age1137 = 1, happy1137 = True} +test1137 :: String +test1137 = name1137 man1137 + +data Happy1138 = Happy1138 {name1138 :: String, age1138 :: Int, happy1138 :: Bool} +man1138 :: Happy1138 +man1138 = Happy1138 {name1138 = "Happy", age1138 = 1, happy1138 = True} +test1138 :: String +test1138 = name1138 man1138 + +data Happy1139 = Happy1139 {name1139 :: String, age1139 :: Int, happy1139 :: Bool} +man1139 :: Happy1139 +man1139 = Happy1139 {name1139 = "Happy", age1139 = 1, happy1139 = True} +test1139 :: String +test1139 = name1139 man1139 + +data Happy1140 = Happy1140 {name1140 :: String, age1140 :: Int, happy1140 :: Bool} +man1140 :: Happy1140 +man1140 = Happy1140 {name1140 = "Happy", age1140 = 1, happy1140 = True} +test1140 :: String +test1140 = name1140 man1140 + +data Happy1141 = Happy1141 {name1141 :: String, age1141 :: Int, happy1141 :: Bool} +man1141 :: Happy1141 +man1141 = Happy1141 {name1141 = "Happy", age1141 = 1, happy1141 = True} +test1141 :: String +test1141 = name1141 man1141 + +data Happy1142 = Happy1142 {name1142 :: String, age1142 :: Int, happy1142 :: Bool} +man1142 :: Happy1142 +man1142 = Happy1142 {name1142 = "Happy", age1142 = 1, happy1142 = True} +test1142 :: String +test1142 = name1142 man1142 + +data Happy1143 = Happy1143 {name1143 :: String, age1143 :: Int, happy1143 :: Bool} +man1143 :: Happy1143 +man1143 = Happy1143 {name1143 = "Happy", age1143 = 1, happy1143 = True} +test1143 :: String +test1143 = name1143 man1143 + +data Happy1144 = Happy1144 {name1144 :: String, age1144 :: Int, happy1144 :: Bool} +man1144 :: Happy1144 +man1144 = Happy1144 {name1144 = "Happy", age1144 = 1, happy1144 = True} +test1144 :: String +test1144 = name1144 man1144 + +data Happy1145 = Happy1145 {name1145 :: String, age1145 :: Int, happy1145 :: Bool} +man1145 :: Happy1145 +man1145 = Happy1145 {name1145 = "Happy", age1145 = 1, happy1145 = True} +test1145 :: String +test1145 = name1145 man1145 + +data Happy1146 = Happy1146 {name1146 :: String, age1146 :: Int, happy1146 :: Bool} +man1146 :: Happy1146 +man1146 = Happy1146 {name1146 = "Happy", age1146 = 1, happy1146 = True} +test1146 :: String +test1146 = name1146 man1146 + +data Happy1147 = Happy1147 {name1147 :: String, age1147 :: Int, happy1147 :: Bool} +man1147 :: Happy1147 +man1147 = Happy1147 {name1147 = "Happy", age1147 = 1, happy1147 = True} +test1147 :: String +test1147 = name1147 man1147 + +data Happy1148 = Happy1148 {name1148 :: String, age1148 :: Int, happy1148 :: Bool} +man1148 :: Happy1148 +man1148 = Happy1148 {name1148 = "Happy", age1148 = 1, happy1148 = True} +test1148 :: String +test1148 = name1148 man1148 + +data Happy1149 = Happy1149 {name1149 :: String, age1149 :: Int, happy1149 :: Bool} +man1149 :: Happy1149 +man1149 = Happy1149 {name1149 = "Happy", age1149 = 1, happy1149 = True} +test1149 :: String +test1149 = name1149 man1149 + +data Happy1150 = Happy1150 {name1150 :: String, age1150 :: Int, happy1150 :: Bool} +man1150 :: Happy1150 +man1150 = Happy1150 {name1150 = "Happy", age1150 = 1, happy1150 = True} +test1150 :: String +test1150 = name1150 man1150 + +data Happy1151 = Happy1151 {name1151 :: String, age1151 :: Int, happy1151 :: Bool} +man1151 :: Happy1151 +man1151 = Happy1151 {name1151 = "Happy", age1151 = 1, happy1151 = True} +test1151 :: String +test1151 = name1151 man1151 + +data Happy1152 = Happy1152 {name1152 :: String, age1152 :: Int, happy1152 :: Bool} +man1152 :: Happy1152 +man1152 = Happy1152 {name1152 = "Happy", age1152 = 1, happy1152 = True} +test1152 :: String +test1152 = name1152 man1152 + +data Happy1153 = Happy1153 {name1153 :: String, age1153 :: Int, happy1153 :: Bool} +man1153 :: Happy1153 +man1153 = Happy1153 {name1153 = "Happy", age1153 = 1, happy1153 = True} +test1153 :: String +test1153 = name1153 man1153 + +data Happy1154 = Happy1154 {name1154 :: String, age1154 :: Int, happy1154 :: Bool} +man1154 :: Happy1154 +man1154 = Happy1154 {name1154 = "Happy", age1154 = 1, happy1154 = True} +test1154 :: String +test1154 = name1154 man1154 + +data Happy1155 = Happy1155 {name1155 :: String, age1155 :: Int, happy1155 :: Bool} +man1155 :: Happy1155 +man1155 = Happy1155 {name1155 = "Happy", age1155 = 1, happy1155 = True} +test1155 :: String +test1155 = name1155 man1155 + +data Happy1156 = Happy1156 {name1156 :: String, age1156 :: Int, happy1156 :: Bool} +man1156 :: Happy1156 +man1156 = Happy1156 {name1156 = "Happy", age1156 = 1, happy1156 = True} +test1156 :: String +test1156 = name1156 man1156 + +data Happy1157 = Happy1157 {name1157 :: String, age1157 :: Int, happy1157 :: Bool} +man1157 :: Happy1157 +man1157 = Happy1157 {name1157 = "Happy", age1157 = 1, happy1157 = True} +test1157 :: String +test1157 = name1157 man1157 + +data Happy1158 = Happy1158 {name1158 :: String, age1158 :: Int, happy1158 :: Bool} +man1158 :: Happy1158 +man1158 = Happy1158 {name1158 = "Happy", age1158 = 1, happy1158 = True} +test1158 :: String +test1158 = name1158 man1158 + +data Happy1159 = Happy1159 {name1159 :: String, age1159 :: Int, happy1159 :: Bool} +man1159 :: Happy1159 +man1159 = Happy1159 {name1159 = "Happy", age1159 = 1, happy1159 = True} +test1159 :: String +test1159 = name1159 man1159 + +data Happy1160 = Happy1160 {name1160 :: String, age1160 :: Int, happy1160 :: Bool} +man1160 :: Happy1160 +man1160 = Happy1160 {name1160 = "Happy", age1160 = 1, happy1160 = True} +test1160 :: String +test1160 = name1160 man1160 + +data Happy1161 = Happy1161 {name1161 :: String, age1161 :: Int, happy1161 :: Bool} +man1161 :: Happy1161 +man1161 = Happy1161 {name1161 = "Happy", age1161 = 1, happy1161 = True} +test1161 :: String +test1161 = name1161 man1161 + +data Happy1162 = Happy1162 {name1162 :: String, age1162 :: Int, happy1162 :: Bool} +man1162 :: Happy1162 +man1162 = Happy1162 {name1162 = "Happy", age1162 = 1, happy1162 = True} +test1162 :: String +test1162 = name1162 man1162 + +data Happy1163 = Happy1163 {name1163 :: String, age1163 :: Int, happy1163 :: Bool} +man1163 :: Happy1163 +man1163 = Happy1163 {name1163 = "Happy", age1163 = 1, happy1163 = True} +test1163 :: String +test1163 = name1163 man1163 + +data Happy1164 = Happy1164 {name1164 :: String, age1164 :: Int, happy1164 :: Bool} +man1164 :: Happy1164 +man1164 = Happy1164 {name1164 = "Happy", age1164 = 1, happy1164 = True} +test1164 :: String +test1164 = name1164 man1164 + +data Happy1165 = Happy1165 {name1165 :: String, age1165 :: Int, happy1165 :: Bool} +man1165 :: Happy1165 +man1165 = Happy1165 {name1165 = "Happy", age1165 = 1, happy1165 = True} +test1165 :: String +test1165 = name1165 man1165 + +data Happy1166 = Happy1166 {name1166 :: String, age1166 :: Int, happy1166 :: Bool} +man1166 :: Happy1166 +man1166 = Happy1166 {name1166 = "Happy", age1166 = 1, happy1166 = True} +test1166 :: String +test1166 = name1166 man1166 + +data Happy1167 = Happy1167 {name1167 :: String, age1167 :: Int, happy1167 :: Bool} +man1167 :: Happy1167 +man1167 = Happy1167 {name1167 = "Happy", age1167 = 1, happy1167 = True} +test1167 :: String +test1167 = name1167 man1167 + +data Happy1168 = Happy1168 {name1168 :: String, age1168 :: Int, happy1168 :: Bool} +man1168 :: Happy1168 +man1168 = Happy1168 {name1168 = "Happy", age1168 = 1, happy1168 = True} +test1168 :: String +test1168 = name1168 man1168 + +data Happy1169 = Happy1169 {name1169 :: String, age1169 :: Int, happy1169 :: Bool} +man1169 :: Happy1169 +man1169 = Happy1169 {name1169 = "Happy", age1169 = 1, happy1169 = True} +test1169 :: String +test1169 = name1169 man1169 + +data Happy1170 = Happy1170 {name1170 :: String, age1170 :: Int, happy1170 :: Bool} +man1170 :: Happy1170 +man1170 = Happy1170 {name1170 = "Happy", age1170 = 1, happy1170 = True} +test1170 :: String +test1170 = name1170 man1170 + +data Happy1171 = Happy1171 {name1171 :: String, age1171 :: Int, happy1171 :: Bool} +man1171 :: Happy1171 +man1171 = Happy1171 {name1171 = "Happy", age1171 = 1, happy1171 = True} +test1171 :: String +test1171 = name1171 man1171 + +data Happy1172 = Happy1172 {name1172 :: String, age1172 :: Int, happy1172 :: Bool} +man1172 :: Happy1172 +man1172 = Happy1172 {name1172 = "Happy", age1172 = 1, happy1172 = True} +test1172 :: String +test1172 = name1172 man1172 + +data Happy1173 = Happy1173 {name1173 :: String, age1173 :: Int, happy1173 :: Bool} +man1173 :: Happy1173 +man1173 = Happy1173 {name1173 = "Happy", age1173 = 1, happy1173 = True} +test1173 :: String +test1173 = name1173 man1173 + +data Happy1174 = Happy1174 {name1174 :: String, age1174 :: Int, happy1174 :: Bool} +man1174 :: Happy1174 +man1174 = Happy1174 {name1174 = "Happy", age1174 = 1, happy1174 = True} +test1174 :: String +test1174 = name1174 man1174 + +data Happy1175 = Happy1175 {name1175 :: String, age1175 :: Int, happy1175 :: Bool} +man1175 :: Happy1175 +man1175 = Happy1175 {name1175 = "Happy", age1175 = 1, happy1175 = True} +test1175 :: String +test1175 = name1175 man1175 + +data Happy1176 = Happy1176 {name1176 :: String, age1176 :: Int, happy1176 :: Bool} +man1176 :: Happy1176 +man1176 = Happy1176 {name1176 = "Happy", age1176 = 1, happy1176 = True} +test1176 :: String +test1176 = name1176 man1176 + +data Happy1177 = Happy1177 {name1177 :: String, age1177 :: Int, happy1177 :: Bool} +man1177 :: Happy1177 +man1177 = Happy1177 {name1177 = "Happy", age1177 = 1, happy1177 = True} +test1177 :: String +test1177 = name1177 man1177 + +data Happy1178 = Happy1178 {name1178 :: String, age1178 :: Int, happy1178 :: Bool} +man1178 :: Happy1178 +man1178 = Happy1178 {name1178 = "Happy", age1178 = 1, happy1178 = True} +test1178 :: String +test1178 = name1178 man1178 + +data Happy1179 = Happy1179 {name1179 :: String, age1179 :: Int, happy1179 :: Bool} +man1179 :: Happy1179 +man1179 = Happy1179 {name1179 = "Happy", age1179 = 1, happy1179 = True} +test1179 :: String +test1179 = name1179 man1179 + +data Happy1180 = Happy1180 {name1180 :: String, age1180 :: Int, happy1180 :: Bool} +man1180 :: Happy1180 +man1180 = Happy1180 {name1180 = "Happy", age1180 = 1, happy1180 = True} +test1180 :: String +test1180 = name1180 man1180 + +data Happy1181 = Happy1181 {name1181 :: String, age1181 :: Int, happy1181 :: Bool} +man1181 :: Happy1181 +man1181 = Happy1181 {name1181 = "Happy", age1181 = 1, happy1181 = True} +test1181 :: String +test1181 = name1181 man1181 + +data Happy1182 = Happy1182 {name1182 :: String, age1182 :: Int, happy1182 :: Bool} +man1182 :: Happy1182 +man1182 = Happy1182 {name1182 = "Happy", age1182 = 1, happy1182 = True} +test1182 :: String +test1182 = name1182 man1182 + +data Happy1183 = Happy1183 {name1183 :: String, age1183 :: Int, happy1183 :: Bool} +man1183 :: Happy1183 +man1183 = Happy1183 {name1183 = "Happy", age1183 = 1, happy1183 = True} +test1183 :: String +test1183 = name1183 man1183 + +data Happy1184 = Happy1184 {name1184 :: String, age1184 :: Int, happy1184 :: Bool} +man1184 :: Happy1184 +man1184 = Happy1184 {name1184 = "Happy", age1184 = 1, happy1184 = True} +test1184 :: String +test1184 = name1184 man1184 + +data Happy1185 = Happy1185 {name1185 :: String, age1185 :: Int, happy1185 :: Bool} +man1185 :: Happy1185 +man1185 = Happy1185 {name1185 = "Happy", age1185 = 1, happy1185 = True} +test1185 :: String +test1185 = name1185 man1185 + +data Happy1186 = Happy1186 {name1186 :: String, age1186 :: Int, happy1186 :: Bool} +man1186 :: Happy1186 +man1186 = Happy1186 {name1186 = "Happy", age1186 = 1, happy1186 = True} +test1186 :: String +test1186 = name1186 man1186 + +data Happy1187 = Happy1187 {name1187 :: String, age1187 :: Int, happy1187 :: Bool} +man1187 :: Happy1187 +man1187 = Happy1187 {name1187 = "Happy", age1187 = 1, happy1187 = True} +test1187 :: String +test1187 = name1187 man1187 + +data Happy1188 = Happy1188 {name1188 :: String, age1188 :: Int, happy1188 :: Bool} +man1188 :: Happy1188 +man1188 = Happy1188 {name1188 = "Happy", age1188 = 1, happy1188 = True} +test1188 :: String +test1188 = name1188 man1188 + +data Happy1189 = Happy1189 {name1189 :: String, age1189 :: Int, happy1189 :: Bool} +man1189 :: Happy1189 +man1189 = Happy1189 {name1189 = "Happy", age1189 = 1, happy1189 = True} +test1189 :: String +test1189 = name1189 man1189 + +data Happy1190 = Happy1190 {name1190 :: String, age1190 :: Int, happy1190 :: Bool} +man1190 :: Happy1190 +man1190 = Happy1190 {name1190 = "Happy", age1190 = 1, happy1190 = True} +test1190 :: String +test1190 = name1190 man1190 + +data Happy1191 = Happy1191 {name1191 :: String, age1191 :: Int, happy1191 :: Bool} +man1191 :: Happy1191 +man1191 = Happy1191 {name1191 = "Happy", age1191 = 1, happy1191 = True} +test1191 :: String +test1191 = name1191 man1191 + +data Happy1192 = Happy1192 {name1192 :: String, age1192 :: Int, happy1192 :: Bool} +man1192 :: Happy1192 +man1192 = Happy1192 {name1192 = "Happy", age1192 = 1, happy1192 = True} +test1192 :: String +test1192 = name1192 man1192 + +data Happy1193 = Happy1193 {name1193 :: String, age1193 :: Int, happy1193 :: Bool} +man1193 :: Happy1193 +man1193 = Happy1193 {name1193 = "Happy", age1193 = 1, happy1193 = True} +test1193 :: String +test1193 = name1193 man1193 + +data Happy1194 = Happy1194 {name1194 :: String, age1194 :: Int, happy1194 :: Bool} +man1194 :: Happy1194 +man1194 = Happy1194 {name1194 = "Happy", age1194 = 1, happy1194 = True} +test1194 :: String +test1194 = name1194 man1194 + +data Happy1195 = Happy1195 {name1195 :: String, age1195 :: Int, happy1195 :: Bool} +man1195 :: Happy1195 +man1195 = Happy1195 {name1195 = "Happy", age1195 = 1, happy1195 = True} +test1195 :: String +test1195 = name1195 man1195 + +data Happy1196 = Happy1196 {name1196 :: String, age1196 :: Int, happy1196 :: Bool} +man1196 :: Happy1196 +man1196 = Happy1196 {name1196 = "Happy", age1196 = 1, happy1196 = True} +test1196 :: String +test1196 = name1196 man1196 + +data Happy1197 = Happy1197 {name1197 :: String, age1197 :: Int, happy1197 :: Bool} +man1197 :: Happy1197 +man1197 = Happy1197 {name1197 = "Happy", age1197 = 1, happy1197 = True} +test1197 :: String +test1197 = name1197 man1197 + +data Happy1198 = Happy1198 {name1198 :: String, age1198 :: Int, happy1198 :: Bool} +man1198 :: Happy1198 +man1198 = Happy1198 {name1198 = "Happy", age1198 = 1, happy1198 = True} +test1198 :: String +test1198 = name1198 man1198 + +data Happy1199 = Happy1199 {name1199 :: String, age1199 :: Int, happy1199 :: Bool} +man1199 :: Happy1199 +man1199 = Happy1199 {name1199 = "Happy", age1199 = 1, happy1199 = True} +test1199 :: String +test1199 = name1199 man1199 + +data Happy1200 = Happy1200 {name1200 :: String, age1200 :: Int, happy1200 :: Bool} +man1200 :: Happy1200 +man1200 = Happy1200 {name1200 = "Happy", age1200 = 1, happy1200 = True} +test1200 :: String +test1200 = name1200 man1200 + +data Happy1201 = Happy1201 {name1201 :: String, age1201 :: Int, happy1201 :: Bool} +man1201 :: Happy1201 +man1201 = Happy1201 {name1201 = "Happy", age1201 = 1, happy1201 = True} +test1201 :: String +test1201 = name1201 man1201 + +data Happy1202 = Happy1202 {name1202 :: String, age1202 :: Int, happy1202 :: Bool} +man1202 :: Happy1202 +man1202 = Happy1202 {name1202 = "Happy", age1202 = 1, happy1202 = True} +test1202 :: String +test1202 = name1202 man1202 + +data Happy1203 = Happy1203 {name1203 :: String, age1203 :: Int, happy1203 :: Bool} +man1203 :: Happy1203 +man1203 = Happy1203 {name1203 = "Happy", age1203 = 1, happy1203 = True} +test1203 :: String +test1203 = name1203 man1203 + +data Happy1204 = Happy1204 {name1204 :: String, age1204 :: Int, happy1204 :: Bool} +man1204 :: Happy1204 +man1204 = Happy1204 {name1204 = "Happy", age1204 = 1, happy1204 = True} +test1204 :: String +test1204 = name1204 man1204 + +data Happy1205 = Happy1205 {name1205 :: String, age1205 :: Int, happy1205 :: Bool} +man1205 :: Happy1205 +man1205 = Happy1205 {name1205 = "Happy", age1205 = 1, happy1205 = True} +test1205 :: String +test1205 = name1205 man1205 + +data Happy1206 = Happy1206 {name1206 :: String, age1206 :: Int, happy1206 :: Bool} +man1206 :: Happy1206 +man1206 = Happy1206 {name1206 = "Happy", age1206 = 1, happy1206 = True} +test1206 :: String +test1206 = name1206 man1206 + +data Happy1207 = Happy1207 {name1207 :: String, age1207 :: Int, happy1207 :: Bool} +man1207 :: Happy1207 +man1207 = Happy1207 {name1207 = "Happy", age1207 = 1, happy1207 = True} +test1207 :: String +test1207 = name1207 man1207 + +data Happy1208 = Happy1208 {name1208 :: String, age1208 :: Int, happy1208 :: Bool} +man1208 :: Happy1208 +man1208 = Happy1208 {name1208 = "Happy", age1208 = 1, happy1208 = True} +test1208 :: String +test1208 = name1208 man1208 + +data Happy1209 = Happy1209 {name1209 :: String, age1209 :: Int, happy1209 :: Bool} +man1209 :: Happy1209 +man1209 = Happy1209 {name1209 = "Happy", age1209 = 1, happy1209 = True} +test1209 :: String +test1209 = name1209 man1209 + +data Happy1210 = Happy1210 {name1210 :: String, age1210 :: Int, happy1210 :: Bool} +man1210 :: Happy1210 +man1210 = Happy1210 {name1210 = "Happy", age1210 = 1, happy1210 = True} +test1210 :: String +test1210 = name1210 man1210 + +data Happy1211 = Happy1211 {name1211 :: String, age1211 :: Int, happy1211 :: Bool} +man1211 :: Happy1211 +man1211 = Happy1211 {name1211 = "Happy", age1211 = 1, happy1211 = True} +test1211 :: String +test1211 = name1211 man1211 + +data Happy1212 = Happy1212 {name1212 :: String, age1212 :: Int, happy1212 :: Bool} +man1212 :: Happy1212 +man1212 = Happy1212 {name1212 = "Happy", age1212 = 1, happy1212 = True} +test1212 :: String +test1212 = name1212 man1212 + +data Happy1213 = Happy1213 {name1213 :: String, age1213 :: Int, happy1213 :: Bool} +man1213 :: Happy1213 +man1213 = Happy1213 {name1213 = "Happy", age1213 = 1, happy1213 = True} +test1213 :: String +test1213 = name1213 man1213 + +data Happy1214 = Happy1214 {name1214 :: String, age1214 :: Int, happy1214 :: Bool} +man1214 :: Happy1214 +man1214 = Happy1214 {name1214 = "Happy", age1214 = 1, happy1214 = True} +test1214 :: String +test1214 = name1214 man1214 + +data Happy1215 = Happy1215 {name1215 :: String, age1215 :: Int, happy1215 :: Bool} +man1215 :: Happy1215 +man1215 = Happy1215 {name1215 = "Happy", age1215 = 1, happy1215 = True} +test1215 :: String +test1215 = name1215 man1215 + +data Happy1216 = Happy1216 {name1216 :: String, age1216 :: Int, happy1216 :: Bool} +man1216 :: Happy1216 +man1216 = Happy1216 {name1216 = "Happy", age1216 = 1, happy1216 = True} +test1216 :: String +test1216 = name1216 man1216 + +data Happy1217 = Happy1217 {name1217 :: String, age1217 :: Int, happy1217 :: Bool} +man1217 :: Happy1217 +man1217 = Happy1217 {name1217 = "Happy", age1217 = 1, happy1217 = True} +test1217 :: String +test1217 = name1217 man1217 + +data Happy1218 = Happy1218 {name1218 :: String, age1218 :: Int, happy1218 :: Bool} +man1218 :: Happy1218 +man1218 = Happy1218 {name1218 = "Happy", age1218 = 1, happy1218 = True} +test1218 :: String +test1218 = name1218 man1218 + +data Happy1219 = Happy1219 {name1219 :: String, age1219 :: Int, happy1219 :: Bool} +man1219 :: Happy1219 +man1219 = Happy1219 {name1219 = "Happy", age1219 = 1, happy1219 = True} +test1219 :: String +test1219 = name1219 man1219 + +data Happy1220 = Happy1220 {name1220 :: String, age1220 :: Int, happy1220 :: Bool} +man1220 :: Happy1220 +man1220 = Happy1220 {name1220 = "Happy", age1220 = 1, happy1220 = True} +test1220 :: String +test1220 = name1220 man1220 + +data Happy1221 = Happy1221 {name1221 :: String, age1221 :: Int, happy1221 :: Bool} +man1221 :: Happy1221 +man1221 = Happy1221 {name1221 = "Happy", age1221 = 1, happy1221 = True} +test1221 :: String +test1221 = name1221 man1221 + +data Happy1222 = Happy1222 {name1222 :: String, age1222 :: Int, happy1222 :: Bool} +man1222 :: Happy1222 +man1222 = Happy1222 {name1222 = "Happy", age1222 = 1, happy1222 = True} +test1222 :: String +test1222 = name1222 man1222 + +data Happy1223 = Happy1223 {name1223 :: String, age1223 :: Int, happy1223 :: Bool} +man1223 :: Happy1223 +man1223 = Happy1223 {name1223 = "Happy", age1223 = 1, happy1223 = True} +test1223 :: String +test1223 = name1223 man1223 + +data Happy1224 = Happy1224 {name1224 :: String, age1224 :: Int, happy1224 :: Bool} +man1224 :: Happy1224 +man1224 = Happy1224 {name1224 = "Happy", age1224 = 1, happy1224 = True} +test1224 :: String +test1224 = name1224 man1224 + +data Happy1225 = Happy1225 {name1225 :: String, age1225 :: Int, happy1225 :: Bool} +man1225 :: Happy1225 +man1225 = Happy1225 {name1225 = "Happy", age1225 = 1, happy1225 = True} +test1225 :: String +test1225 = name1225 man1225 + +data Happy1226 = Happy1226 {name1226 :: String, age1226 :: Int, happy1226 :: Bool} +man1226 :: Happy1226 +man1226 = Happy1226 {name1226 = "Happy", age1226 = 1, happy1226 = True} +test1226 :: String +test1226 = name1226 man1226 + +data Happy1227 = Happy1227 {name1227 :: String, age1227 :: Int, happy1227 :: Bool} +man1227 :: Happy1227 +man1227 = Happy1227 {name1227 = "Happy", age1227 = 1, happy1227 = True} +test1227 :: String +test1227 = name1227 man1227 + +data Happy1228 = Happy1228 {name1228 :: String, age1228 :: Int, happy1228 :: Bool} +man1228 :: Happy1228 +man1228 = Happy1228 {name1228 = "Happy", age1228 = 1, happy1228 = True} +test1228 :: String +test1228 = name1228 man1228 + +data Happy1229 = Happy1229 {name1229 :: String, age1229 :: Int, happy1229 :: Bool} +man1229 :: Happy1229 +man1229 = Happy1229 {name1229 = "Happy", age1229 = 1, happy1229 = True} +test1229 :: String +test1229 = name1229 man1229 + +data Happy1230 = Happy1230 {name1230 :: String, age1230 :: Int, happy1230 :: Bool} +man1230 :: Happy1230 +man1230 = Happy1230 {name1230 = "Happy", age1230 = 1, happy1230 = True} +test1230 :: String +test1230 = name1230 man1230 + +data Happy1231 = Happy1231 {name1231 :: String, age1231 :: Int, happy1231 :: Bool} +man1231 :: Happy1231 +man1231 = Happy1231 {name1231 = "Happy", age1231 = 1, happy1231 = True} +test1231 :: String +test1231 = name1231 man1231 + +data Happy1232 = Happy1232 {name1232 :: String, age1232 :: Int, happy1232 :: Bool} +man1232 :: Happy1232 +man1232 = Happy1232 {name1232 = "Happy", age1232 = 1, happy1232 = True} +test1232 :: String +test1232 = name1232 man1232 + +data Happy1233 = Happy1233 {name1233 :: String, age1233 :: Int, happy1233 :: Bool} +man1233 :: Happy1233 +man1233 = Happy1233 {name1233 = "Happy", age1233 = 1, happy1233 = True} +test1233 :: String +test1233 = name1233 man1233 + +data Happy1234 = Happy1234 {name1234 :: String, age1234 :: Int, happy1234 :: Bool} +man1234 :: Happy1234 +man1234 = Happy1234 {name1234 = "Happy", age1234 = 1, happy1234 = True} +test1234 :: String +test1234 = name1234 man1234 + +data Happy1235 = Happy1235 {name1235 :: String, age1235 :: Int, happy1235 :: Bool} +man1235 :: Happy1235 +man1235 = Happy1235 {name1235 = "Happy", age1235 = 1, happy1235 = True} +test1235 :: String +test1235 = name1235 man1235 + +data Happy1236 = Happy1236 {name1236 :: String, age1236 :: Int, happy1236 :: Bool} +man1236 :: Happy1236 +man1236 = Happy1236 {name1236 = "Happy", age1236 = 1, happy1236 = True} +test1236 :: String +test1236 = name1236 man1236 + +data Happy1237 = Happy1237 {name1237 :: String, age1237 :: Int, happy1237 :: Bool} +man1237 :: Happy1237 +man1237 = Happy1237 {name1237 = "Happy", age1237 = 1, happy1237 = True} +test1237 :: String +test1237 = name1237 man1237 + +data Happy1238 = Happy1238 {name1238 :: String, age1238 :: Int, happy1238 :: Bool} +man1238 :: Happy1238 +man1238 = Happy1238 {name1238 = "Happy", age1238 = 1, happy1238 = True} +test1238 :: String +test1238 = name1238 man1238 + +data Happy1239 = Happy1239 {name1239 :: String, age1239 :: Int, happy1239 :: Bool} +man1239 :: Happy1239 +man1239 = Happy1239 {name1239 = "Happy", age1239 = 1, happy1239 = True} +test1239 :: String +test1239 = name1239 man1239 + +data Happy1240 = Happy1240 {name1240 :: String, age1240 :: Int, happy1240 :: Bool} +man1240 :: Happy1240 +man1240 = Happy1240 {name1240 = "Happy", age1240 = 1, happy1240 = True} +test1240 :: String +test1240 = name1240 man1240 + +data Happy1241 = Happy1241 {name1241 :: String, age1241 :: Int, happy1241 :: Bool} +man1241 :: Happy1241 +man1241 = Happy1241 {name1241 = "Happy", age1241 = 1, happy1241 = True} +test1241 :: String +test1241 = name1241 man1241 + +data Happy1242 = Happy1242 {name1242 :: String, age1242 :: Int, happy1242 :: Bool} +man1242 :: Happy1242 +man1242 = Happy1242 {name1242 = "Happy", age1242 = 1, happy1242 = True} +test1242 :: String +test1242 = name1242 man1242 + +data Happy1243 = Happy1243 {name1243 :: String, age1243 :: Int, happy1243 :: Bool} +man1243 :: Happy1243 +man1243 = Happy1243 {name1243 = "Happy", age1243 = 1, happy1243 = True} +test1243 :: String +test1243 = name1243 man1243 + +data Happy1244 = Happy1244 {name1244 :: String, age1244 :: Int, happy1244 :: Bool} +man1244 :: Happy1244 +man1244 = Happy1244 {name1244 = "Happy", age1244 = 1, happy1244 = True} +test1244 :: String +test1244 = name1244 man1244 + +data Happy1245 = Happy1245 {name1245 :: String, age1245 :: Int, happy1245 :: Bool} +man1245 :: Happy1245 +man1245 = Happy1245 {name1245 = "Happy", age1245 = 1, happy1245 = True} +test1245 :: String +test1245 = name1245 man1245 + +data Happy1246 = Happy1246 {name1246 :: String, age1246 :: Int, happy1246 :: Bool} +man1246 :: Happy1246 +man1246 = Happy1246 {name1246 = "Happy", age1246 = 1, happy1246 = True} +test1246 :: String +test1246 = name1246 man1246 + +data Happy1247 = Happy1247 {name1247 :: String, age1247 :: Int, happy1247 :: Bool} +man1247 :: Happy1247 +man1247 = Happy1247 {name1247 = "Happy", age1247 = 1, happy1247 = True} +test1247 :: String +test1247 = name1247 man1247 + +data Happy1248 = Happy1248 {name1248 :: String, age1248 :: Int, happy1248 :: Bool} +man1248 :: Happy1248 +man1248 = Happy1248 {name1248 = "Happy", age1248 = 1, happy1248 = True} +test1248 :: String +test1248 = name1248 man1248 + +data Happy1249 = Happy1249 {name1249 :: String, age1249 :: Int, happy1249 :: Bool} +man1249 :: Happy1249 +man1249 = Happy1249 {name1249 = "Happy", age1249 = 1, happy1249 = True} +test1249 :: String +test1249 = name1249 man1249 + +data Happy1250 = Happy1250 {name1250 :: String, age1250 :: Int, happy1250 :: Bool} +man1250 :: Happy1250 +man1250 = Happy1250 {name1250 = "Happy", age1250 = 1, happy1250 = True} +test1250 :: String +test1250 = name1250 man1250 + +data Happy1251 = Happy1251 {name1251 :: String, age1251 :: Int, happy1251 :: Bool} +man1251 :: Happy1251 +man1251 = Happy1251 {name1251 = "Happy", age1251 = 1, happy1251 = True} +test1251 :: String +test1251 = name1251 man1251 + +data Happy1252 = Happy1252 {name1252 :: String, age1252 :: Int, happy1252 :: Bool} +man1252 :: Happy1252 +man1252 = Happy1252 {name1252 = "Happy", age1252 = 1, happy1252 = True} +test1252 :: String +test1252 = name1252 man1252 + +data Happy1253 = Happy1253 {name1253 :: String, age1253 :: Int, happy1253 :: Bool} +man1253 :: Happy1253 +man1253 = Happy1253 {name1253 = "Happy", age1253 = 1, happy1253 = True} +test1253 :: String +test1253 = name1253 man1253 + +data Happy1254 = Happy1254 {name1254 :: String, age1254 :: Int, happy1254 :: Bool} +man1254 :: Happy1254 +man1254 = Happy1254 {name1254 = "Happy", age1254 = 1, happy1254 = True} +test1254 :: String +test1254 = name1254 man1254 + +data Happy1255 = Happy1255 {name1255 :: String, age1255 :: Int, happy1255 :: Bool} +man1255 :: Happy1255 +man1255 = Happy1255 {name1255 = "Happy", age1255 = 1, happy1255 = True} +test1255 :: String +test1255 = name1255 man1255 + +data Happy1256 = Happy1256 {name1256 :: String, age1256 :: Int, happy1256 :: Bool} +man1256 :: Happy1256 +man1256 = Happy1256 {name1256 = "Happy", age1256 = 1, happy1256 = True} +test1256 :: String +test1256 = name1256 man1256 + +data Happy1257 = Happy1257 {name1257 :: String, age1257 :: Int, happy1257 :: Bool} +man1257 :: Happy1257 +man1257 = Happy1257 {name1257 = "Happy", age1257 = 1, happy1257 = True} +test1257 :: String +test1257 = name1257 man1257 + +data Happy1258 = Happy1258 {name1258 :: String, age1258 :: Int, happy1258 :: Bool} +man1258 :: Happy1258 +man1258 = Happy1258 {name1258 = "Happy", age1258 = 1, happy1258 = True} +test1258 :: String +test1258 = name1258 man1258 + +data Happy1259 = Happy1259 {name1259 :: String, age1259 :: Int, happy1259 :: Bool} +man1259 :: Happy1259 +man1259 = Happy1259 {name1259 = "Happy", age1259 = 1, happy1259 = True} +test1259 :: String +test1259 = name1259 man1259 + +data Happy1260 = Happy1260 {name1260 :: String, age1260 :: Int, happy1260 :: Bool} +man1260 :: Happy1260 +man1260 = Happy1260 {name1260 = "Happy", age1260 = 1, happy1260 = True} +test1260 :: String +test1260 = name1260 man1260 + +data Happy1261 = Happy1261 {name1261 :: String, age1261 :: Int, happy1261 :: Bool} +man1261 :: Happy1261 +man1261 = Happy1261 {name1261 = "Happy", age1261 = 1, happy1261 = True} +test1261 :: String +test1261 = name1261 man1261 + +data Happy1262 = Happy1262 {name1262 :: String, age1262 :: Int, happy1262 :: Bool} +man1262 :: Happy1262 +man1262 = Happy1262 {name1262 = "Happy", age1262 = 1, happy1262 = True} +test1262 :: String +test1262 = name1262 man1262 + +data Happy1263 = Happy1263 {name1263 :: String, age1263 :: Int, happy1263 :: Bool} +man1263 :: Happy1263 +man1263 = Happy1263 {name1263 = "Happy", age1263 = 1, happy1263 = True} +test1263 :: String +test1263 = name1263 man1263 + +data Happy1264 = Happy1264 {name1264 :: String, age1264 :: Int, happy1264 :: Bool} +man1264 :: Happy1264 +man1264 = Happy1264 {name1264 = "Happy", age1264 = 1, happy1264 = True} +test1264 :: String +test1264 = name1264 man1264 + +data Happy1265 = Happy1265 {name1265 :: String, age1265 :: Int, happy1265 :: Bool} +man1265 :: Happy1265 +man1265 = Happy1265 {name1265 = "Happy", age1265 = 1, happy1265 = True} +test1265 :: String +test1265 = name1265 man1265 + +data Happy1266 = Happy1266 {name1266 :: String, age1266 :: Int, happy1266 :: Bool} +man1266 :: Happy1266 +man1266 = Happy1266 {name1266 = "Happy", age1266 = 1, happy1266 = True} +test1266 :: String +test1266 = name1266 man1266 + +data Happy1267 = Happy1267 {name1267 :: String, age1267 :: Int, happy1267 :: Bool} +man1267 :: Happy1267 +man1267 = Happy1267 {name1267 = "Happy", age1267 = 1, happy1267 = True} +test1267 :: String +test1267 = name1267 man1267 + +data Happy1268 = Happy1268 {name1268 :: String, age1268 :: Int, happy1268 :: Bool} +man1268 :: Happy1268 +man1268 = Happy1268 {name1268 = "Happy", age1268 = 1, happy1268 = True} +test1268 :: String +test1268 = name1268 man1268 + +data Happy1269 = Happy1269 {name1269 :: String, age1269 :: Int, happy1269 :: Bool} +man1269 :: Happy1269 +man1269 = Happy1269 {name1269 = "Happy", age1269 = 1, happy1269 = True} +test1269 :: String +test1269 = name1269 man1269 + +data Happy1270 = Happy1270 {name1270 :: String, age1270 :: Int, happy1270 :: Bool} +man1270 :: Happy1270 +man1270 = Happy1270 {name1270 = "Happy", age1270 = 1, happy1270 = True} +test1270 :: String +test1270 = name1270 man1270 + +data Happy1271 = Happy1271 {name1271 :: String, age1271 :: Int, happy1271 :: Bool} +man1271 :: Happy1271 +man1271 = Happy1271 {name1271 = "Happy", age1271 = 1, happy1271 = True} +test1271 :: String +test1271 = name1271 man1271 + +data Happy1272 = Happy1272 {name1272 :: String, age1272 :: Int, happy1272 :: Bool} +man1272 :: Happy1272 +man1272 = Happy1272 {name1272 = "Happy", age1272 = 1, happy1272 = True} +test1272 :: String +test1272 = name1272 man1272 + +data Happy1273 = Happy1273 {name1273 :: String, age1273 :: Int, happy1273 :: Bool} +man1273 :: Happy1273 +man1273 = Happy1273 {name1273 = "Happy", age1273 = 1, happy1273 = True} +test1273 :: String +test1273 = name1273 man1273 + +data Happy1274 = Happy1274 {name1274 :: String, age1274 :: Int, happy1274 :: Bool} +man1274 :: Happy1274 +man1274 = Happy1274 {name1274 = "Happy", age1274 = 1, happy1274 = True} +test1274 :: String +test1274 = name1274 man1274 + +data Happy1275 = Happy1275 {name1275 :: String, age1275 :: Int, happy1275 :: Bool} +man1275 :: Happy1275 +man1275 = Happy1275 {name1275 = "Happy", age1275 = 1, happy1275 = True} +test1275 :: String +test1275 = name1275 man1275 + +data Happy1276 = Happy1276 {name1276 :: String, age1276 :: Int, happy1276 :: Bool} +man1276 :: Happy1276 +man1276 = Happy1276 {name1276 = "Happy", age1276 = 1, happy1276 = True} +test1276 :: String +test1276 = name1276 man1276 + +data Happy1277 = Happy1277 {name1277 :: String, age1277 :: Int, happy1277 :: Bool} +man1277 :: Happy1277 +man1277 = Happy1277 {name1277 = "Happy", age1277 = 1, happy1277 = True} +test1277 :: String +test1277 = name1277 man1277 + +data Happy1278 = Happy1278 {name1278 :: String, age1278 :: Int, happy1278 :: Bool} +man1278 :: Happy1278 +man1278 = Happy1278 {name1278 = "Happy", age1278 = 1, happy1278 = True} +test1278 :: String +test1278 = name1278 man1278 + +data Happy1279 = Happy1279 {name1279 :: String, age1279 :: Int, happy1279 :: Bool} +man1279 :: Happy1279 +man1279 = Happy1279 {name1279 = "Happy", age1279 = 1, happy1279 = True} +test1279 :: String +test1279 = name1279 man1279 + +data Happy1280 = Happy1280 {name1280 :: String, age1280 :: Int, happy1280 :: Bool} +man1280 :: Happy1280 +man1280 = Happy1280 {name1280 = "Happy", age1280 = 1, happy1280 = True} +test1280 :: String +test1280 = name1280 man1280 + +data Happy1281 = Happy1281 {name1281 :: String, age1281 :: Int, happy1281 :: Bool} +man1281 :: Happy1281 +man1281 = Happy1281 {name1281 = "Happy", age1281 = 1, happy1281 = True} +test1281 :: String +test1281 = name1281 man1281 + +data Happy1282 = Happy1282 {name1282 :: String, age1282 :: Int, happy1282 :: Bool} +man1282 :: Happy1282 +man1282 = Happy1282 {name1282 = "Happy", age1282 = 1, happy1282 = True} +test1282 :: String +test1282 = name1282 man1282 + +data Happy1283 = Happy1283 {name1283 :: String, age1283 :: Int, happy1283 :: Bool} +man1283 :: Happy1283 +man1283 = Happy1283 {name1283 = "Happy", age1283 = 1, happy1283 = True} +test1283 :: String +test1283 = name1283 man1283 + +data Happy1284 = Happy1284 {name1284 :: String, age1284 :: Int, happy1284 :: Bool} +man1284 :: Happy1284 +man1284 = Happy1284 {name1284 = "Happy", age1284 = 1, happy1284 = True} +test1284 :: String +test1284 = name1284 man1284 + +data Happy1285 = Happy1285 {name1285 :: String, age1285 :: Int, happy1285 :: Bool} +man1285 :: Happy1285 +man1285 = Happy1285 {name1285 = "Happy", age1285 = 1, happy1285 = True} +test1285 :: String +test1285 = name1285 man1285 + +data Happy1286 = Happy1286 {name1286 :: String, age1286 :: Int, happy1286 :: Bool} +man1286 :: Happy1286 +man1286 = Happy1286 {name1286 = "Happy", age1286 = 1, happy1286 = True} +test1286 :: String +test1286 = name1286 man1286 + +data Happy1287 = Happy1287 {name1287 :: String, age1287 :: Int, happy1287 :: Bool} +man1287 :: Happy1287 +man1287 = Happy1287 {name1287 = "Happy", age1287 = 1, happy1287 = True} +test1287 :: String +test1287 = name1287 man1287 + +data Happy1288 = Happy1288 {name1288 :: String, age1288 :: Int, happy1288 :: Bool} +man1288 :: Happy1288 +man1288 = Happy1288 {name1288 = "Happy", age1288 = 1, happy1288 = True} +test1288 :: String +test1288 = name1288 man1288 + +data Happy1289 = Happy1289 {name1289 :: String, age1289 :: Int, happy1289 :: Bool} +man1289 :: Happy1289 +man1289 = Happy1289 {name1289 = "Happy", age1289 = 1, happy1289 = True} +test1289 :: String +test1289 = name1289 man1289 + +data Happy1290 = Happy1290 {name1290 :: String, age1290 :: Int, happy1290 :: Bool} +man1290 :: Happy1290 +man1290 = Happy1290 {name1290 = "Happy", age1290 = 1, happy1290 = True} +test1290 :: String +test1290 = name1290 man1290 + +data Happy1291 = Happy1291 {name1291 :: String, age1291 :: Int, happy1291 :: Bool} +man1291 :: Happy1291 +man1291 = Happy1291 {name1291 = "Happy", age1291 = 1, happy1291 = True} +test1291 :: String +test1291 = name1291 man1291 + +data Happy1292 = Happy1292 {name1292 :: String, age1292 :: Int, happy1292 :: Bool} +man1292 :: Happy1292 +man1292 = Happy1292 {name1292 = "Happy", age1292 = 1, happy1292 = True} +test1292 :: String +test1292 = name1292 man1292 + +data Happy1293 = Happy1293 {name1293 :: String, age1293 :: Int, happy1293 :: Bool} +man1293 :: Happy1293 +man1293 = Happy1293 {name1293 = "Happy", age1293 = 1, happy1293 = True} +test1293 :: String +test1293 = name1293 man1293 + +data Happy1294 = Happy1294 {name1294 :: String, age1294 :: Int, happy1294 :: Bool} +man1294 :: Happy1294 +man1294 = Happy1294 {name1294 = "Happy", age1294 = 1, happy1294 = True} +test1294 :: String +test1294 = name1294 man1294 + +data Happy1295 = Happy1295 {name1295 :: String, age1295 :: Int, happy1295 :: Bool} +man1295 :: Happy1295 +man1295 = Happy1295 {name1295 = "Happy", age1295 = 1, happy1295 = True} +test1295 :: String +test1295 = name1295 man1295 + +data Happy1296 = Happy1296 {name1296 :: String, age1296 :: Int, happy1296 :: Bool} +man1296 :: Happy1296 +man1296 = Happy1296 {name1296 = "Happy", age1296 = 1, happy1296 = True} +test1296 :: String +test1296 = name1296 man1296 + +data Happy1297 = Happy1297 {name1297 :: String, age1297 :: Int, happy1297 :: Bool} +man1297 :: Happy1297 +man1297 = Happy1297 {name1297 = "Happy", age1297 = 1, happy1297 = True} +test1297 :: String +test1297 = name1297 man1297 + +data Happy1298 = Happy1298 {name1298 :: String, age1298 :: Int, happy1298 :: Bool} +man1298 :: Happy1298 +man1298 = Happy1298 {name1298 = "Happy", age1298 = 1, happy1298 = True} +test1298 :: String +test1298 = man1298.name1298 + +data Happy1299 = Happy1299 {name1299 :: String, age1299 :: Int, happy1299 :: Bool} +man1299 :: Happy1299 +man1299 = Happy1299 {name1299 = "Happy", age1299 = 1, happy1299 = True} +test1299 :: String +test1299 = name1299 man1299 diff --git a/plugins/hls-overloaded-record-dot-plugin/test/testdata/Benchmark.hs b/plugins/hls-overloaded-record-dot-plugin/test/testdata/Benchmark.hs new file mode 100644 index 0000000000..5cb49507a8 --- /dev/null +++ b/plugins/hls-overloaded-record-dot-plugin/test/testdata/Benchmark.hs @@ -0,0 +1,1804 @@ + +main :: IO () +main = do + putStrLn test1000 + +data Happy1000 = Happy1000 {name1000 :: String, age1000 :: Int, happy1000 :: Bool} +man1000 :: Happy1000 +man1000 = Happy1000 {name1000 = "Happy", age1000 = 1, happy1000 = True} +test1000 :: String +test1000 = name1000 man1000 + +data Happy1001 = Happy1001 {name1001 :: String, age1001 :: Int, happy1001 :: Bool} +man1001 :: Happy1001 +man1001 = Happy1001 {name1001 = "Happy", age1001 = 1, happy1001 = True} +test1001 :: String +test1001 = name1001 man1001 + +data Happy1002 = Happy1002 {name1002 :: String, age1002 :: Int, happy1002 :: Bool} +man1002 :: Happy1002 +man1002 = Happy1002 {name1002 = "Happy", age1002 = 1, happy1002 = True} +test1002 :: String +test1002 = name1002 man1002 + +data Happy1003 = Happy1003 {name1003 :: String, age1003 :: Int, happy1003 :: Bool} +man1003 :: Happy1003 +man1003 = Happy1003 {name1003 = "Happy", age1003 = 1, happy1003 = True} +test1003 :: String +test1003 = name1003 man1003 + +data Happy1004 = Happy1004 {name1004 :: String, age1004 :: Int, happy1004 :: Bool} +man1004 :: Happy1004 +man1004 = Happy1004 {name1004 = "Happy", age1004 = 1, happy1004 = True} +test1004 :: String +test1004 = name1004 man1004 + +data Happy1005 = Happy1005 {name1005 :: String, age1005 :: Int, happy1005 :: Bool} +man1005 :: Happy1005 +man1005 = Happy1005 {name1005 = "Happy", age1005 = 1, happy1005 = True} +test1005 :: String +test1005 = name1005 man1005 + +data Happy1006 = Happy1006 {name1006 :: String, age1006 :: Int, happy1006 :: Bool} +man1006 :: Happy1006 +man1006 = Happy1006 {name1006 = "Happy", age1006 = 1, happy1006 = True} +test1006 :: String +test1006 = name1006 man1006 + +data Happy1007 = Happy1007 {name1007 :: String, age1007 :: Int, happy1007 :: Bool} +man1007 :: Happy1007 +man1007 = Happy1007 {name1007 = "Happy", age1007 = 1, happy1007 = True} +test1007 :: String +test1007 = name1007 man1007 + +data Happy1008 = Happy1008 {name1008 :: String, age1008 :: Int, happy1008 :: Bool} +man1008 :: Happy1008 +man1008 = Happy1008 {name1008 = "Happy", age1008 = 1, happy1008 = True} +test1008 :: String +test1008 = name1008 man1008 + +data Happy1009 = Happy1009 {name1009 :: String, age1009 :: Int, happy1009 :: Bool} +man1009 :: Happy1009 +man1009 = Happy1009 {name1009 = "Happy", age1009 = 1, happy1009 = True} +test1009 :: String +test1009 = name1009 man1009 + +data Happy1010 = Happy1010 {name1010 :: String, age1010 :: Int, happy1010 :: Bool} +man1010 :: Happy1010 +man1010 = Happy1010 {name1010 = "Happy", age1010 = 1, happy1010 = True} +test1010 :: String +test1010 = name1010 man1010 + +data Happy1011 = Happy1011 {name1011 :: String, age1011 :: Int, happy1011 :: Bool} +man1011 :: Happy1011 +man1011 = Happy1011 {name1011 = "Happy", age1011 = 1, happy1011 = True} +test1011 :: String +test1011 = name1011 man1011 + +data Happy1012 = Happy1012 {name1012 :: String, age1012 :: Int, happy1012 :: Bool} +man1012 :: Happy1012 +man1012 = Happy1012 {name1012 = "Happy", age1012 = 1, happy1012 = True} +test1012 :: String +test1012 = name1012 man1012 + +data Happy1013 = Happy1013 {name1013 :: String, age1013 :: Int, happy1013 :: Bool} +man1013 :: Happy1013 +man1013 = Happy1013 {name1013 = "Happy", age1013 = 1, happy1013 = True} +test1013 :: String +test1013 = name1013 man1013 + +data Happy1014 = Happy1014 {name1014 :: String, age1014 :: Int, happy1014 :: Bool} +man1014 :: Happy1014 +man1014 = Happy1014 {name1014 = "Happy", age1014 = 1, happy1014 = True} +test1014 :: String +test1014 = name1014 man1014 + +data Happy1015 = Happy1015 {name1015 :: String, age1015 :: Int, happy1015 :: Bool} +man1015 :: Happy1015 +man1015 = Happy1015 {name1015 = "Happy", age1015 = 1, happy1015 = True} +test1015 :: String +test1015 = name1015 man1015 + +data Happy1016 = Happy1016 {name1016 :: String, age1016 :: Int, happy1016 :: Bool} +man1016 :: Happy1016 +man1016 = Happy1016 {name1016 = "Happy", age1016 = 1, happy1016 = True} +test1016 :: String +test1016 = name1016 man1016 + +data Happy1017 = Happy1017 {name1017 :: String, age1017 :: Int, happy1017 :: Bool} +man1017 :: Happy1017 +man1017 = Happy1017 {name1017 = "Happy", age1017 = 1, happy1017 = True} +test1017 :: String +test1017 = name1017 man1017 + +data Happy1018 = Happy1018 {name1018 :: String, age1018 :: Int, happy1018 :: Bool} +man1018 :: Happy1018 +man1018 = Happy1018 {name1018 = "Happy", age1018 = 1, happy1018 = True} +test1018 :: String +test1018 = name1018 man1018 + +data Happy1019 = Happy1019 {name1019 :: String, age1019 :: Int, happy1019 :: Bool} +man1019 :: Happy1019 +man1019 = Happy1019 {name1019 = "Happy", age1019 = 1, happy1019 = True} +test1019 :: String +test1019 = name1019 man1019 + +data Happy1020 = Happy1020 {name1020 :: String, age1020 :: Int, happy1020 :: Bool} +man1020 :: Happy1020 +man1020 = Happy1020 {name1020 = "Happy", age1020 = 1, happy1020 = True} +test1020 :: String +test1020 = name1020 man1020 + +data Happy1021 = Happy1021 {name1021 :: String, age1021 :: Int, happy1021 :: Bool} +man1021 :: Happy1021 +man1021 = Happy1021 {name1021 = "Happy", age1021 = 1, happy1021 = True} +test1021 :: String +test1021 = name1021 man1021 + +data Happy1022 = Happy1022 {name1022 :: String, age1022 :: Int, happy1022 :: Bool} +man1022 :: Happy1022 +man1022 = Happy1022 {name1022 = "Happy", age1022 = 1, happy1022 = True} +test1022 :: String +test1022 = name1022 man1022 + +data Happy1023 = Happy1023 {name1023 :: String, age1023 :: Int, happy1023 :: Bool} +man1023 :: Happy1023 +man1023 = Happy1023 {name1023 = "Happy", age1023 = 1, happy1023 = True} +test1023 :: String +test1023 = name1023 man1023 + +data Happy1024 = Happy1024 {name1024 :: String, age1024 :: Int, happy1024 :: Bool} +man1024 :: Happy1024 +man1024 = Happy1024 {name1024 = "Happy", age1024 = 1, happy1024 = True} +test1024 :: String +test1024 = name1024 man1024 + +data Happy1025 = Happy1025 {name1025 :: String, age1025 :: Int, happy1025 :: Bool} +man1025 :: Happy1025 +man1025 = Happy1025 {name1025 = "Happy", age1025 = 1, happy1025 = True} +test1025 :: String +test1025 = name1025 man1025 + +data Happy1026 = Happy1026 {name1026 :: String, age1026 :: Int, happy1026 :: Bool} +man1026 :: Happy1026 +man1026 = Happy1026 {name1026 = "Happy", age1026 = 1, happy1026 = True} +test1026 :: String +test1026 = name1026 man1026 + +data Happy1027 = Happy1027 {name1027 :: String, age1027 :: Int, happy1027 :: Bool} +man1027 :: Happy1027 +man1027 = Happy1027 {name1027 = "Happy", age1027 = 1, happy1027 = True} +test1027 :: String +test1027 = name1027 man1027 + +data Happy1028 = Happy1028 {name1028 :: String, age1028 :: Int, happy1028 :: Bool} +man1028 :: Happy1028 +man1028 = Happy1028 {name1028 = "Happy", age1028 = 1, happy1028 = True} +test1028 :: String +test1028 = name1028 man1028 + +data Happy1029 = Happy1029 {name1029 :: String, age1029 :: Int, happy1029 :: Bool} +man1029 :: Happy1029 +man1029 = Happy1029 {name1029 = "Happy", age1029 = 1, happy1029 = True} +test1029 :: String +test1029 = name1029 man1029 + +data Happy1030 = Happy1030 {name1030 :: String, age1030 :: Int, happy1030 :: Bool} +man1030 :: Happy1030 +man1030 = Happy1030 {name1030 = "Happy", age1030 = 1, happy1030 = True} +test1030 :: String +test1030 = name1030 man1030 + +data Happy1031 = Happy1031 {name1031 :: String, age1031 :: Int, happy1031 :: Bool} +man1031 :: Happy1031 +man1031 = Happy1031 {name1031 = "Happy", age1031 = 1, happy1031 = True} +test1031 :: String +test1031 = name1031 man1031 + +data Happy1032 = Happy1032 {name1032 :: String, age1032 :: Int, happy1032 :: Bool} +man1032 :: Happy1032 +man1032 = Happy1032 {name1032 = "Happy", age1032 = 1, happy1032 = True} +test1032 :: String +test1032 = name1032 man1032 + +data Happy1033 = Happy1033 {name1033 :: String, age1033 :: Int, happy1033 :: Bool} +man1033 :: Happy1033 +man1033 = Happy1033 {name1033 = "Happy", age1033 = 1, happy1033 = True} +test1033 :: String +test1033 = name1033 man1033 + +data Happy1034 = Happy1034 {name1034 :: String, age1034 :: Int, happy1034 :: Bool} +man1034 :: Happy1034 +man1034 = Happy1034 {name1034 = "Happy", age1034 = 1, happy1034 = True} +test1034 :: String +test1034 = name1034 man1034 + +data Happy1035 = Happy1035 {name1035 :: String, age1035 :: Int, happy1035 :: Bool} +man1035 :: Happy1035 +man1035 = Happy1035 {name1035 = "Happy", age1035 = 1, happy1035 = True} +test1035 :: String +test1035 = name1035 man1035 + +data Happy1036 = Happy1036 {name1036 :: String, age1036 :: Int, happy1036 :: Bool} +man1036 :: Happy1036 +man1036 = Happy1036 {name1036 = "Happy", age1036 = 1, happy1036 = True} +test1036 :: String +test1036 = name1036 man1036 + +data Happy1037 = Happy1037 {name1037 :: String, age1037 :: Int, happy1037 :: Bool} +man1037 :: Happy1037 +man1037 = Happy1037 {name1037 = "Happy", age1037 = 1, happy1037 = True} +test1037 :: String +test1037 = name1037 man1037 + +data Happy1038 = Happy1038 {name1038 :: String, age1038 :: Int, happy1038 :: Bool} +man1038 :: Happy1038 +man1038 = Happy1038 {name1038 = "Happy", age1038 = 1, happy1038 = True} +test1038 :: String +test1038 = name1038 man1038 + +data Happy1039 = Happy1039 {name1039 :: String, age1039 :: Int, happy1039 :: Bool} +man1039 :: Happy1039 +man1039 = Happy1039 {name1039 = "Happy", age1039 = 1, happy1039 = True} +test1039 :: String +test1039 = name1039 man1039 + +data Happy1040 = Happy1040 {name1040 :: String, age1040 :: Int, happy1040 :: Bool} +man1040 :: Happy1040 +man1040 = Happy1040 {name1040 = "Happy", age1040 = 1, happy1040 = True} +test1040 :: String +test1040 = name1040 man1040 + +data Happy1041 = Happy1041 {name1041 :: String, age1041 :: Int, happy1041 :: Bool} +man1041 :: Happy1041 +man1041 = Happy1041 {name1041 = "Happy", age1041 = 1, happy1041 = True} +test1041 :: String +test1041 = name1041 man1041 + +data Happy1042 = Happy1042 {name1042 :: String, age1042 :: Int, happy1042 :: Bool} +man1042 :: Happy1042 +man1042 = Happy1042 {name1042 = "Happy", age1042 = 1, happy1042 = True} +test1042 :: String +test1042 = name1042 man1042 + +data Happy1043 = Happy1043 {name1043 :: String, age1043 :: Int, happy1043 :: Bool} +man1043 :: Happy1043 +man1043 = Happy1043 {name1043 = "Happy", age1043 = 1, happy1043 = True} +test1043 :: String +test1043 = name1043 man1043 + +data Happy1044 = Happy1044 {name1044 :: String, age1044 :: Int, happy1044 :: Bool} +man1044 :: Happy1044 +man1044 = Happy1044 {name1044 = "Happy", age1044 = 1, happy1044 = True} +test1044 :: String +test1044 = name1044 man1044 + +data Happy1045 = Happy1045 {name1045 :: String, age1045 :: Int, happy1045 :: Bool} +man1045 :: Happy1045 +man1045 = Happy1045 {name1045 = "Happy", age1045 = 1, happy1045 = True} +test1045 :: String +test1045 = name1045 man1045 + +data Happy1046 = Happy1046 {name1046 :: String, age1046 :: Int, happy1046 :: Bool} +man1046 :: Happy1046 +man1046 = Happy1046 {name1046 = "Happy", age1046 = 1, happy1046 = True} +test1046 :: String +test1046 = name1046 man1046 + +data Happy1047 = Happy1047 {name1047 :: String, age1047 :: Int, happy1047 :: Bool} +man1047 :: Happy1047 +man1047 = Happy1047 {name1047 = "Happy", age1047 = 1, happy1047 = True} +test1047 :: String +test1047 = name1047 man1047 + +data Happy1048 = Happy1048 {name1048 :: String, age1048 :: Int, happy1048 :: Bool} +man1048 :: Happy1048 +man1048 = Happy1048 {name1048 = "Happy", age1048 = 1, happy1048 = True} +test1048 :: String +test1048 = name1048 man1048 + +data Happy1049 = Happy1049 {name1049 :: String, age1049 :: Int, happy1049 :: Bool} +man1049 :: Happy1049 +man1049 = Happy1049 {name1049 = "Happy", age1049 = 1, happy1049 = True} +test1049 :: String +test1049 = name1049 man1049 + +data Happy1050 = Happy1050 {name1050 :: String, age1050 :: Int, happy1050 :: Bool} +man1050 :: Happy1050 +man1050 = Happy1050 {name1050 = "Happy", age1050 = 1, happy1050 = True} +test1050 :: String +test1050 = name1050 man1050 + +data Happy1051 = Happy1051 {name1051 :: String, age1051 :: Int, happy1051 :: Bool} +man1051 :: Happy1051 +man1051 = Happy1051 {name1051 = "Happy", age1051 = 1, happy1051 = True} +test1051 :: String +test1051 = name1051 man1051 + +data Happy1052 = Happy1052 {name1052 :: String, age1052 :: Int, happy1052 :: Bool} +man1052 :: Happy1052 +man1052 = Happy1052 {name1052 = "Happy", age1052 = 1, happy1052 = True} +test1052 :: String +test1052 = name1052 man1052 + +data Happy1053 = Happy1053 {name1053 :: String, age1053 :: Int, happy1053 :: Bool} +man1053 :: Happy1053 +man1053 = Happy1053 {name1053 = "Happy", age1053 = 1, happy1053 = True} +test1053 :: String +test1053 = name1053 man1053 + +data Happy1054 = Happy1054 {name1054 :: String, age1054 :: Int, happy1054 :: Bool} +man1054 :: Happy1054 +man1054 = Happy1054 {name1054 = "Happy", age1054 = 1, happy1054 = True} +test1054 :: String +test1054 = name1054 man1054 + +data Happy1055 = Happy1055 {name1055 :: String, age1055 :: Int, happy1055 :: Bool} +man1055 :: Happy1055 +man1055 = Happy1055 {name1055 = "Happy", age1055 = 1, happy1055 = True} +test1055 :: String +test1055 = name1055 man1055 + +data Happy1056 = Happy1056 {name1056 :: String, age1056 :: Int, happy1056 :: Bool} +man1056 :: Happy1056 +man1056 = Happy1056 {name1056 = "Happy", age1056 = 1, happy1056 = True} +test1056 :: String +test1056 = name1056 man1056 + +data Happy1057 = Happy1057 {name1057 :: String, age1057 :: Int, happy1057 :: Bool} +man1057 :: Happy1057 +man1057 = Happy1057 {name1057 = "Happy", age1057 = 1, happy1057 = True} +test1057 :: String +test1057 = name1057 man1057 + +data Happy1058 = Happy1058 {name1058 :: String, age1058 :: Int, happy1058 :: Bool} +man1058 :: Happy1058 +man1058 = Happy1058 {name1058 = "Happy", age1058 = 1, happy1058 = True} +test1058 :: String +test1058 = name1058 man1058 + +data Happy1059 = Happy1059 {name1059 :: String, age1059 :: Int, happy1059 :: Bool} +man1059 :: Happy1059 +man1059 = Happy1059 {name1059 = "Happy", age1059 = 1, happy1059 = True} +test1059 :: String +test1059 = name1059 man1059 + +data Happy1060 = Happy1060 {name1060 :: String, age1060 :: Int, happy1060 :: Bool} +man1060 :: Happy1060 +man1060 = Happy1060 {name1060 = "Happy", age1060 = 1, happy1060 = True} +test1060 :: String +test1060 = name1060 man1060 + +data Happy1061 = Happy1061 {name1061 :: String, age1061 :: Int, happy1061 :: Bool} +man1061 :: Happy1061 +man1061 = Happy1061 {name1061 = "Happy", age1061 = 1, happy1061 = True} +test1061 :: String +test1061 = name1061 man1061 + +data Happy1062 = Happy1062 {name1062 :: String, age1062 :: Int, happy1062 :: Bool} +man1062 :: Happy1062 +man1062 = Happy1062 {name1062 = "Happy", age1062 = 1, happy1062 = True} +test1062 :: String +test1062 = name1062 man1062 + +data Happy1063 = Happy1063 {name1063 :: String, age1063 :: Int, happy1063 :: Bool} +man1063 :: Happy1063 +man1063 = Happy1063 {name1063 = "Happy", age1063 = 1, happy1063 = True} +test1063 :: String +test1063 = name1063 man1063 + +data Happy1064 = Happy1064 {name1064 :: String, age1064 :: Int, happy1064 :: Bool} +man1064 :: Happy1064 +man1064 = Happy1064 {name1064 = "Happy", age1064 = 1, happy1064 = True} +test1064 :: String +test1064 = name1064 man1064 + +data Happy1065 = Happy1065 {name1065 :: String, age1065 :: Int, happy1065 :: Bool} +man1065 :: Happy1065 +man1065 = Happy1065 {name1065 = "Happy", age1065 = 1, happy1065 = True} +test1065 :: String +test1065 = name1065 man1065 + +data Happy1066 = Happy1066 {name1066 :: String, age1066 :: Int, happy1066 :: Bool} +man1066 :: Happy1066 +man1066 = Happy1066 {name1066 = "Happy", age1066 = 1, happy1066 = True} +test1066 :: String +test1066 = name1066 man1066 + +data Happy1067 = Happy1067 {name1067 :: String, age1067 :: Int, happy1067 :: Bool} +man1067 :: Happy1067 +man1067 = Happy1067 {name1067 = "Happy", age1067 = 1, happy1067 = True} +test1067 :: String +test1067 = name1067 man1067 + +data Happy1068 = Happy1068 {name1068 :: String, age1068 :: Int, happy1068 :: Bool} +man1068 :: Happy1068 +man1068 = Happy1068 {name1068 = "Happy", age1068 = 1, happy1068 = True} +test1068 :: String +test1068 = name1068 man1068 + +data Happy1069 = Happy1069 {name1069 :: String, age1069 :: Int, happy1069 :: Bool} +man1069 :: Happy1069 +man1069 = Happy1069 {name1069 = "Happy", age1069 = 1, happy1069 = True} +test1069 :: String +test1069 = name1069 man1069 + +data Happy1070 = Happy1070 {name1070 :: String, age1070 :: Int, happy1070 :: Bool} +man1070 :: Happy1070 +man1070 = Happy1070 {name1070 = "Happy", age1070 = 1, happy1070 = True} +test1070 :: String +test1070 = name1070 man1070 + +data Happy1071 = Happy1071 {name1071 :: String, age1071 :: Int, happy1071 :: Bool} +man1071 :: Happy1071 +man1071 = Happy1071 {name1071 = "Happy", age1071 = 1, happy1071 = True} +test1071 :: String +test1071 = name1071 man1071 + +data Happy1072 = Happy1072 {name1072 :: String, age1072 :: Int, happy1072 :: Bool} +man1072 :: Happy1072 +man1072 = Happy1072 {name1072 = "Happy", age1072 = 1, happy1072 = True} +test1072 :: String +test1072 = name1072 man1072 + +data Happy1073 = Happy1073 {name1073 :: String, age1073 :: Int, happy1073 :: Bool} +man1073 :: Happy1073 +man1073 = Happy1073 {name1073 = "Happy", age1073 = 1, happy1073 = True} +test1073 :: String +test1073 = name1073 man1073 + +data Happy1074 = Happy1074 {name1074 :: String, age1074 :: Int, happy1074 :: Bool} +man1074 :: Happy1074 +man1074 = Happy1074 {name1074 = "Happy", age1074 = 1, happy1074 = True} +test1074 :: String +test1074 = name1074 man1074 + +data Happy1075 = Happy1075 {name1075 :: String, age1075 :: Int, happy1075 :: Bool} +man1075 :: Happy1075 +man1075 = Happy1075 {name1075 = "Happy", age1075 = 1, happy1075 = True} +test1075 :: String +test1075 = name1075 man1075 + +data Happy1076 = Happy1076 {name1076 :: String, age1076 :: Int, happy1076 :: Bool} +man1076 :: Happy1076 +man1076 = Happy1076 {name1076 = "Happy", age1076 = 1, happy1076 = True} +test1076 :: String +test1076 = name1076 man1076 + +data Happy1077 = Happy1077 {name1077 :: String, age1077 :: Int, happy1077 :: Bool} +man1077 :: Happy1077 +man1077 = Happy1077 {name1077 = "Happy", age1077 = 1, happy1077 = True} +test1077 :: String +test1077 = name1077 man1077 + +data Happy1078 = Happy1078 {name1078 :: String, age1078 :: Int, happy1078 :: Bool} +man1078 :: Happy1078 +man1078 = Happy1078 {name1078 = "Happy", age1078 = 1, happy1078 = True} +test1078 :: String +test1078 = name1078 man1078 + +data Happy1079 = Happy1079 {name1079 :: String, age1079 :: Int, happy1079 :: Bool} +man1079 :: Happy1079 +man1079 = Happy1079 {name1079 = "Happy", age1079 = 1, happy1079 = True} +test1079 :: String +test1079 = name1079 man1079 + +data Happy1080 = Happy1080 {name1080 :: String, age1080 :: Int, happy1080 :: Bool} +man1080 :: Happy1080 +man1080 = Happy1080 {name1080 = "Happy", age1080 = 1, happy1080 = True} +test1080 :: String +test1080 = name1080 man1080 + +data Happy1081 = Happy1081 {name1081 :: String, age1081 :: Int, happy1081 :: Bool} +man1081 :: Happy1081 +man1081 = Happy1081 {name1081 = "Happy", age1081 = 1, happy1081 = True} +test1081 :: String +test1081 = name1081 man1081 + +data Happy1082 = Happy1082 {name1082 :: String, age1082 :: Int, happy1082 :: Bool} +man1082 :: Happy1082 +man1082 = Happy1082 {name1082 = "Happy", age1082 = 1, happy1082 = True} +test1082 :: String +test1082 = name1082 man1082 + +data Happy1083 = Happy1083 {name1083 :: String, age1083 :: Int, happy1083 :: Bool} +man1083 :: Happy1083 +man1083 = Happy1083 {name1083 = "Happy", age1083 = 1, happy1083 = True} +test1083 :: String +test1083 = name1083 man1083 + +data Happy1084 = Happy1084 {name1084 :: String, age1084 :: Int, happy1084 :: Bool} +man1084 :: Happy1084 +man1084 = Happy1084 {name1084 = "Happy", age1084 = 1, happy1084 = True} +test1084 :: String +test1084 = name1084 man1084 + +data Happy1085 = Happy1085 {name1085 :: String, age1085 :: Int, happy1085 :: Bool} +man1085 :: Happy1085 +man1085 = Happy1085 {name1085 = "Happy", age1085 = 1, happy1085 = True} +test1085 :: String +test1085 = name1085 man1085 + +data Happy1086 = Happy1086 {name1086 :: String, age1086 :: Int, happy1086 :: Bool} +man1086 :: Happy1086 +man1086 = Happy1086 {name1086 = "Happy", age1086 = 1, happy1086 = True} +test1086 :: String +test1086 = name1086 man1086 + +data Happy1087 = Happy1087 {name1087 :: String, age1087 :: Int, happy1087 :: Bool} +man1087 :: Happy1087 +man1087 = Happy1087 {name1087 = "Happy", age1087 = 1, happy1087 = True} +test1087 :: String +test1087 = name1087 man1087 + +data Happy1088 = Happy1088 {name1088 :: String, age1088 :: Int, happy1088 :: Bool} +man1088 :: Happy1088 +man1088 = Happy1088 {name1088 = "Happy", age1088 = 1, happy1088 = True} +test1088 :: String +test1088 = name1088 man1088 + +data Happy1089 = Happy1089 {name1089 :: String, age1089 :: Int, happy1089 :: Bool} +man1089 :: Happy1089 +man1089 = Happy1089 {name1089 = "Happy", age1089 = 1, happy1089 = True} +test1089 :: String +test1089 = name1089 man1089 + +data Happy1090 = Happy1090 {name1090 :: String, age1090 :: Int, happy1090 :: Bool} +man1090 :: Happy1090 +man1090 = Happy1090 {name1090 = "Happy", age1090 = 1, happy1090 = True} +test1090 :: String +test1090 = name1090 man1090 + +data Happy1091 = Happy1091 {name1091 :: String, age1091 :: Int, happy1091 :: Bool} +man1091 :: Happy1091 +man1091 = Happy1091 {name1091 = "Happy", age1091 = 1, happy1091 = True} +test1091 :: String +test1091 = name1091 man1091 + +data Happy1092 = Happy1092 {name1092 :: String, age1092 :: Int, happy1092 :: Bool} +man1092 :: Happy1092 +man1092 = Happy1092 {name1092 = "Happy", age1092 = 1, happy1092 = True} +test1092 :: String +test1092 = name1092 man1092 + +data Happy1093 = Happy1093 {name1093 :: String, age1093 :: Int, happy1093 :: Bool} +man1093 :: Happy1093 +man1093 = Happy1093 {name1093 = "Happy", age1093 = 1, happy1093 = True} +test1093 :: String +test1093 = name1093 man1093 + +data Happy1094 = Happy1094 {name1094 :: String, age1094 :: Int, happy1094 :: Bool} +man1094 :: Happy1094 +man1094 = Happy1094 {name1094 = "Happy", age1094 = 1, happy1094 = True} +test1094 :: String +test1094 = name1094 man1094 + +data Happy1095 = Happy1095 {name1095 :: String, age1095 :: Int, happy1095 :: Bool} +man1095 :: Happy1095 +man1095 = Happy1095 {name1095 = "Happy", age1095 = 1, happy1095 = True} +test1095 :: String +test1095 = name1095 man1095 + +data Happy1096 = Happy1096 {name1096 :: String, age1096 :: Int, happy1096 :: Bool} +man1096 :: Happy1096 +man1096 = Happy1096 {name1096 = "Happy", age1096 = 1, happy1096 = True} +test1096 :: String +test1096 = name1096 man1096 + +data Happy1097 = Happy1097 {name1097 :: String, age1097 :: Int, happy1097 :: Bool} +man1097 :: Happy1097 +man1097 = Happy1097 {name1097 = "Happy", age1097 = 1, happy1097 = True} +test1097 :: String +test1097 = name1097 man1097 + +data Happy1098 = Happy1098 {name1098 :: String, age1098 :: Int, happy1098 :: Bool} +man1098 :: Happy1098 +man1098 = Happy1098 {name1098 = "Happy", age1098 = 1, happy1098 = True} +test1098 :: String +test1098 = name1098 man1098 + +data Happy1099 = Happy1099 {name1099 :: String, age1099 :: Int, happy1099 :: Bool} +man1099 :: Happy1099 +man1099 = Happy1099 {name1099 = "Happy", age1099 = 1, happy1099 = True} +test1099 :: String +test1099 = name1099 man1099 + +data Happy1100 = Happy1100 {name1100 :: String, age1100 :: Int, happy1100 :: Bool} +man1100 :: Happy1100 +man1100 = Happy1100 {name1100 = "Happy", age1100 = 1, happy1100 = True} +test1100 :: String +test1100 = name1100 man1100 + +data Happy1101 = Happy1101 {name1101 :: String, age1101 :: Int, happy1101 :: Bool} +man1101 :: Happy1101 +man1101 = Happy1101 {name1101 = "Happy", age1101 = 1, happy1101 = True} +test1101 :: String +test1101 = name1101 man1101 + +data Happy1102 = Happy1102 {name1102 :: String, age1102 :: Int, happy1102 :: Bool} +man1102 :: Happy1102 +man1102 = Happy1102 {name1102 = "Happy", age1102 = 1, happy1102 = True} +test1102 :: String +test1102 = name1102 man1102 + +data Happy1103 = Happy1103 {name1103 :: String, age1103 :: Int, happy1103 :: Bool} +man1103 :: Happy1103 +man1103 = Happy1103 {name1103 = "Happy", age1103 = 1, happy1103 = True} +test1103 :: String +test1103 = name1103 man1103 + +data Happy1104 = Happy1104 {name1104 :: String, age1104 :: Int, happy1104 :: Bool} +man1104 :: Happy1104 +man1104 = Happy1104 {name1104 = "Happy", age1104 = 1, happy1104 = True} +test1104 :: String +test1104 = name1104 man1104 + +data Happy1105 = Happy1105 {name1105 :: String, age1105 :: Int, happy1105 :: Bool} +man1105 :: Happy1105 +man1105 = Happy1105 {name1105 = "Happy", age1105 = 1, happy1105 = True} +test1105 :: String +test1105 = name1105 man1105 + +data Happy1106 = Happy1106 {name1106 :: String, age1106 :: Int, happy1106 :: Bool} +man1106 :: Happy1106 +man1106 = Happy1106 {name1106 = "Happy", age1106 = 1, happy1106 = True} +test1106 :: String +test1106 = name1106 man1106 + +data Happy1107 = Happy1107 {name1107 :: String, age1107 :: Int, happy1107 :: Bool} +man1107 :: Happy1107 +man1107 = Happy1107 {name1107 = "Happy", age1107 = 1, happy1107 = True} +test1107 :: String +test1107 = name1107 man1107 + +data Happy1108 = Happy1108 {name1108 :: String, age1108 :: Int, happy1108 :: Bool} +man1108 :: Happy1108 +man1108 = Happy1108 {name1108 = "Happy", age1108 = 1, happy1108 = True} +test1108 :: String +test1108 = name1108 man1108 + +data Happy1109 = Happy1109 {name1109 :: String, age1109 :: Int, happy1109 :: Bool} +man1109 :: Happy1109 +man1109 = Happy1109 {name1109 = "Happy", age1109 = 1, happy1109 = True} +test1109 :: String +test1109 = name1109 man1109 + +data Happy1110 = Happy1110 {name1110 :: String, age1110 :: Int, happy1110 :: Bool} +man1110 :: Happy1110 +man1110 = Happy1110 {name1110 = "Happy", age1110 = 1, happy1110 = True} +test1110 :: String +test1110 = name1110 man1110 + +data Happy1111 = Happy1111 {name1111 :: String, age1111 :: Int, happy1111 :: Bool} +man1111 :: Happy1111 +man1111 = Happy1111 {name1111 = "Happy", age1111 = 1, happy1111 = True} +test1111 :: String +test1111 = name1111 man1111 + +data Happy1112 = Happy1112 {name1112 :: String, age1112 :: Int, happy1112 :: Bool} +man1112 :: Happy1112 +man1112 = Happy1112 {name1112 = "Happy", age1112 = 1, happy1112 = True} +test1112 :: String +test1112 = name1112 man1112 + +data Happy1113 = Happy1113 {name1113 :: String, age1113 :: Int, happy1113 :: Bool} +man1113 :: Happy1113 +man1113 = Happy1113 {name1113 = "Happy", age1113 = 1, happy1113 = True} +test1113 :: String +test1113 = name1113 man1113 + +data Happy1114 = Happy1114 {name1114 :: String, age1114 :: Int, happy1114 :: Bool} +man1114 :: Happy1114 +man1114 = Happy1114 {name1114 = "Happy", age1114 = 1, happy1114 = True} +test1114 :: String +test1114 = name1114 man1114 + +data Happy1115 = Happy1115 {name1115 :: String, age1115 :: Int, happy1115 :: Bool} +man1115 :: Happy1115 +man1115 = Happy1115 {name1115 = "Happy", age1115 = 1, happy1115 = True} +test1115 :: String +test1115 = name1115 man1115 + +data Happy1116 = Happy1116 {name1116 :: String, age1116 :: Int, happy1116 :: Bool} +man1116 :: Happy1116 +man1116 = Happy1116 {name1116 = "Happy", age1116 = 1, happy1116 = True} +test1116 :: String +test1116 = name1116 man1116 + +data Happy1117 = Happy1117 {name1117 :: String, age1117 :: Int, happy1117 :: Bool} +man1117 :: Happy1117 +man1117 = Happy1117 {name1117 = "Happy", age1117 = 1, happy1117 = True} +test1117 :: String +test1117 = name1117 man1117 + +data Happy1118 = Happy1118 {name1118 :: String, age1118 :: Int, happy1118 :: Bool} +man1118 :: Happy1118 +man1118 = Happy1118 {name1118 = "Happy", age1118 = 1, happy1118 = True} +test1118 :: String +test1118 = name1118 man1118 + +data Happy1119 = Happy1119 {name1119 :: String, age1119 :: Int, happy1119 :: Bool} +man1119 :: Happy1119 +man1119 = Happy1119 {name1119 = "Happy", age1119 = 1, happy1119 = True} +test1119 :: String +test1119 = name1119 man1119 + +data Happy1120 = Happy1120 {name1120 :: String, age1120 :: Int, happy1120 :: Bool} +man1120 :: Happy1120 +man1120 = Happy1120 {name1120 = "Happy", age1120 = 1, happy1120 = True} +test1120 :: String +test1120 = name1120 man1120 + +data Happy1121 = Happy1121 {name1121 :: String, age1121 :: Int, happy1121 :: Bool} +man1121 :: Happy1121 +man1121 = Happy1121 {name1121 = "Happy", age1121 = 1, happy1121 = True} +test1121 :: String +test1121 = name1121 man1121 + +data Happy1122 = Happy1122 {name1122 :: String, age1122 :: Int, happy1122 :: Bool} +man1122 :: Happy1122 +man1122 = Happy1122 {name1122 = "Happy", age1122 = 1, happy1122 = True} +test1122 :: String +test1122 = name1122 man1122 + +data Happy1123 = Happy1123 {name1123 :: String, age1123 :: Int, happy1123 :: Bool} +man1123 :: Happy1123 +man1123 = Happy1123 {name1123 = "Happy", age1123 = 1, happy1123 = True} +test1123 :: String +test1123 = name1123 man1123 + +data Happy1124 = Happy1124 {name1124 :: String, age1124 :: Int, happy1124 :: Bool} +man1124 :: Happy1124 +man1124 = Happy1124 {name1124 = "Happy", age1124 = 1, happy1124 = True} +test1124 :: String +test1124 = name1124 man1124 + +data Happy1125 = Happy1125 {name1125 :: String, age1125 :: Int, happy1125 :: Bool} +man1125 :: Happy1125 +man1125 = Happy1125 {name1125 = "Happy", age1125 = 1, happy1125 = True} +test1125 :: String +test1125 = name1125 man1125 + +data Happy1126 = Happy1126 {name1126 :: String, age1126 :: Int, happy1126 :: Bool} +man1126 :: Happy1126 +man1126 = Happy1126 {name1126 = "Happy", age1126 = 1, happy1126 = True} +test1126 :: String +test1126 = name1126 man1126 + +data Happy1127 = Happy1127 {name1127 :: String, age1127 :: Int, happy1127 :: Bool} +man1127 :: Happy1127 +man1127 = Happy1127 {name1127 = "Happy", age1127 = 1, happy1127 = True} +test1127 :: String +test1127 = name1127 man1127 + +data Happy1128 = Happy1128 {name1128 :: String, age1128 :: Int, happy1128 :: Bool} +man1128 :: Happy1128 +man1128 = Happy1128 {name1128 = "Happy", age1128 = 1, happy1128 = True} +test1128 :: String +test1128 = name1128 man1128 + +data Happy1129 = Happy1129 {name1129 :: String, age1129 :: Int, happy1129 :: Bool} +man1129 :: Happy1129 +man1129 = Happy1129 {name1129 = "Happy", age1129 = 1, happy1129 = True} +test1129 :: String +test1129 = name1129 man1129 + +data Happy1130 = Happy1130 {name1130 :: String, age1130 :: Int, happy1130 :: Bool} +man1130 :: Happy1130 +man1130 = Happy1130 {name1130 = "Happy", age1130 = 1, happy1130 = True} +test1130 :: String +test1130 = name1130 man1130 + +data Happy1131 = Happy1131 {name1131 :: String, age1131 :: Int, happy1131 :: Bool} +man1131 :: Happy1131 +man1131 = Happy1131 {name1131 = "Happy", age1131 = 1, happy1131 = True} +test1131 :: String +test1131 = name1131 man1131 + +data Happy1132 = Happy1132 {name1132 :: String, age1132 :: Int, happy1132 :: Bool} +man1132 :: Happy1132 +man1132 = Happy1132 {name1132 = "Happy", age1132 = 1, happy1132 = True} +test1132 :: String +test1132 = name1132 man1132 + +data Happy1133 = Happy1133 {name1133 :: String, age1133 :: Int, happy1133 :: Bool} +man1133 :: Happy1133 +man1133 = Happy1133 {name1133 = "Happy", age1133 = 1, happy1133 = True} +test1133 :: String +test1133 = name1133 man1133 + +data Happy1134 = Happy1134 {name1134 :: String, age1134 :: Int, happy1134 :: Bool} +man1134 :: Happy1134 +man1134 = Happy1134 {name1134 = "Happy", age1134 = 1, happy1134 = True} +test1134 :: String +test1134 = name1134 man1134 + +data Happy1135 = Happy1135 {name1135 :: String, age1135 :: Int, happy1135 :: Bool} +man1135 :: Happy1135 +man1135 = Happy1135 {name1135 = "Happy", age1135 = 1, happy1135 = True} +test1135 :: String +test1135 = name1135 man1135 + +data Happy1136 = Happy1136 {name1136 :: String, age1136 :: Int, happy1136 :: Bool} +man1136 :: Happy1136 +man1136 = Happy1136 {name1136 = "Happy", age1136 = 1, happy1136 = True} +test1136 :: String +test1136 = name1136 man1136 + +data Happy1137 = Happy1137 {name1137 :: String, age1137 :: Int, happy1137 :: Bool} +man1137 :: Happy1137 +man1137 = Happy1137 {name1137 = "Happy", age1137 = 1, happy1137 = True} +test1137 :: String +test1137 = name1137 man1137 + +data Happy1138 = Happy1138 {name1138 :: String, age1138 :: Int, happy1138 :: Bool} +man1138 :: Happy1138 +man1138 = Happy1138 {name1138 = "Happy", age1138 = 1, happy1138 = True} +test1138 :: String +test1138 = name1138 man1138 + +data Happy1139 = Happy1139 {name1139 :: String, age1139 :: Int, happy1139 :: Bool} +man1139 :: Happy1139 +man1139 = Happy1139 {name1139 = "Happy", age1139 = 1, happy1139 = True} +test1139 :: String +test1139 = name1139 man1139 + +data Happy1140 = Happy1140 {name1140 :: String, age1140 :: Int, happy1140 :: Bool} +man1140 :: Happy1140 +man1140 = Happy1140 {name1140 = "Happy", age1140 = 1, happy1140 = True} +test1140 :: String +test1140 = name1140 man1140 + +data Happy1141 = Happy1141 {name1141 :: String, age1141 :: Int, happy1141 :: Bool} +man1141 :: Happy1141 +man1141 = Happy1141 {name1141 = "Happy", age1141 = 1, happy1141 = True} +test1141 :: String +test1141 = name1141 man1141 + +data Happy1142 = Happy1142 {name1142 :: String, age1142 :: Int, happy1142 :: Bool} +man1142 :: Happy1142 +man1142 = Happy1142 {name1142 = "Happy", age1142 = 1, happy1142 = True} +test1142 :: String +test1142 = name1142 man1142 + +data Happy1143 = Happy1143 {name1143 :: String, age1143 :: Int, happy1143 :: Bool} +man1143 :: Happy1143 +man1143 = Happy1143 {name1143 = "Happy", age1143 = 1, happy1143 = True} +test1143 :: String +test1143 = name1143 man1143 + +data Happy1144 = Happy1144 {name1144 :: String, age1144 :: Int, happy1144 :: Bool} +man1144 :: Happy1144 +man1144 = Happy1144 {name1144 = "Happy", age1144 = 1, happy1144 = True} +test1144 :: String +test1144 = name1144 man1144 + +data Happy1145 = Happy1145 {name1145 :: String, age1145 :: Int, happy1145 :: Bool} +man1145 :: Happy1145 +man1145 = Happy1145 {name1145 = "Happy", age1145 = 1, happy1145 = True} +test1145 :: String +test1145 = name1145 man1145 + +data Happy1146 = Happy1146 {name1146 :: String, age1146 :: Int, happy1146 :: Bool} +man1146 :: Happy1146 +man1146 = Happy1146 {name1146 = "Happy", age1146 = 1, happy1146 = True} +test1146 :: String +test1146 = name1146 man1146 + +data Happy1147 = Happy1147 {name1147 :: String, age1147 :: Int, happy1147 :: Bool} +man1147 :: Happy1147 +man1147 = Happy1147 {name1147 = "Happy", age1147 = 1, happy1147 = True} +test1147 :: String +test1147 = name1147 man1147 + +data Happy1148 = Happy1148 {name1148 :: String, age1148 :: Int, happy1148 :: Bool} +man1148 :: Happy1148 +man1148 = Happy1148 {name1148 = "Happy", age1148 = 1, happy1148 = True} +test1148 :: String +test1148 = name1148 man1148 + +data Happy1149 = Happy1149 {name1149 :: String, age1149 :: Int, happy1149 :: Bool} +man1149 :: Happy1149 +man1149 = Happy1149 {name1149 = "Happy", age1149 = 1, happy1149 = True} +test1149 :: String +test1149 = name1149 man1149 + +data Happy1150 = Happy1150 {name1150 :: String, age1150 :: Int, happy1150 :: Bool} +man1150 :: Happy1150 +man1150 = Happy1150 {name1150 = "Happy", age1150 = 1, happy1150 = True} +test1150 :: String +test1150 = name1150 man1150 + +data Happy1151 = Happy1151 {name1151 :: String, age1151 :: Int, happy1151 :: Bool} +man1151 :: Happy1151 +man1151 = Happy1151 {name1151 = "Happy", age1151 = 1, happy1151 = True} +test1151 :: String +test1151 = name1151 man1151 + +data Happy1152 = Happy1152 {name1152 :: String, age1152 :: Int, happy1152 :: Bool} +man1152 :: Happy1152 +man1152 = Happy1152 {name1152 = "Happy", age1152 = 1, happy1152 = True} +test1152 :: String +test1152 = name1152 man1152 + +data Happy1153 = Happy1153 {name1153 :: String, age1153 :: Int, happy1153 :: Bool} +man1153 :: Happy1153 +man1153 = Happy1153 {name1153 = "Happy", age1153 = 1, happy1153 = True} +test1153 :: String +test1153 = name1153 man1153 + +data Happy1154 = Happy1154 {name1154 :: String, age1154 :: Int, happy1154 :: Bool} +man1154 :: Happy1154 +man1154 = Happy1154 {name1154 = "Happy", age1154 = 1, happy1154 = True} +test1154 :: String +test1154 = name1154 man1154 + +data Happy1155 = Happy1155 {name1155 :: String, age1155 :: Int, happy1155 :: Bool} +man1155 :: Happy1155 +man1155 = Happy1155 {name1155 = "Happy", age1155 = 1, happy1155 = True} +test1155 :: String +test1155 = name1155 man1155 + +data Happy1156 = Happy1156 {name1156 :: String, age1156 :: Int, happy1156 :: Bool} +man1156 :: Happy1156 +man1156 = Happy1156 {name1156 = "Happy", age1156 = 1, happy1156 = True} +test1156 :: String +test1156 = name1156 man1156 + +data Happy1157 = Happy1157 {name1157 :: String, age1157 :: Int, happy1157 :: Bool} +man1157 :: Happy1157 +man1157 = Happy1157 {name1157 = "Happy", age1157 = 1, happy1157 = True} +test1157 :: String +test1157 = name1157 man1157 + +data Happy1158 = Happy1158 {name1158 :: String, age1158 :: Int, happy1158 :: Bool} +man1158 :: Happy1158 +man1158 = Happy1158 {name1158 = "Happy", age1158 = 1, happy1158 = True} +test1158 :: String +test1158 = name1158 man1158 + +data Happy1159 = Happy1159 {name1159 :: String, age1159 :: Int, happy1159 :: Bool} +man1159 :: Happy1159 +man1159 = Happy1159 {name1159 = "Happy", age1159 = 1, happy1159 = True} +test1159 :: String +test1159 = name1159 man1159 + +data Happy1160 = Happy1160 {name1160 :: String, age1160 :: Int, happy1160 :: Bool} +man1160 :: Happy1160 +man1160 = Happy1160 {name1160 = "Happy", age1160 = 1, happy1160 = True} +test1160 :: String +test1160 = name1160 man1160 + +data Happy1161 = Happy1161 {name1161 :: String, age1161 :: Int, happy1161 :: Bool} +man1161 :: Happy1161 +man1161 = Happy1161 {name1161 = "Happy", age1161 = 1, happy1161 = True} +test1161 :: String +test1161 = name1161 man1161 + +data Happy1162 = Happy1162 {name1162 :: String, age1162 :: Int, happy1162 :: Bool} +man1162 :: Happy1162 +man1162 = Happy1162 {name1162 = "Happy", age1162 = 1, happy1162 = True} +test1162 :: String +test1162 = name1162 man1162 + +data Happy1163 = Happy1163 {name1163 :: String, age1163 :: Int, happy1163 :: Bool} +man1163 :: Happy1163 +man1163 = Happy1163 {name1163 = "Happy", age1163 = 1, happy1163 = True} +test1163 :: String +test1163 = name1163 man1163 + +data Happy1164 = Happy1164 {name1164 :: String, age1164 :: Int, happy1164 :: Bool} +man1164 :: Happy1164 +man1164 = Happy1164 {name1164 = "Happy", age1164 = 1, happy1164 = True} +test1164 :: String +test1164 = name1164 man1164 + +data Happy1165 = Happy1165 {name1165 :: String, age1165 :: Int, happy1165 :: Bool} +man1165 :: Happy1165 +man1165 = Happy1165 {name1165 = "Happy", age1165 = 1, happy1165 = True} +test1165 :: String +test1165 = name1165 man1165 + +data Happy1166 = Happy1166 {name1166 :: String, age1166 :: Int, happy1166 :: Bool} +man1166 :: Happy1166 +man1166 = Happy1166 {name1166 = "Happy", age1166 = 1, happy1166 = True} +test1166 :: String +test1166 = name1166 man1166 + +data Happy1167 = Happy1167 {name1167 :: String, age1167 :: Int, happy1167 :: Bool} +man1167 :: Happy1167 +man1167 = Happy1167 {name1167 = "Happy", age1167 = 1, happy1167 = True} +test1167 :: String +test1167 = name1167 man1167 + +data Happy1168 = Happy1168 {name1168 :: String, age1168 :: Int, happy1168 :: Bool} +man1168 :: Happy1168 +man1168 = Happy1168 {name1168 = "Happy", age1168 = 1, happy1168 = True} +test1168 :: String +test1168 = name1168 man1168 + +data Happy1169 = Happy1169 {name1169 :: String, age1169 :: Int, happy1169 :: Bool} +man1169 :: Happy1169 +man1169 = Happy1169 {name1169 = "Happy", age1169 = 1, happy1169 = True} +test1169 :: String +test1169 = name1169 man1169 + +data Happy1170 = Happy1170 {name1170 :: String, age1170 :: Int, happy1170 :: Bool} +man1170 :: Happy1170 +man1170 = Happy1170 {name1170 = "Happy", age1170 = 1, happy1170 = True} +test1170 :: String +test1170 = name1170 man1170 + +data Happy1171 = Happy1171 {name1171 :: String, age1171 :: Int, happy1171 :: Bool} +man1171 :: Happy1171 +man1171 = Happy1171 {name1171 = "Happy", age1171 = 1, happy1171 = True} +test1171 :: String +test1171 = name1171 man1171 + +data Happy1172 = Happy1172 {name1172 :: String, age1172 :: Int, happy1172 :: Bool} +man1172 :: Happy1172 +man1172 = Happy1172 {name1172 = "Happy", age1172 = 1, happy1172 = True} +test1172 :: String +test1172 = name1172 man1172 + +data Happy1173 = Happy1173 {name1173 :: String, age1173 :: Int, happy1173 :: Bool} +man1173 :: Happy1173 +man1173 = Happy1173 {name1173 = "Happy", age1173 = 1, happy1173 = True} +test1173 :: String +test1173 = name1173 man1173 + +data Happy1174 = Happy1174 {name1174 :: String, age1174 :: Int, happy1174 :: Bool} +man1174 :: Happy1174 +man1174 = Happy1174 {name1174 = "Happy", age1174 = 1, happy1174 = True} +test1174 :: String +test1174 = name1174 man1174 + +data Happy1175 = Happy1175 {name1175 :: String, age1175 :: Int, happy1175 :: Bool} +man1175 :: Happy1175 +man1175 = Happy1175 {name1175 = "Happy", age1175 = 1, happy1175 = True} +test1175 :: String +test1175 = name1175 man1175 + +data Happy1176 = Happy1176 {name1176 :: String, age1176 :: Int, happy1176 :: Bool} +man1176 :: Happy1176 +man1176 = Happy1176 {name1176 = "Happy", age1176 = 1, happy1176 = True} +test1176 :: String +test1176 = name1176 man1176 + +data Happy1177 = Happy1177 {name1177 :: String, age1177 :: Int, happy1177 :: Bool} +man1177 :: Happy1177 +man1177 = Happy1177 {name1177 = "Happy", age1177 = 1, happy1177 = True} +test1177 :: String +test1177 = name1177 man1177 + +data Happy1178 = Happy1178 {name1178 :: String, age1178 :: Int, happy1178 :: Bool} +man1178 :: Happy1178 +man1178 = Happy1178 {name1178 = "Happy", age1178 = 1, happy1178 = True} +test1178 :: String +test1178 = name1178 man1178 + +data Happy1179 = Happy1179 {name1179 :: String, age1179 :: Int, happy1179 :: Bool} +man1179 :: Happy1179 +man1179 = Happy1179 {name1179 = "Happy", age1179 = 1, happy1179 = True} +test1179 :: String +test1179 = name1179 man1179 + +data Happy1180 = Happy1180 {name1180 :: String, age1180 :: Int, happy1180 :: Bool} +man1180 :: Happy1180 +man1180 = Happy1180 {name1180 = "Happy", age1180 = 1, happy1180 = True} +test1180 :: String +test1180 = name1180 man1180 + +data Happy1181 = Happy1181 {name1181 :: String, age1181 :: Int, happy1181 :: Bool} +man1181 :: Happy1181 +man1181 = Happy1181 {name1181 = "Happy", age1181 = 1, happy1181 = True} +test1181 :: String +test1181 = name1181 man1181 + +data Happy1182 = Happy1182 {name1182 :: String, age1182 :: Int, happy1182 :: Bool} +man1182 :: Happy1182 +man1182 = Happy1182 {name1182 = "Happy", age1182 = 1, happy1182 = True} +test1182 :: String +test1182 = name1182 man1182 + +data Happy1183 = Happy1183 {name1183 :: String, age1183 :: Int, happy1183 :: Bool} +man1183 :: Happy1183 +man1183 = Happy1183 {name1183 = "Happy", age1183 = 1, happy1183 = True} +test1183 :: String +test1183 = name1183 man1183 + +data Happy1184 = Happy1184 {name1184 :: String, age1184 :: Int, happy1184 :: Bool} +man1184 :: Happy1184 +man1184 = Happy1184 {name1184 = "Happy", age1184 = 1, happy1184 = True} +test1184 :: String +test1184 = name1184 man1184 + +data Happy1185 = Happy1185 {name1185 :: String, age1185 :: Int, happy1185 :: Bool} +man1185 :: Happy1185 +man1185 = Happy1185 {name1185 = "Happy", age1185 = 1, happy1185 = True} +test1185 :: String +test1185 = name1185 man1185 + +data Happy1186 = Happy1186 {name1186 :: String, age1186 :: Int, happy1186 :: Bool} +man1186 :: Happy1186 +man1186 = Happy1186 {name1186 = "Happy", age1186 = 1, happy1186 = True} +test1186 :: String +test1186 = name1186 man1186 + +data Happy1187 = Happy1187 {name1187 :: String, age1187 :: Int, happy1187 :: Bool} +man1187 :: Happy1187 +man1187 = Happy1187 {name1187 = "Happy", age1187 = 1, happy1187 = True} +test1187 :: String +test1187 = name1187 man1187 + +data Happy1188 = Happy1188 {name1188 :: String, age1188 :: Int, happy1188 :: Bool} +man1188 :: Happy1188 +man1188 = Happy1188 {name1188 = "Happy", age1188 = 1, happy1188 = True} +test1188 :: String +test1188 = name1188 man1188 + +data Happy1189 = Happy1189 {name1189 :: String, age1189 :: Int, happy1189 :: Bool} +man1189 :: Happy1189 +man1189 = Happy1189 {name1189 = "Happy", age1189 = 1, happy1189 = True} +test1189 :: String +test1189 = name1189 man1189 + +data Happy1190 = Happy1190 {name1190 :: String, age1190 :: Int, happy1190 :: Bool} +man1190 :: Happy1190 +man1190 = Happy1190 {name1190 = "Happy", age1190 = 1, happy1190 = True} +test1190 :: String +test1190 = name1190 man1190 + +data Happy1191 = Happy1191 {name1191 :: String, age1191 :: Int, happy1191 :: Bool} +man1191 :: Happy1191 +man1191 = Happy1191 {name1191 = "Happy", age1191 = 1, happy1191 = True} +test1191 :: String +test1191 = name1191 man1191 + +data Happy1192 = Happy1192 {name1192 :: String, age1192 :: Int, happy1192 :: Bool} +man1192 :: Happy1192 +man1192 = Happy1192 {name1192 = "Happy", age1192 = 1, happy1192 = True} +test1192 :: String +test1192 = name1192 man1192 + +data Happy1193 = Happy1193 {name1193 :: String, age1193 :: Int, happy1193 :: Bool} +man1193 :: Happy1193 +man1193 = Happy1193 {name1193 = "Happy", age1193 = 1, happy1193 = True} +test1193 :: String +test1193 = name1193 man1193 + +data Happy1194 = Happy1194 {name1194 :: String, age1194 :: Int, happy1194 :: Bool} +man1194 :: Happy1194 +man1194 = Happy1194 {name1194 = "Happy", age1194 = 1, happy1194 = True} +test1194 :: String +test1194 = name1194 man1194 + +data Happy1195 = Happy1195 {name1195 :: String, age1195 :: Int, happy1195 :: Bool} +man1195 :: Happy1195 +man1195 = Happy1195 {name1195 = "Happy", age1195 = 1, happy1195 = True} +test1195 :: String +test1195 = name1195 man1195 + +data Happy1196 = Happy1196 {name1196 :: String, age1196 :: Int, happy1196 :: Bool} +man1196 :: Happy1196 +man1196 = Happy1196 {name1196 = "Happy", age1196 = 1, happy1196 = True} +test1196 :: String +test1196 = name1196 man1196 + +data Happy1197 = Happy1197 {name1197 :: String, age1197 :: Int, happy1197 :: Bool} +man1197 :: Happy1197 +man1197 = Happy1197 {name1197 = "Happy", age1197 = 1, happy1197 = True} +test1197 :: String +test1197 = name1197 man1197 + +data Happy1198 = Happy1198 {name1198 :: String, age1198 :: Int, happy1198 :: Bool} +man1198 :: Happy1198 +man1198 = Happy1198 {name1198 = "Happy", age1198 = 1, happy1198 = True} +test1198 :: String +test1198 = name1198 man1198 + +data Happy1199 = Happy1199 {name1199 :: String, age1199 :: Int, happy1199 :: Bool} +man1199 :: Happy1199 +man1199 = Happy1199 {name1199 = "Happy", age1199 = 1, happy1199 = True} +test1199 :: String +test1199 = name1199 man1199 + +data Happy1200 = Happy1200 {name1200 :: String, age1200 :: Int, happy1200 :: Bool} +man1200 :: Happy1200 +man1200 = Happy1200 {name1200 = "Happy", age1200 = 1, happy1200 = True} +test1200 :: String +test1200 = name1200 man1200 + +data Happy1201 = Happy1201 {name1201 :: String, age1201 :: Int, happy1201 :: Bool} +man1201 :: Happy1201 +man1201 = Happy1201 {name1201 = "Happy", age1201 = 1, happy1201 = True} +test1201 :: String +test1201 = name1201 man1201 + +data Happy1202 = Happy1202 {name1202 :: String, age1202 :: Int, happy1202 :: Bool} +man1202 :: Happy1202 +man1202 = Happy1202 {name1202 = "Happy", age1202 = 1, happy1202 = True} +test1202 :: String +test1202 = name1202 man1202 + +data Happy1203 = Happy1203 {name1203 :: String, age1203 :: Int, happy1203 :: Bool} +man1203 :: Happy1203 +man1203 = Happy1203 {name1203 = "Happy", age1203 = 1, happy1203 = True} +test1203 :: String +test1203 = name1203 man1203 + +data Happy1204 = Happy1204 {name1204 :: String, age1204 :: Int, happy1204 :: Bool} +man1204 :: Happy1204 +man1204 = Happy1204 {name1204 = "Happy", age1204 = 1, happy1204 = True} +test1204 :: String +test1204 = name1204 man1204 + +data Happy1205 = Happy1205 {name1205 :: String, age1205 :: Int, happy1205 :: Bool} +man1205 :: Happy1205 +man1205 = Happy1205 {name1205 = "Happy", age1205 = 1, happy1205 = True} +test1205 :: String +test1205 = name1205 man1205 + +data Happy1206 = Happy1206 {name1206 :: String, age1206 :: Int, happy1206 :: Bool} +man1206 :: Happy1206 +man1206 = Happy1206 {name1206 = "Happy", age1206 = 1, happy1206 = True} +test1206 :: String +test1206 = name1206 man1206 + +data Happy1207 = Happy1207 {name1207 :: String, age1207 :: Int, happy1207 :: Bool} +man1207 :: Happy1207 +man1207 = Happy1207 {name1207 = "Happy", age1207 = 1, happy1207 = True} +test1207 :: String +test1207 = name1207 man1207 + +data Happy1208 = Happy1208 {name1208 :: String, age1208 :: Int, happy1208 :: Bool} +man1208 :: Happy1208 +man1208 = Happy1208 {name1208 = "Happy", age1208 = 1, happy1208 = True} +test1208 :: String +test1208 = name1208 man1208 + +data Happy1209 = Happy1209 {name1209 :: String, age1209 :: Int, happy1209 :: Bool} +man1209 :: Happy1209 +man1209 = Happy1209 {name1209 = "Happy", age1209 = 1, happy1209 = True} +test1209 :: String +test1209 = name1209 man1209 + +data Happy1210 = Happy1210 {name1210 :: String, age1210 :: Int, happy1210 :: Bool} +man1210 :: Happy1210 +man1210 = Happy1210 {name1210 = "Happy", age1210 = 1, happy1210 = True} +test1210 :: String +test1210 = name1210 man1210 + +data Happy1211 = Happy1211 {name1211 :: String, age1211 :: Int, happy1211 :: Bool} +man1211 :: Happy1211 +man1211 = Happy1211 {name1211 = "Happy", age1211 = 1, happy1211 = True} +test1211 :: String +test1211 = name1211 man1211 + +data Happy1212 = Happy1212 {name1212 :: String, age1212 :: Int, happy1212 :: Bool} +man1212 :: Happy1212 +man1212 = Happy1212 {name1212 = "Happy", age1212 = 1, happy1212 = True} +test1212 :: String +test1212 = name1212 man1212 + +data Happy1213 = Happy1213 {name1213 :: String, age1213 :: Int, happy1213 :: Bool} +man1213 :: Happy1213 +man1213 = Happy1213 {name1213 = "Happy", age1213 = 1, happy1213 = True} +test1213 :: String +test1213 = name1213 man1213 + +data Happy1214 = Happy1214 {name1214 :: String, age1214 :: Int, happy1214 :: Bool} +man1214 :: Happy1214 +man1214 = Happy1214 {name1214 = "Happy", age1214 = 1, happy1214 = True} +test1214 :: String +test1214 = name1214 man1214 + +data Happy1215 = Happy1215 {name1215 :: String, age1215 :: Int, happy1215 :: Bool} +man1215 :: Happy1215 +man1215 = Happy1215 {name1215 = "Happy", age1215 = 1, happy1215 = True} +test1215 :: String +test1215 = name1215 man1215 + +data Happy1216 = Happy1216 {name1216 :: String, age1216 :: Int, happy1216 :: Bool} +man1216 :: Happy1216 +man1216 = Happy1216 {name1216 = "Happy", age1216 = 1, happy1216 = True} +test1216 :: String +test1216 = name1216 man1216 + +data Happy1217 = Happy1217 {name1217 :: String, age1217 :: Int, happy1217 :: Bool} +man1217 :: Happy1217 +man1217 = Happy1217 {name1217 = "Happy", age1217 = 1, happy1217 = True} +test1217 :: String +test1217 = name1217 man1217 + +data Happy1218 = Happy1218 {name1218 :: String, age1218 :: Int, happy1218 :: Bool} +man1218 :: Happy1218 +man1218 = Happy1218 {name1218 = "Happy", age1218 = 1, happy1218 = True} +test1218 :: String +test1218 = name1218 man1218 + +data Happy1219 = Happy1219 {name1219 :: String, age1219 :: Int, happy1219 :: Bool} +man1219 :: Happy1219 +man1219 = Happy1219 {name1219 = "Happy", age1219 = 1, happy1219 = True} +test1219 :: String +test1219 = name1219 man1219 + +data Happy1220 = Happy1220 {name1220 :: String, age1220 :: Int, happy1220 :: Bool} +man1220 :: Happy1220 +man1220 = Happy1220 {name1220 = "Happy", age1220 = 1, happy1220 = True} +test1220 :: String +test1220 = name1220 man1220 + +data Happy1221 = Happy1221 {name1221 :: String, age1221 :: Int, happy1221 :: Bool} +man1221 :: Happy1221 +man1221 = Happy1221 {name1221 = "Happy", age1221 = 1, happy1221 = True} +test1221 :: String +test1221 = name1221 man1221 + +data Happy1222 = Happy1222 {name1222 :: String, age1222 :: Int, happy1222 :: Bool} +man1222 :: Happy1222 +man1222 = Happy1222 {name1222 = "Happy", age1222 = 1, happy1222 = True} +test1222 :: String +test1222 = name1222 man1222 + +data Happy1223 = Happy1223 {name1223 :: String, age1223 :: Int, happy1223 :: Bool} +man1223 :: Happy1223 +man1223 = Happy1223 {name1223 = "Happy", age1223 = 1, happy1223 = True} +test1223 :: String +test1223 = name1223 man1223 + +data Happy1224 = Happy1224 {name1224 :: String, age1224 :: Int, happy1224 :: Bool} +man1224 :: Happy1224 +man1224 = Happy1224 {name1224 = "Happy", age1224 = 1, happy1224 = True} +test1224 :: String +test1224 = name1224 man1224 + +data Happy1225 = Happy1225 {name1225 :: String, age1225 :: Int, happy1225 :: Bool} +man1225 :: Happy1225 +man1225 = Happy1225 {name1225 = "Happy", age1225 = 1, happy1225 = True} +test1225 :: String +test1225 = name1225 man1225 + +data Happy1226 = Happy1226 {name1226 :: String, age1226 :: Int, happy1226 :: Bool} +man1226 :: Happy1226 +man1226 = Happy1226 {name1226 = "Happy", age1226 = 1, happy1226 = True} +test1226 :: String +test1226 = name1226 man1226 + +data Happy1227 = Happy1227 {name1227 :: String, age1227 :: Int, happy1227 :: Bool} +man1227 :: Happy1227 +man1227 = Happy1227 {name1227 = "Happy", age1227 = 1, happy1227 = True} +test1227 :: String +test1227 = name1227 man1227 + +data Happy1228 = Happy1228 {name1228 :: String, age1228 :: Int, happy1228 :: Bool} +man1228 :: Happy1228 +man1228 = Happy1228 {name1228 = "Happy", age1228 = 1, happy1228 = True} +test1228 :: String +test1228 = name1228 man1228 + +data Happy1229 = Happy1229 {name1229 :: String, age1229 :: Int, happy1229 :: Bool} +man1229 :: Happy1229 +man1229 = Happy1229 {name1229 = "Happy", age1229 = 1, happy1229 = True} +test1229 :: String +test1229 = name1229 man1229 + +data Happy1230 = Happy1230 {name1230 :: String, age1230 :: Int, happy1230 :: Bool} +man1230 :: Happy1230 +man1230 = Happy1230 {name1230 = "Happy", age1230 = 1, happy1230 = True} +test1230 :: String +test1230 = name1230 man1230 + +data Happy1231 = Happy1231 {name1231 :: String, age1231 :: Int, happy1231 :: Bool} +man1231 :: Happy1231 +man1231 = Happy1231 {name1231 = "Happy", age1231 = 1, happy1231 = True} +test1231 :: String +test1231 = name1231 man1231 + +data Happy1232 = Happy1232 {name1232 :: String, age1232 :: Int, happy1232 :: Bool} +man1232 :: Happy1232 +man1232 = Happy1232 {name1232 = "Happy", age1232 = 1, happy1232 = True} +test1232 :: String +test1232 = name1232 man1232 + +data Happy1233 = Happy1233 {name1233 :: String, age1233 :: Int, happy1233 :: Bool} +man1233 :: Happy1233 +man1233 = Happy1233 {name1233 = "Happy", age1233 = 1, happy1233 = True} +test1233 :: String +test1233 = name1233 man1233 + +data Happy1234 = Happy1234 {name1234 :: String, age1234 :: Int, happy1234 :: Bool} +man1234 :: Happy1234 +man1234 = Happy1234 {name1234 = "Happy", age1234 = 1, happy1234 = True} +test1234 :: String +test1234 = name1234 man1234 + +data Happy1235 = Happy1235 {name1235 :: String, age1235 :: Int, happy1235 :: Bool} +man1235 :: Happy1235 +man1235 = Happy1235 {name1235 = "Happy", age1235 = 1, happy1235 = True} +test1235 :: String +test1235 = name1235 man1235 + +data Happy1236 = Happy1236 {name1236 :: String, age1236 :: Int, happy1236 :: Bool} +man1236 :: Happy1236 +man1236 = Happy1236 {name1236 = "Happy", age1236 = 1, happy1236 = True} +test1236 :: String +test1236 = name1236 man1236 + +data Happy1237 = Happy1237 {name1237 :: String, age1237 :: Int, happy1237 :: Bool} +man1237 :: Happy1237 +man1237 = Happy1237 {name1237 = "Happy", age1237 = 1, happy1237 = True} +test1237 :: String +test1237 = name1237 man1237 + +data Happy1238 = Happy1238 {name1238 :: String, age1238 :: Int, happy1238 :: Bool} +man1238 :: Happy1238 +man1238 = Happy1238 {name1238 = "Happy", age1238 = 1, happy1238 = True} +test1238 :: String +test1238 = name1238 man1238 + +data Happy1239 = Happy1239 {name1239 :: String, age1239 :: Int, happy1239 :: Bool} +man1239 :: Happy1239 +man1239 = Happy1239 {name1239 = "Happy", age1239 = 1, happy1239 = True} +test1239 :: String +test1239 = name1239 man1239 + +data Happy1240 = Happy1240 {name1240 :: String, age1240 :: Int, happy1240 :: Bool} +man1240 :: Happy1240 +man1240 = Happy1240 {name1240 = "Happy", age1240 = 1, happy1240 = True} +test1240 :: String +test1240 = name1240 man1240 + +data Happy1241 = Happy1241 {name1241 :: String, age1241 :: Int, happy1241 :: Bool} +man1241 :: Happy1241 +man1241 = Happy1241 {name1241 = "Happy", age1241 = 1, happy1241 = True} +test1241 :: String +test1241 = name1241 man1241 + +data Happy1242 = Happy1242 {name1242 :: String, age1242 :: Int, happy1242 :: Bool} +man1242 :: Happy1242 +man1242 = Happy1242 {name1242 = "Happy", age1242 = 1, happy1242 = True} +test1242 :: String +test1242 = name1242 man1242 + +data Happy1243 = Happy1243 {name1243 :: String, age1243 :: Int, happy1243 :: Bool} +man1243 :: Happy1243 +man1243 = Happy1243 {name1243 = "Happy", age1243 = 1, happy1243 = True} +test1243 :: String +test1243 = name1243 man1243 + +data Happy1244 = Happy1244 {name1244 :: String, age1244 :: Int, happy1244 :: Bool} +man1244 :: Happy1244 +man1244 = Happy1244 {name1244 = "Happy", age1244 = 1, happy1244 = True} +test1244 :: String +test1244 = name1244 man1244 + +data Happy1245 = Happy1245 {name1245 :: String, age1245 :: Int, happy1245 :: Bool} +man1245 :: Happy1245 +man1245 = Happy1245 {name1245 = "Happy", age1245 = 1, happy1245 = True} +test1245 :: String +test1245 = name1245 man1245 + +data Happy1246 = Happy1246 {name1246 :: String, age1246 :: Int, happy1246 :: Bool} +man1246 :: Happy1246 +man1246 = Happy1246 {name1246 = "Happy", age1246 = 1, happy1246 = True} +test1246 :: String +test1246 = name1246 man1246 + +data Happy1247 = Happy1247 {name1247 :: String, age1247 :: Int, happy1247 :: Bool} +man1247 :: Happy1247 +man1247 = Happy1247 {name1247 = "Happy", age1247 = 1, happy1247 = True} +test1247 :: String +test1247 = name1247 man1247 + +data Happy1248 = Happy1248 {name1248 :: String, age1248 :: Int, happy1248 :: Bool} +man1248 :: Happy1248 +man1248 = Happy1248 {name1248 = "Happy", age1248 = 1, happy1248 = True} +test1248 :: String +test1248 = name1248 man1248 + +data Happy1249 = Happy1249 {name1249 :: String, age1249 :: Int, happy1249 :: Bool} +man1249 :: Happy1249 +man1249 = Happy1249 {name1249 = "Happy", age1249 = 1, happy1249 = True} +test1249 :: String +test1249 = name1249 man1249 + +data Happy1250 = Happy1250 {name1250 :: String, age1250 :: Int, happy1250 :: Bool} +man1250 :: Happy1250 +man1250 = Happy1250 {name1250 = "Happy", age1250 = 1, happy1250 = True} +test1250 :: String +test1250 = name1250 man1250 + +data Happy1251 = Happy1251 {name1251 :: String, age1251 :: Int, happy1251 :: Bool} +man1251 :: Happy1251 +man1251 = Happy1251 {name1251 = "Happy", age1251 = 1, happy1251 = True} +test1251 :: String +test1251 = name1251 man1251 + +data Happy1252 = Happy1252 {name1252 :: String, age1252 :: Int, happy1252 :: Bool} +man1252 :: Happy1252 +man1252 = Happy1252 {name1252 = "Happy", age1252 = 1, happy1252 = True} +test1252 :: String +test1252 = name1252 man1252 + +data Happy1253 = Happy1253 {name1253 :: String, age1253 :: Int, happy1253 :: Bool} +man1253 :: Happy1253 +man1253 = Happy1253 {name1253 = "Happy", age1253 = 1, happy1253 = True} +test1253 :: String +test1253 = name1253 man1253 + +data Happy1254 = Happy1254 {name1254 :: String, age1254 :: Int, happy1254 :: Bool} +man1254 :: Happy1254 +man1254 = Happy1254 {name1254 = "Happy", age1254 = 1, happy1254 = True} +test1254 :: String +test1254 = name1254 man1254 + +data Happy1255 = Happy1255 {name1255 :: String, age1255 :: Int, happy1255 :: Bool} +man1255 :: Happy1255 +man1255 = Happy1255 {name1255 = "Happy", age1255 = 1, happy1255 = True} +test1255 :: String +test1255 = name1255 man1255 + +data Happy1256 = Happy1256 {name1256 :: String, age1256 :: Int, happy1256 :: Bool} +man1256 :: Happy1256 +man1256 = Happy1256 {name1256 = "Happy", age1256 = 1, happy1256 = True} +test1256 :: String +test1256 = name1256 man1256 + +data Happy1257 = Happy1257 {name1257 :: String, age1257 :: Int, happy1257 :: Bool} +man1257 :: Happy1257 +man1257 = Happy1257 {name1257 = "Happy", age1257 = 1, happy1257 = True} +test1257 :: String +test1257 = name1257 man1257 + +data Happy1258 = Happy1258 {name1258 :: String, age1258 :: Int, happy1258 :: Bool} +man1258 :: Happy1258 +man1258 = Happy1258 {name1258 = "Happy", age1258 = 1, happy1258 = True} +test1258 :: String +test1258 = name1258 man1258 + +data Happy1259 = Happy1259 {name1259 :: String, age1259 :: Int, happy1259 :: Bool} +man1259 :: Happy1259 +man1259 = Happy1259 {name1259 = "Happy", age1259 = 1, happy1259 = True} +test1259 :: String +test1259 = name1259 man1259 + +data Happy1260 = Happy1260 {name1260 :: String, age1260 :: Int, happy1260 :: Bool} +man1260 :: Happy1260 +man1260 = Happy1260 {name1260 = "Happy", age1260 = 1, happy1260 = True} +test1260 :: String +test1260 = name1260 man1260 + +data Happy1261 = Happy1261 {name1261 :: String, age1261 :: Int, happy1261 :: Bool} +man1261 :: Happy1261 +man1261 = Happy1261 {name1261 = "Happy", age1261 = 1, happy1261 = True} +test1261 :: String +test1261 = name1261 man1261 + +data Happy1262 = Happy1262 {name1262 :: String, age1262 :: Int, happy1262 :: Bool} +man1262 :: Happy1262 +man1262 = Happy1262 {name1262 = "Happy", age1262 = 1, happy1262 = True} +test1262 :: String +test1262 = name1262 man1262 + +data Happy1263 = Happy1263 {name1263 :: String, age1263 :: Int, happy1263 :: Bool} +man1263 :: Happy1263 +man1263 = Happy1263 {name1263 = "Happy", age1263 = 1, happy1263 = True} +test1263 :: String +test1263 = name1263 man1263 + +data Happy1264 = Happy1264 {name1264 :: String, age1264 :: Int, happy1264 :: Bool} +man1264 :: Happy1264 +man1264 = Happy1264 {name1264 = "Happy", age1264 = 1, happy1264 = True} +test1264 :: String +test1264 = name1264 man1264 + +data Happy1265 = Happy1265 {name1265 :: String, age1265 :: Int, happy1265 :: Bool} +man1265 :: Happy1265 +man1265 = Happy1265 {name1265 = "Happy", age1265 = 1, happy1265 = True} +test1265 :: String +test1265 = name1265 man1265 + +data Happy1266 = Happy1266 {name1266 :: String, age1266 :: Int, happy1266 :: Bool} +man1266 :: Happy1266 +man1266 = Happy1266 {name1266 = "Happy", age1266 = 1, happy1266 = True} +test1266 :: String +test1266 = name1266 man1266 + +data Happy1267 = Happy1267 {name1267 :: String, age1267 :: Int, happy1267 :: Bool} +man1267 :: Happy1267 +man1267 = Happy1267 {name1267 = "Happy", age1267 = 1, happy1267 = True} +test1267 :: String +test1267 = name1267 man1267 + +data Happy1268 = Happy1268 {name1268 :: String, age1268 :: Int, happy1268 :: Bool} +man1268 :: Happy1268 +man1268 = Happy1268 {name1268 = "Happy", age1268 = 1, happy1268 = True} +test1268 :: String +test1268 = name1268 man1268 + +data Happy1269 = Happy1269 {name1269 :: String, age1269 :: Int, happy1269 :: Bool} +man1269 :: Happy1269 +man1269 = Happy1269 {name1269 = "Happy", age1269 = 1, happy1269 = True} +test1269 :: String +test1269 = name1269 man1269 + +data Happy1270 = Happy1270 {name1270 :: String, age1270 :: Int, happy1270 :: Bool} +man1270 :: Happy1270 +man1270 = Happy1270 {name1270 = "Happy", age1270 = 1, happy1270 = True} +test1270 :: String +test1270 = name1270 man1270 + +data Happy1271 = Happy1271 {name1271 :: String, age1271 :: Int, happy1271 :: Bool} +man1271 :: Happy1271 +man1271 = Happy1271 {name1271 = "Happy", age1271 = 1, happy1271 = True} +test1271 :: String +test1271 = name1271 man1271 + +data Happy1272 = Happy1272 {name1272 :: String, age1272 :: Int, happy1272 :: Bool} +man1272 :: Happy1272 +man1272 = Happy1272 {name1272 = "Happy", age1272 = 1, happy1272 = True} +test1272 :: String +test1272 = name1272 man1272 + +data Happy1273 = Happy1273 {name1273 :: String, age1273 :: Int, happy1273 :: Bool} +man1273 :: Happy1273 +man1273 = Happy1273 {name1273 = "Happy", age1273 = 1, happy1273 = True} +test1273 :: String +test1273 = name1273 man1273 + +data Happy1274 = Happy1274 {name1274 :: String, age1274 :: Int, happy1274 :: Bool} +man1274 :: Happy1274 +man1274 = Happy1274 {name1274 = "Happy", age1274 = 1, happy1274 = True} +test1274 :: String +test1274 = name1274 man1274 + +data Happy1275 = Happy1275 {name1275 :: String, age1275 :: Int, happy1275 :: Bool} +man1275 :: Happy1275 +man1275 = Happy1275 {name1275 = "Happy", age1275 = 1, happy1275 = True} +test1275 :: String +test1275 = name1275 man1275 + +data Happy1276 = Happy1276 {name1276 :: String, age1276 :: Int, happy1276 :: Bool} +man1276 :: Happy1276 +man1276 = Happy1276 {name1276 = "Happy", age1276 = 1, happy1276 = True} +test1276 :: String +test1276 = name1276 man1276 + +data Happy1277 = Happy1277 {name1277 :: String, age1277 :: Int, happy1277 :: Bool} +man1277 :: Happy1277 +man1277 = Happy1277 {name1277 = "Happy", age1277 = 1, happy1277 = True} +test1277 :: String +test1277 = name1277 man1277 + +data Happy1278 = Happy1278 {name1278 :: String, age1278 :: Int, happy1278 :: Bool} +man1278 :: Happy1278 +man1278 = Happy1278 {name1278 = "Happy", age1278 = 1, happy1278 = True} +test1278 :: String +test1278 = name1278 man1278 + +data Happy1279 = Happy1279 {name1279 :: String, age1279 :: Int, happy1279 :: Bool} +man1279 :: Happy1279 +man1279 = Happy1279 {name1279 = "Happy", age1279 = 1, happy1279 = True} +test1279 :: String +test1279 = name1279 man1279 + +data Happy1280 = Happy1280 {name1280 :: String, age1280 :: Int, happy1280 :: Bool} +man1280 :: Happy1280 +man1280 = Happy1280 {name1280 = "Happy", age1280 = 1, happy1280 = True} +test1280 :: String +test1280 = name1280 man1280 + +data Happy1281 = Happy1281 {name1281 :: String, age1281 :: Int, happy1281 :: Bool} +man1281 :: Happy1281 +man1281 = Happy1281 {name1281 = "Happy", age1281 = 1, happy1281 = True} +test1281 :: String +test1281 = name1281 man1281 + +data Happy1282 = Happy1282 {name1282 :: String, age1282 :: Int, happy1282 :: Bool} +man1282 :: Happy1282 +man1282 = Happy1282 {name1282 = "Happy", age1282 = 1, happy1282 = True} +test1282 :: String +test1282 = name1282 man1282 + +data Happy1283 = Happy1283 {name1283 :: String, age1283 :: Int, happy1283 :: Bool} +man1283 :: Happy1283 +man1283 = Happy1283 {name1283 = "Happy", age1283 = 1, happy1283 = True} +test1283 :: String +test1283 = name1283 man1283 + +data Happy1284 = Happy1284 {name1284 :: String, age1284 :: Int, happy1284 :: Bool} +man1284 :: Happy1284 +man1284 = Happy1284 {name1284 = "Happy", age1284 = 1, happy1284 = True} +test1284 :: String +test1284 = name1284 man1284 + +data Happy1285 = Happy1285 {name1285 :: String, age1285 :: Int, happy1285 :: Bool} +man1285 :: Happy1285 +man1285 = Happy1285 {name1285 = "Happy", age1285 = 1, happy1285 = True} +test1285 :: String +test1285 = name1285 man1285 + +data Happy1286 = Happy1286 {name1286 :: String, age1286 :: Int, happy1286 :: Bool} +man1286 :: Happy1286 +man1286 = Happy1286 {name1286 = "Happy", age1286 = 1, happy1286 = True} +test1286 :: String +test1286 = name1286 man1286 + +data Happy1287 = Happy1287 {name1287 :: String, age1287 :: Int, happy1287 :: Bool} +man1287 :: Happy1287 +man1287 = Happy1287 {name1287 = "Happy", age1287 = 1, happy1287 = True} +test1287 :: String +test1287 = name1287 man1287 + +data Happy1288 = Happy1288 {name1288 :: String, age1288 :: Int, happy1288 :: Bool} +man1288 :: Happy1288 +man1288 = Happy1288 {name1288 = "Happy", age1288 = 1, happy1288 = True} +test1288 :: String +test1288 = name1288 man1288 + +data Happy1289 = Happy1289 {name1289 :: String, age1289 :: Int, happy1289 :: Bool} +man1289 :: Happy1289 +man1289 = Happy1289 {name1289 = "Happy", age1289 = 1, happy1289 = True} +test1289 :: String +test1289 = name1289 man1289 + +data Happy1290 = Happy1290 {name1290 :: String, age1290 :: Int, happy1290 :: Bool} +man1290 :: Happy1290 +man1290 = Happy1290 {name1290 = "Happy", age1290 = 1, happy1290 = True} +test1290 :: String +test1290 = name1290 man1290 + +data Happy1291 = Happy1291 {name1291 :: String, age1291 :: Int, happy1291 :: Bool} +man1291 :: Happy1291 +man1291 = Happy1291 {name1291 = "Happy", age1291 = 1, happy1291 = True} +test1291 :: String +test1291 = name1291 man1291 + +data Happy1292 = Happy1292 {name1292 :: String, age1292 :: Int, happy1292 :: Bool} +man1292 :: Happy1292 +man1292 = Happy1292 {name1292 = "Happy", age1292 = 1, happy1292 = True} +test1292 :: String +test1292 = name1292 man1292 + +data Happy1293 = Happy1293 {name1293 :: String, age1293 :: Int, happy1293 :: Bool} +man1293 :: Happy1293 +man1293 = Happy1293 {name1293 = "Happy", age1293 = 1, happy1293 = True} +test1293 :: String +test1293 = name1293 man1293 + +data Happy1294 = Happy1294 {name1294 :: String, age1294 :: Int, happy1294 :: Bool} +man1294 :: Happy1294 +man1294 = Happy1294 {name1294 = "Happy", age1294 = 1, happy1294 = True} +test1294 :: String +test1294 = name1294 man1294 + +data Happy1295 = Happy1295 {name1295 :: String, age1295 :: Int, happy1295 :: Bool} +man1295 :: Happy1295 +man1295 = Happy1295 {name1295 = "Happy", age1295 = 1, happy1295 = True} +test1295 :: String +test1295 = name1295 man1295 + +data Happy1296 = Happy1296 {name1296 :: String, age1296 :: Int, happy1296 :: Bool} +man1296 :: Happy1296 +man1296 = Happy1296 {name1296 = "Happy", age1296 = 1, happy1296 = True} +test1296 :: String +test1296 = name1296 man1296 + +data Happy1297 = Happy1297 {name1297 :: String, age1297 :: Int, happy1297 :: Bool} +man1297 :: Happy1297 +man1297 = Happy1297 {name1297 = "Happy", age1297 = 1, happy1297 = True} +test1297 :: String +test1297 = name1297 man1297 + +data Happy1298 = Happy1298 {name1298 :: String, age1298 :: Int, happy1298 :: Bool} +man1298 :: Happy1298 +man1298 = Happy1298 {name1298 = "Happy", age1298 = 1, happy1298 = True} +test1298 :: String +test1298 = name1298 man1298 + +data Happy1299 = Happy1299 {name1299 :: String, age1299 :: Int, happy1299 :: Bool} +man1299 :: Happy1299 +man1299 = Happy1299 {name1299 = "Happy", age1299 = 1, happy1299 = True} +test1299 :: String +test1299 = name1299 man1299 From c19480daea4babc1e4991801eb2b46fa3cc320df Mon Sep 17 00:00:00 2001 From: Nathan Maxson Date: Mon, 19 Jun 2023 16:40:23 +0300 Subject: [PATCH 05/18] Fix merge mistakes; move function to hls-test-utils --- hls-plugin-api/src/Ide/Types.hs | 20 ----------------- hls-test-utils/src/Test/Hls.hs | 22 +++++++++++++++++++ .../test/Main.hs | 21 ------------------ 3 files changed, 22 insertions(+), 41 deletions(-) diff --git a/hls-plugin-api/src/Ide/Types.hs b/hls-plugin-api/src/Ide/Types.hs index 460a890201..1a5b57ad5d 100644 --- a/hls-plugin-api/src/Ide/Types.hs +++ b/hls-plugin-api/src/Ide/Types.hs @@ -406,19 +406,6 @@ instance PluginMethod Request Method_TextDocumentCodeAction where instance PluginMethod Request Method_CodeActionResolve where pluginEnabled _ msgParams pluginDesc config = pluginEnabledConfig plcCodeActionsOn (configForPlugin config pluginDesc) - wasRequested :: (Command |? CodeAction) -> Bool - wasRequested (InL _) = True - wasRequested (InR ca) - | Nothing <- _only context = True - | Just allowed <- _only context - -- See https://github.com/microsoft/language-server-protocol/issues/970 - -- This is somewhat vague, but due to the hierarchical nature of action kinds, we - -- should check whether the requested kind is a *prefix* of the action kind. - -- That means, for example, we will return actions with kinds `quickfix.import` and - -- `quickfix.somethingElse` if the requested kind is `quickfix`. - , Just caKind <- ca ^. L.kind = any (\k -> k `codeActionKindSubsumes` caKind) allowed - | otherwise = False - instance PluginMethod Request Method_TextDocumentDefinition where pluginEnabled _ msgParams pluginDesc _ = pluginResponsible uri pluginDesc @@ -555,13 +542,6 @@ instance PluginRequestMethod Method_TextDocumentCodeAction where , Just caKind <- ca ^. L.kind = any (\k -> k `codeActionKindSubsumes` caKind) allowed | otherwise = False - -- Copied form lsp-types 1.6 to get compilation working. May make more - -- sense to add it back to lsp-types 2.0 - -- | Does the first 'CodeActionKind' subsume the other one, hierarchically. Reflexive. - codeActionKindSubsumes :: CodeActionKind -> CodeActionKind -> Bool - -- Simple but ugly implementation: prefix on the string representation - codeActionKindSubsumes parent child = toEnumBaseType parent `T.isPrefixOf` toEnumBaseType child - instance PluginRequestMethod Method_CodeActionResolve where -- TODO: Make a more serious combineResponses function combineResponses _ _ _ _ (x :| _) = x diff --git a/hls-test-utils/src/Test/Hls.hs b/hls-test-utils/src/Test/Hls.hs index 1864fdab49..97c0e03fe1 100644 --- a/hls-test-utils/src/Test/Hls.hs +++ b/hls-test-utils/src/Test/Hls.hs @@ -20,6 +20,7 @@ module Test.Hls defaultTestRunner, goldenGitDiff, goldenWithHaskellDoc, + goldenWithHaskellAndCaps, goldenWithCabalDoc, goldenWithHaskellDocFormatter, goldenWithCabalDocFormatter, @@ -143,6 +144,27 @@ goldenWithHaskellDoc -> TestTree goldenWithHaskellDoc = goldenWithDoc "haskell" +goldenWithHaskellAndCaps + :: Pretty b + => ClientCapabilities + -> PluginTestDescriptor b + -> TestName + -> FilePath + -> FilePath + -> FilePath + -> FilePath + -> (TextDocumentIdentifier -> Session ()) + -> TestTree +goldenWithHaskellAndCaps clientCaps plugin title testDataDir path desc ext act = + goldenGitDiff title (testDataDir path <.> desc <.> ext) + $ runSessionWithServerAndCaps plugin clientCaps testDataDir + $ TL.encodeUtf8 . TL.fromStrict + <$> do + doc <- openDoc (path <.> ext) "haskell" + void waitForBuildQueue + act doc + documentContents doc + goldenWithCabalDoc :: Pretty b => PluginTestDescriptor b diff --git a/plugins/hls-overloaded-record-dot-plugin/test/Main.hs b/plugins/hls-overloaded-record-dot-plugin/test/Main.hs index f943d0e7e4..d7dac49ade 100644 --- a/plugins/hls-overloaded-record-dot-plugin/test/Main.hs +++ b/plugins/hls-overloaded-record-dot-plugin/test/Main.hs @@ -105,24 +105,3 @@ isExplicitFieldsCodeAction selectorName CodeAction {_title} = testDataDir :: FilePath testDataDir = "test" "testdata" - -goldenWithHaskellAndCaps - :: Pretty b - => ClientCapabilities - -> PluginTestDescriptor b - -> TestName - -> FilePath - -> FilePath - -> FilePath - -> FilePath - -> (TextDocumentIdentifier -> Session ()) - -> TestTree -goldenWithHaskellAndCaps clientCaps plugin title testDataDir path desc ext act = - goldenGitDiff title (testDataDir path <.> desc <.> ext) - $ runSessionWithServerAndCaps plugin clientCaps testDataDir - $ TL.encodeUtf8 . TL.fromStrict - <$> do - doc <- openDoc (path <.> ext) "haskell" - void waitForBuildQueue - act doc - documentContents doc From 5e37f6ffa9e1499338cfc700d8ed8b1de1d9bce9 Mon Sep 17 00:00:00 2001 From: Nathan Maxson Date: Mon, 19 Jun 2023 17:15:01 +0300 Subject: [PATCH 06/18] Remove codeLens resolve Fix codeActionResolve combine responses --- hls-plugin-api/src/Ide/Types.hs | 13 +++---------- 1 file changed, 3 insertions(+), 10 deletions(-) diff --git a/hls-plugin-api/src/Ide/Types.hs b/hls-plugin-api/src/Ide/Types.hs index 1a5b57ad5d..7535256185 100644 --- a/hls-plugin-api/src/Ide/Types.hs +++ b/hls-plugin-api/src/Ide/Types.hs @@ -440,10 +440,6 @@ instance PluginMethod Request Method_TextDocumentCodeLens where where uri = msgParams ^. L.textDocument . L.uri -instance PluginMethod Request Method_CodeLensResolve where - pluginEnabled _ msgParams pluginDesc config = pluginEnabledConfig plcCodeLensOn (configForPlugin config pluginDesc) - - instance PluginMethod Request Method_TextDocumentRename where pluginEnabled _ msgParams pluginDesc config = pluginResponsible uri pluginDesc && pluginEnabledConfig plcRenameOn (configForPlugin config pluginDesc) @@ -543,8 +539,9 @@ instance PluginRequestMethod Method_TextDocumentCodeAction where | otherwise = False instance PluginRequestMethod Method_CodeActionResolve where - -- TODO: Make a more serious combineResponses function - combineResponses _ _ _ _ (x :| _) = x + -- CodeAction resolve is currently only used to changed the edit field, thus + -- that's the only field we are combining. + combineResponses _ _ _ codeAction (toList -> codeActions) = codeAction & L.edit .~ mconcat ((^. L.edit) <$> codeActions) instance PluginRequestMethod Method_TextDocumentDefinition where combineResponses _ _ _ _ (x :| _) = x @@ -563,10 +560,6 @@ instance PluginRequestMethod Method_WorkspaceSymbol where instance PluginRequestMethod Method_TextDocumentCodeLens where -instance PluginRequestMethod Method_CodeLensResolve where - -- TODO: Make a more serious combineResponses function - combineResponses _ _ _ _ (x :| _) = x - instance PluginRequestMethod Method_TextDocumentRename where instance PluginRequestMethod Method_TextDocumentHover where From 4bcd45bc39af8b366c9d044895efabfa5161aae7 Mon Sep 17 00:00:00 2001 From: Nathan Maxson Date: Wed, 21 Jun 2023 16:16:50 +0300 Subject: [PATCH 07/18] Don't use partial functions --- .../src/Ide/Plugin/OverloadedRecordDot.hs | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/plugins/hls-overloaded-record-dot-plugin/src/Ide/Plugin/OverloadedRecordDot.hs b/plugins/hls-overloaded-record-dot-plugin/src/Ide/Plugin/OverloadedRecordDot.hs index 440067ac17..ec82f1d122 100644 --- a/plugins/hls-overloaded-record-dot-plugin/src/Ide/Plugin/OverloadedRecordDot.hs +++ b/plugins/hls-overloaded-record-dot-plugin/src/Ide/Plugin/OverloadedRecordDot.hs @@ -261,10 +261,11 @@ collectRecSelsRule recorder = define (cmapWithPrio LogShake recorder) $ logWith recorder Debug (LogCollectedRecordSelectors recSels) let crsDetails = IntMap.fromList $ zip uniques recSels -- We need the rangeMap to be able to filter by range later - crsMap :: RangeMap Int - crsMap = RangeMap.fromList (location . (\x-> fromJust $ IntMap.lookup x crsDetails)) uniques + rangeAndUnique = mapM (\x -> (, x) . location <$> IntMap.lookup x crsDetails) uniques + crsMap :: Maybe (RangeMap Int) + crsMap = RangeMap.fromList' <$> rangeAndUnique crsDetails :: IntMap.IntMap RecordSelectorExpr - pure ([], CRSR <$> Just crsMap <*> Just crsDetails <*> Just exts) + pure ([], CRSR <$> crsMap <*> Just crsDetails <*> Just exts) where getEnabledExtensions :: TcModuleResult -> [Extension] getEnabledExtensions = getExtensions . tmrParsed getRecordSelectors :: TcModuleResult -> [RecordSelectorExpr] From 7d4f01eeabbcd10b7ea838a9c2a03e2923a5b6c5 Mon Sep 17 00:00:00 2001 From: Nathan Maxson Date: Thu, 22 Jun 2023 23:56:31 +0300 Subject: [PATCH 08/18] Implement michaelpj's suggestions --- hls-plugin-api/hls-plugin-api.cabal | 1 + hls-plugin-api/src/Ide/Types.hs | 71 +++++++++++- .../hls-overloaded-record-dot-plugin.cabal | 1 + .../src/Ide/Plugin/OverloadedRecordDot.hs | 106 ++++++++---------- .../test/Main.hs | 52 ++++----- 5 files changed, 137 insertions(+), 94 deletions(-) diff --git a/hls-plugin-api/hls-plugin-api.cabal b/hls-plugin-api/hls-plugin-api.cabal index 2762f335ff..64d1aa8263 100644 --- a/hls-plugin-api/hls-plugin-api.cabal +++ b/hls-plugin-api/hls-plugin-api.cabal @@ -62,6 +62,7 @@ library , opentelemetry >=0.4 , optparse-applicative , regex-tdfa >=1.3.1.0 + , row-types , text , transformers , unordered-containers diff --git a/hls-plugin-api/src/Ide/Types.hs b/hls-plugin-api/src/Ide/Types.hs index 7535256185..e38ca85e21 100644 --- a/hls-plugin-api/src/Ide/Types.hs +++ b/hls-plugin-api/src/Ide/Types.hs @@ -12,6 +12,7 @@ {-# LANGUAGE MonadComprehensions #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE NamedFieldPuns #-} +{-# LANGUAGE OverloadedLabels #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE PatternSynonyms #-} {-# LANGUAGE PolyKinds #-} @@ -47,6 +48,8 @@ module Ide.Types , installSigUsr1Handler , responseError , lookupCommandProvider +, OwnedResolveData(..) +, mkCodeActionHandlerWithResolve ) where @@ -59,7 +62,9 @@ import System.Posix.Signals #endif import Control.Applicative ((<|>)) import Control.Arrow ((&&&)) -import Control.Lens ((.~), (^.)) +import Control.Lens (_Just, (.~), (^.), (^?)) +import Control.Monad.Trans.Class (lift) +import Control.Monad.Trans.Except (ExceptT (..), runExceptT) import Data.Aeson hiding (Null, defaultOptions) import Data.Default import Data.Dependent.Map (DMap) @@ -74,6 +79,7 @@ import Data.List.NonEmpty (NonEmpty (..), toList) import qualified Data.Map as Map import Data.Maybe import Data.Ord +import Data.Row ((.!)) import Data.Semigroup import Data.String import qualified Data.Text as T @@ -85,7 +91,9 @@ import Ide.Plugin.Properties import qualified Language.LSP.Protocol.Lens as L import Language.LSP.Protocol.Message import Language.LSP.Protocol.Types -import Language.LSP.Server (LspM, getVirtualFile) +import Language.LSP.Server (LspM, LspT, + getClientCapabilities, + getVirtualFile) import Language.LSP.VFS import Numeric.Natural import OpenTelemetry.Eventlog @@ -404,7 +412,9 @@ instance PluginMethod Request Method_TextDocumentCodeAction where uri = msgParams ^. L.textDocument . L.uri instance PluginMethod Request Method_CodeActionResolve where - pluginEnabled _ msgParams pluginDesc config = pluginEnabledConfig plcCodeActionsOn (configForPlugin config pluginDesc) + pluginEnabled _ msgParams pluginDesc config = + pluginResolverResponsible (msgParams ^. L.data_) pluginDesc + && pluginEnabledConfig plcCodeActionsOn (configForPlugin config pluginDesc) instance PluginMethod Request Method_TextDocumentDefinition where pluginEnabled _ msgParams pluginDesc _ = @@ -856,7 +866,7 @@ type CommandFunction ideState a newtype PluginId = PluginId T.Text deriving (Show, Read, Eq, Ord) - deriving newtype (FromJSON, Hashable) + deriving newtype (ToJSON, FromJSON, Hashable) instance IsString PluginId where fromString = PluginId . T.pack @@ -957,7 +967,6 @@ instance HasTracing WorkspaceSymbolParams where instance HasTracing CallHierarchyIncomingCallsParams instance HasTracing CallHierarchyOutgoingCallsParams instance HasTracing CompletionItem -instance HasTracing CodeLens instance HasTracing CodeAction -- --------------------------------------------------------------------- @@ -992,3 +1001,55 @@ getProcessID = fromIntegral <$> P.getProcessID installSigUsr1Handler h = void $ installHandler sigUSR1 (Catch h) Nothing #endif + +-- |When provided with both a codeAction provider and an affiliated codeAction +-- resolve provider, this function creates a handler that automatically uses +-- your resolve provider to fill out you original codeAction if the client doesn't +-- have codeAction resolve support. This means you don't have to check whether +-- the client supports resolve and act accordingly in your own providers. +mkCodeActionHandlerWithResolve + :: (ideState -> PluginId -> CodeActionParams -> LspM Config (Either ResponseError ([Command |? CodeAction] |? Null))) + -> (ideState -> PluginId -> CodeAction -> LspM Config (Either ResponseError CodeAction)) + -> PluginHandlers ideState +mkCodeActionHandlerWithResolve codeActionMethod codeResolveMethod = + let newCodeActionMethod ideState pid params = runExceptT $ + do codeActionReturn <- ExceptT $ codeActionMethod ideState pid params + caps <- lift getClientCapabilities + case codeActionReturn of + r@(InR _) -> pure r + (InL ls) -> do + let mapper :: (Command |? CodeAction) -> ExceptT ResponseError (LspT Config IO) (Command |? CodeAction) + mapper c@(InL _) = pure c + mapper (InR codeAction) = fmap (InR . dropData) $ ExceptT $ codeResolveMethod ideState pid codeAction + if supportsResolve caps + then pure $ InL ls + else InL <$> traverse mapper ls --This is the actual part where we fill in the edit data for the client + in mkPluginHandler SMethod_TextDocumentCodeAction newCodeActionMethod + <> mkPluginHandler SMethod_CodeActionResolve codeResolveMethod + where supportsResolve :: ClientCapabilities -> Bool + supportsResolve caps = + caps ^? L.textDocument . _Just . L.codeAction . _Just . L.dataSupport . _Just == Just True + && case caps ^? L.textDocument . _Just . L.codeAction . _Just . L.resolveSupport . _Just of + Just row -> "edit" `elem` row .! #properties + _ -> False + dropData :: CodeAction -> CodeAction + dropData ca = ca & L.data_ .~ Nothing + +-- |Allow plugins to "own" resolve data, allowing only them to be queried for +-- the resolve action. This design has added flexibility at the cost of nested +-- Value types +data OwnedResolveData = ORD { + owner :: PluginId +, value :: Value +} deriving (Generic, Show) +instance ToJSON OwnedResolveData +instance FromJSON OwnedResolveData + +pluginResolverResponsible :: Maybe Value -> PluginDescriptor c -> Bool +pluginResolverResponsible (Just val) pluginDesc = + case fromJSON val of + (Success (ORD o _)) -> pluginId pluginDesc == o + _ -> True -- We want to fail open in case our resolver is not using the ORD type +-- This is a wierd case, because anything that gets resolved should have a data +-- field, but in any case, failing open is safe enough. +pluginResolverResponsible Nothing _ = True diff --git a/plugins/hls-overloaded-record-dot-plugin/hls-overloaded-record-dot-plugin.cabal b/plugins/hls-overloaded-record-dot-plugin/hls-overloaded-record-dot-plugin.cabal index 40789fedea..cc25318dc7 100644 --- a/plugins/hls-overloaded-record-dot-plugin/hls-overloaded-record-dot-plugin.cabal +++ b/plugins/hls-overloaded-record-dot-plugin/hls-overloaded-record-dot-plugin.cabal @@ -65,5 +65,6 @@ test-suite tests , lens , lsp-test , lsp-types + , row-types , hls-test-utils diff --git a/plugins/hls-overloaded-record-dot-plugin/src/Ide/Plugin/OverloadedRecordDot.hs b/plugins/hls-overloaded-record-dot-plugin/src/Ide/Plugin/OverloadedRecordDot.hs index ec82f1d122..28873b9a13 100644 --- a/plugins/hls-overloaded-record-dot-plugin/src/Ide/Plugin/OverloadedRecordDot.hs +++ b/plugins/hls-overloaded-record-dot-plugin/src/Ide/Plugin/OverloadedRecordDot.hs @@ -17,7 +17,7 @@ import Control.Lens (_Just, (^.), (^?)) import Control.Monad (replicateM) import Control.Monad.IO.Class (MonadIO, liftIO) import Control.Monad.Trans.Class (lift) -import Control.Monad.Trans.Except (ExceptT) +import Control.Monad.Trans.Except (ExceptT, throwE) import Data.Aeson (FromJSON, Result (..), ToJSON, fromJSON, toJSON) import Data.Generics (GenericQ, everything, @@ -79,10 +79,12 @@ import qualified Ide.Plugin.RangeMap as RangeMap import Ide.PluginUtils (getNormalizedFilePath, handleMaybeM, pluginResponse) -import Ide.Types (PluginDescriptor (..), +import Ide.Types (OwnedResolveData (..), + PluginDescriptor (..), PluginId (..), PluginMethodHandler, defaultPluginDescriptor, + mkCodeActionHandlerWithResolve, mkPluginHandler) import Language.LSP.Protocol.Lens (HasChanges (changes)) import qualified Language.LSP.Protocol.Lens as L @@ -93,7 +95,7 @@ import Language.LSP.Protocol.Types (CodeAction (..), CodeActionParams (..), Command, TextEdit (..), Uri (..), - WorkspaceEdit (WorkspaceEdit), + WorkspaceEdit (WorkspaceEdit, _changeAnnotations, _changes, _documentChanges), fromNormalizedUri, normalizedFilePathToUri, type (|?) (..)) @@ -116,7 +118,13 @@ instance Hashable CollectRecordSelectors instance NFData CollectRecordSelectors data CollectRecordSelectorsResult = CRSR - { records :: RangeMap Int + { -- |We store everything in here that we need to create the unresolved + -- codeAction, the range, an uniquely identifiable int, and the expression + -- for the selector expression that we use to generate the name + records :: RangeMap (Int, HsExpr (GhcPass 'Renamed)) + -- |This is for when we need to fully generate a textEdit. It contains the + -- whole expression we are interested in indexed to the unique id we got + -- from the previous field , recordInfos :: IntMap.IntMap RecordSelectorExpr , enabledExtensions :: [Extension] } @@ -147,8 +155,12 @@ instance Pretty RecordSelectorExpr where instance NFData RecordSelectorExpr where rnf = rwhnf +-- |The data that is serialized and placed in the data field of resolvable +-- code actions data ORDResolveData = ORDRD { + -- |We need the uri to get shake results uri :: Uri + -- |The unique id that allows us to find the specific codeAction we want , uniqueID :: Int } deriving (Generic, Show) instance ToJSON ORDResolveData @@ -158,89 +170,65 @@ descriptor :: Recorder (WithPriority Log) -> PluginId -> PluginDescriptor IdeState descriptor recorder plId = (defaultPluginDescriptor plId) { pluginHandlers = - mkPluginHandler SMethod_TextDocumentCodeAction codeActionProvider - <> mkPluginHandler SMethod_CodeActionResolve resolveProvider - + mkCodeActionHandlerWithResolve codeActionProvider resolveProvider , pluginRules = collectRecSelsRule recorder } resolveProvider :: PluginMethodHandler IdeState 'Method_CodeActionResolve resolveProvider ideState pId ca@(CodeAction _ _ _ _ _ _ _ (Just resData)) = pluginResponse $ do - case fromJSON $ resData of + case fromJSON resData >>= \x -> fromJSON $ value x of Success (ORDRD uri int) -> do nfp <- getNormalizedFilePath uri CRSR _ crsDetails exts <- collectRecSelResult ideState nfp pragma <- getFirstPragma pId ideState nfp - let pragmaEdit = - if OverloadedRecordDot `elem` exts - then Nothing - else Just $ insertNewPragma pragma OverloadedRecordDot - edits (Just crs) = convertRecordSelectors crs : maybeToList pragmaEdit - edits _ = [] - changes = Just $ WorkspaceEdit - (Just (Map.singleton (fromNormalizedUri - (normalizedFilePathToUri nfp)) - (edits (IntMap.lookup int crsDetails)))) - Nothing Nothing - pure $ ca {_edit = changes} - _ -> pure ca + pure $ ca {_edit = mkWorkspaceEdit uri int crsDetails exts pragma} + _ -> throwE "Unable to deserialize the data" codeActionProvider :: PluginMethodHandler IdeState 'Method_TextDocumentCodeAction codeActionProvider ideState pId (CodeActionParams _ _ caDocId caRange _) = pluginResponse $ do nfp <- getNormalizedFilePath (caDocId ^. L.uri) - pragma <- getFirstPragma pId ideState nfp - caps <- lift getClientCapabilities CRSR crsMap crsDetails exts <- collectRecSelResult ideState nfp - let supportsResolve :: Maybe Bool - supportsResolve = caps ^? L.textDocument . _Just . L.codeAction . _Just . L.dataSupport . _Just - pragmaEdit = - if OverloadedRecordDot `elem` exts - then Nothing - else Just $ insertNewPragma pragma OverloadedRecordDot - edits (Just crs) = convertRecordSelectors crs : maybeToList pragmaEdit - edits _ = [] - changes crsM crsD = - case supportsResolve of - Just False -> Just $ WorkspaceEdit - (Just (Map.singleton (fromNormalizedUri - (normalizedFilePathToUri nfp)) - (edits (IntMap.lookup crsM crsD)))) - Nothing Nothing - _ -> Nothing - resolveData crsM = - case supportsResolve of - Just True -> Just $ toJSON $ ORDRD (caDocId ^. L.uri) crsM - _ -> Nothing - mkCodeAction crsD crsM = InR CodeAction + let mkCodeAction (crsM, nse) = InR CodeAction { -- We pass the record selector to the title function, so that -- we can have the name of the record selector in the title of -- the codeAction. This allows the user can easily distinguish -- between the different codeActions when using nested record -- selectors, the disadvantage is we need to print out the -- name of the record selector which will decrease performance - _title = mkCodeActionTitle exts crsM crsD + _title = mkCodeActionTitle exts crsM nse , _kind = Just CodeActionKind_RefactorRewrite , _diagnostics = Nothing , _isPreferred = Nothing , _disabled = Nothing - , _edit = changes crsM crsD + , _edit = Nothing , _command = Nothing - , _data_ = resolveData crsM + , _data_ = Just $ toJSON $ ORD pId $ toJSON $ ORDRD (caDocId ^. L.uri) crsM } - actions = map (mkCodeAction crsDetails) (RangeMap.filterByRange caRange crsMap) + actions = map mkCodeAction (RangeMap.filterByRange caRange crsMap) pure $ InL actions where - mkCodeActionTitle :: [Extension] -> Int -> IntMap.IntMap RecordSelectorExpr-> Text - mkCodeActionTitle exts crsM crsD = + mkCodeActionTitle :: [Extension] -> Int -> HsExpr (GhcPass 'Renamed) -> Text + mkCodeActionTitle exts crsM se = if OverloadedRecordDot `elem` exts then title else title <> " (needs extension: OverloadedRecordDot)" where - title = "Convert `" <> name (IntMap.lookup crsM crsD) <> "` to record dot syntax" - name (Just (RecordSelectorExpr _ se _)) = printOutputable se - name _ = "" + title = "Convert `" <> printOutputable se <> "` to record dot syntax" + +mkWorkspaceEdit:: Uri -> Int -> IntMap.IntMap RecordSelectorExpr -> [Extension] -> NextPragmaInfo-> Maybe WorkspaceEdit +mkWorkspaceEdit uri crsM crsD exts pragma = + Just $ WorkspaceEdit + { _changes = Just (Map.singleton uri (edits (IntMap.lookup crsM crsD))) + , _documentChanges = Nothing + , _changeAnnotations = Nothing} + where pragmaEdit = + if OverloadedRecordDot `elem` exts + then Nothing + else Just $ insertNewPragma pragma OverloadedRecordDot + edits (Just crs) = convertRecordSelectors crs : maybeToList pragmaEdit + edits _ = [] collectRecSelsRule :: Recorder (WithPriority Log) -> Rules () collectRecSelsRule recorder = define (cmapWithPrio LogShake recorder) $ @@ -259,13 +247,12 @@ collectRecSelsRule recorder = define (cmapWithPrio LogShake recorder) $ recSels = mapMaybe (rewriteRange pm) (getRecordSelectors tmr) uniques <- liftIO $ replicateM (length recSels) (hashUnique <$> newUnique) logWith recorder Debug (LogCollectedRecordSelectors recSels) - let crsDetails = IntMap.fromList $ zip uniques recSels + let crsUniquesAndDetails = zip uniques recSels -- We need the rangeMap to be able to filter by range later - rangeAndUnique = mapM (\x -> (, x) . location <$> IntMap.lookup x crsDetails) uniques - crsMap :: Maybe (RangeMap Int) - crsMap = RangeMap.fromList' <$> rangeAndUnique - crsDetails :: IntMap.IntMap RecordSelectorExpr - pure ([], CRSR <$> crsMap <*> Just crsDetails <*> Just exts) + rangeAndUnique = toRangeAndUnique <$> crsUniquesAndDetails + crsMap :: RangeMap (Int, HsExpr (GhcPass 'Renamed)) + crsMap = RangeMap.fromList' rangeAndUnique + pure ([], CRSR <$> Just crsMap <*> Just (IntMap.fromList crsUniquesAndDetails) <*> Just exts) where getEnabledExtensions :: TcModuleResult -> [Extension] getEnabledExtensions = getExtensions . tmrParsed getRecordSelectors :: TcModuleResult -> [RecordSelectorExpr] @@ -277,6 +264,7 @@ collectRecSelsRule recorder = define (cmapWithPrio LogShake recorder) $ case toCurrentRange pm (location recSel) of Just newLoc -> Just $ recSel{location = newLoc} Nothing -> Nothing + toRangeAndUnique (id, RecordSelectorExpr l (unLoc -> se) _) = (l, (id, se)) convertRecordSelectors :: RecordSelectorExpr -> TextEdit convertRecordSelectors (RecordSelectorExpr l se re) = diff --git a/plugins/hls-overloaded-record-dot-plugin/test/Main.hs b/plugins/hls-overloaded-record-dot-plugin/test/Main.hs index d7dac49ade..94b0666eaf 100644 --- a/plugins/hls-overloaded-record-dot-plugin/test/Main.hs +++ b/plugins/hls-overloaded-record-dot-plugin/test/Main.hs @@ -1,5 +1,6 @@ {-# LANGUAGE DuplicateRecordFields #-} {-# LANGUAGE NamedFieldPuns #-} +{-# LANGUAGE OverloadedLabels #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TypeOperators #-} @@ -8,6 +9,8 @@ module Main ( main ) where import Control.Lens (_Just, set, (^.)) import Data.Either (rights) import Data.Functor (void) +import Data.Maybe (isNothing) +import Data.Row import qualified Data.Text as T import qualified Data.Text.Lazy as TL import qualified Data.Text.Lazy.Encoding as TL @@ -32,36 +35,23 @@ plugin = mkPluginTestDescriptor OverloadedRecordDot.descriptor "overloaded-recor test :: TestTree test = testGroup "overloaded-record-dot" - [testGroup - "without resolve" - [ mkTest "Simple" "Simple" "name" 10 7 10 15, - mkTest "NoPragmaNeeded" "NoPragmaNeeded" "name" 11 7 11 15, - mkTest "NestedParens" "NestedParens" "name" 15 7 15 24, - mkTest "NestedDot" "NestedDot" "name" 17 7 17 22, - mkTest "NestedDollar" "NestedDollar" "name" 15 7 15 24, - mkTest "MultilineCase" "MultilineCase" "name" 10 7 12 15, - mkTest "Multiline" "Multiline" "name" 10 7 11 15, - mkTest "MultilineExpanded" "MultilineExpanded" "owner" 28 8 28 19 - ], - testGroup - "with Resolve" - [ mkResolveTest "Simple" "Simple" "name" 10 7 10 15, - mkResolveTest "NoPragmaNeeded" "NoPragmaNeeded" "name" 11 7 11 15, - mkResolveTest "NestedParens" "NestedParens" "name" 15 7 15 24, - mkResolveTest "NestedDot" "NestedDot" "name" 17 7 17 22, - mkResolveTest "NestedDollar" "NestedDollar" "name" 15 7 15 24, - mkResolveTest "MultilineCase" "MultilineCase" "name" 10 7 12 15, - mkResolveTest "Multiline" "Multiline" "name" 10 7 11 15, - mkResolveTest "MultilineExpanded" "MultilineExpanded" "owner" 28 8 28 19 - ], - testGroup - "benchmark" - [ mkTest "Benchmark without resolve" "Benchmark" "name1298" 1797 11 1797 27, - mkResolveTest "Benchmark with resolve" "Benchmark" "name1298" 1797 11 1797 27 - ]] + (mkTest "Simple" "Simple" "name" 10 7 10 15 + <> mkTest "NoPragmaNeeded" "NoPragmaNeeded" "name" 11 7 11 15 + <> mkTest "NestedParens" "NestedParens" "name" 15 7 15 24 + <> mkTest "NestedDot" "NestedDot" "name" 17 7 17 22 + <> mkTest "NestedDollar" "NestedDollar" "name" 15 7 15 24 + <> mkTest "MultilineCase" "MultilineCase" "name" 10 7 12 15 + <> mkTest "Multiline" "Multiline" "name" 10 7 11 15 + <> mkTest "MultilineExpanded" "MultilineExpanded" "owner" 28 8 28 19 + <> mkTest "Benchmark" "Benchmark" "name1298" 1797 11 1797 27) -mkTest :: TestName -> FilePath -> T.Text -> UInt -> UInt -> UInt -> UInt -> TestTree +mkTest :: TestName -> FilePath -> T.Text -> UInt -> UInt -> UInt -> UInt -> [TestTree] mkTest title fp selectorName x1 y1 x2 y2 = + [mkNoResolveTest (title <> " without resolve") fp selectorName x1 y1 x2 y2, + mkResolveTest (title <> " with resolve") fp selectorName x1 y1 x2 y2] + +mkNoResolveTest :: TestName -> FilePath -> T.Text -> UInt -> UInt -> UInt -> UInt -> TestTree +mkNoResolveTest title fp selectorName x1 y1 x2 y2 = goldenWithHaskellAndCaps noResolveCaps plugin title testDataDir fp "expected" "hs" $ \doc -> do (act:_) <- getExplicitFieldsActions doc selectorName x1 y1 x2 y2 executeCodeAction act @@ -69,9 +59,11 @@ mkTest title fp selectorName x1 y1 x2 y2 = mkResolveTest :: TestName -> FilePath -> T.Text -> UInt -> UInt -> UInt -> UInt -> TestTree mkResolveTest title fp selectorName x1 y1 x2 y2 = - goldenWithHaskellDoc plugin title testDataDir fp "expected" "hs" $ \doc -> do + goldenWithHaskellAndCaps resolveCaps plugin title testDataDir fp "expected" "hs" $ \doc -> do ((Right act):_) <- getAndResolveExplicitFieldsActions doc selectorName x1 y1 x2 y2 executeCodeAction act + where resolveCaps = set (L.textDocument . _Just . L.codeAction . _Just . L.resolveSupport . _Just) (#properties .== ["edit"]) fullCaps + getExplicitFieldsActions :: TextDocumentIdentifier @@ -90,7 +82,7 @@ getAndResolveExplicitFieldsActions -> Session [Either ResponseError CodeAction] getAndResolveExplicitFieldsActions doc selectorName x1 y1 x2 y2 = do actions <- findExplicitFieldsAction selectorName <$> getCodeActions doc range - rsp <- mapM (request SMethod_CodeActionResolve) actions + rsp <- mapM (request SMethod_CodeActionResolve) (filter (\x -> isNothing (x ^. L.edit)) actions) pure $ (^. L.result) <$> rsp where From 225152efbe53178f608b57f89f8a41fe496af875 Mon Sep 17 00:00:00 2001 From: Nathan Maxson Date: Mon, 26 Jun 2023 19:34:42 +0300 Subject: [PATCH 09/18] Make owned resolve data transparent to the plugins --- hls-plugin-api/src/Ide/Types.hs | 44 +++++++++++++------ .../src/Ide/Plugin/OverloadedRecordDot.hs | 7 ++- 2 files changed, 33 insertions(+), 18 deletions(-) diff --git a/hls-plugin-api/src/Ide/Types.hs b/hls-plugin-api/src/Ide/Types.hs index e38ca85e21..f993544edc 100644 --- a/hls-plugin-api/src/Ide/Types.hs +++ b/hls-plugin-api/src/Ide/Types.hs @@ -62,7 +62,7 @@ import System.Posix.Signals #endif import Control.Applicative ((<|>)) import Control.Arrow ((&&&)) -import Control.Lens (_Just, (.~), (^.), (^?)) +import Control.Lens (_Just, (.~), (?~), (^.), (^?)) import Control.Monad.Trans.Class (lift) import Control.Monad.Trans.Except (ExceptT (..), runExceptT) import Data.Aeson hiding (Null, defaultOptions) @@ -1008,7 +1008,7 @@ installSigUsr1Handler h = void $ installHandler sigUSR1 (Catch h) Nothing -- have codeAction resolve support. This means you don't have to check whether -- the client supports resolve and act accordingly in your own providers. mkCodeActionHandlerWithResolve - :: (ideState -> PluginId -> CodeActionParams -> LspM Config (Either ResponseError ([Command |? CodeAction] |? Null))) + :: forall ideState. (ideState -> PluginId -> CodeActionParams -> LspM Config (Either ResponseError ([Command |? CodeAction] |? Null))) -> (ideState -> PluginId -> CodeAction -> LspM Config (Either ResponseError CodeAction)) -> PluginHandlers ideState mkCodeActionHandlerWithResolve codeActionMethod codeResolveMethod = @@ -1017,23 +1017,39 @@ mkCodeActionHandlerWithResolve codeActionMethod codeResolveMethod = caps <- lift getClientCapabilities case codeActionReturn of r@(InR _) -> pure r - (InL ls) -> do - let mapper :: (Command |? CodeAction) -> ExceptT ResponseError (LspT Config IO) (Command |? CodeAction) - mapper c@(InL _) = pure c - mapper (InR codeAction) = fmap (InR . dropData) $ ExceptT $ codeResolveMethod ideState pid codeAction - if supportsResolve caps - then pure $ InL ls - else InL <$> traverse mapper ls --This is the actual part where we fill in the edit data for the client + (InL ls) | -- If the client supports resolve, we will wrap the resolve data in a owned + -- resolve data type to allow the server to know who to send the resolve request to + supportsResolve caps -> pure $ InL (wrapResolveData pid <$> ls) + --This is the actual part where we call resolveCodeAction which fills in the edit data for the client + | otherwise -> InL <$> traverse (resolveCodeAction ideState pid) ls + newCodeResolveMethod ideState pid params = + codeResolveMethod ideState pid (unwrapResolveData params) in mkPluginHandler SMethod_TextDocumentCodeAction newCodeActionMethod - <> mkPluginHandler SMethod_CodeActionResolve codeResolveMethod - where supportsResolve :: ClientCapabilities -> Bool - supportsResolve caps = + <> mkPluginHandler SMethod_CodeActionResolve newCodeResolveMethod + where + supportsResolve :: ClientCapabilities -> Bool + supportsResolve caps = caps ^? L.textDocument . _Just . L.codeAction . _Just . L.dataSupport . _Just == Just True && case caps ^? L.textDocument . _Just . L.codeAction . _Just . L.resolveSupport . _Just of Just row -> "edit" `elem` row .! #properties _ -> False - dropData :: CodeAction -> CodeAction - dropData ca = ca & L.data_ .~ Nothing + dropData :: CodeAction -> CodeAction + dropData ca = ca & L.data_ .~ Nothing + resolveCodeAction :: ideState -> PluginId -> (Command |? CodeAction) -> ExceptT ResponseError (LspT Config IO) (Command |? CodeAction) + resolveCodeAction _ideState _pid c@(InL _) = pure c + resolveCodeAction ideState pid (InR codeAction) = + fmap (InR . dropData) $ ExceptT $ codeResolveMethod ideState pid codeAction + -- We don't wrap commands + wrapResolveData _pid c@(InL _) = c + wrapResolveData pid (InR c@(CodeAction{_data_=Just x})) = + InR $ c & L.data_ ?~ toJSON (ORD pid x) + -- Neither do we wrap code actions's without data fields, + wrapResolveData _pid c@(InR (CodeAction{_data_=Nothing})) = c + unwrapResolveData c@CodeAction{_data_ = Just x} + | Success ORD {value = v} <- fromJSON x = c & L.data_ ?~ v + -- If we can't successfully decode the value as a ORD type than + -- we just return the codeAction untouched. + unwrapResolveData c = c -- |Allow plugins to "own" resolve data, allowing only them to be queried for -- the resolve action. This design has added flexibility at the cost of nested diff --git a/plugins/hls-overloaded-record-dot-plugin/src/Ide/Plugin/OverloadedRecordDot.hs b/plugins/hls-overloaded-record-dot-plugin/src/Ide/Plugin/OverloadedRecordDot.hs index 28873b9a13..7629240398 100644 --- a/plugins/hls-overloaded-record-dot-plugin/src/Ide/Plugin/OverloadedRecordDot.hs +++ b/plugins/hls-overloaded-record-dot-plugin/src/Ide/Plugin/OverloadedRecordDot.hs @@ -79,8 +79,7 @@ import qualified Ide.Plugin.RangeMap as RangeMap import Ide.PluginUtils (getNormalizedFilePath, handleMaybeM, pluginResponse) -import Ide.Types (OwnedResolveData (..), - PluginDescriptor (..), +import Ide.Types (PluginDescriptor (..), PluginId (..), PluginMethodHandler, defaultPluginDescriptor, @@ -177,7 +176,7 @@ descriptor recorder plId = (defaultPluginDescriptor plId) resolveProvider :: PluginMethodHandler IdeState 'Method_CodeActionResolve resolveProvider ideState pId ca@(CodeAction _ _ _ _ _ _ _ (Just resData)) = pluginResponse $ do - case fromJSON resData >>= \x -> fromJSON $ value x of + case fromJSON resData of Success (ORDRD uri int) -> do nfp <- getNormalizedFilePath uri CRSR _ crsDetails exts <- collectRecSelResult ideState nfp @@ -204,7 +203,7 @@ codeActionProvider ideState pId (CodeActionParams _ _ caDocId caRange _) = , _disabled = Nothing , _edit = Nothing , _command = Nothing - , _data_ = Just $ toJSON $ ORD pId $ toJSON $ ORDRD (caDocId ^. L.uri) crsM + , _data_ = Just $ toJSON $ ORDRD (caDocId ^. L.uri) crsM } actions = map mkCodeAction (RangeMap.filterByRange caRange crsMap) pure $ InL actions From 4b3426587ea3e030e318802d22994afcd1560487 Mon Sep 17 00:00:00 2001 From: Nathan Maxson Date: Mon, 26 Jun 2023 19:51:59 +0300 Subject: [PATCH 10/18] Improve ord's resolve handler's error handling --- .../src/Ide/Plugin/OverloadedRecordDot.hs | 25 ++++++++++--------- 1 file changed, 13 insertions(+), 12 deletions(-) diff --git a/plugins/hls-overloaded-record-dot-plugin/src/Ide/Plugin/OverloadedRecordDot.hs b/plugins/hls-overloaded-record-dot-plugin/src/Ide/Plugin/OverloadedRecordDot.hs index 7629240398..8e574df868 100644 --- a/plugins/hls-overloaded-record-dot-plugin/src/Ide/Plugin/OverloadedRecordDot.hs +++ b/plugins/hls-overloaded-record-dot-plugin/src/Ide/Plugin/OverloadedRecordDot.hs @@ -176,13 +176,15 @@ descriptor recorder plId = (defaultPluginDescriptor plId) resolveProvider :: PluginMethodHandler IdeState 'Method_CodeActionResolve resolveProvider ideState pId ca@(CodeAction _ _ _ _ _ _ _ (Just resData)) = pluginResponse $ do - case fromJSON resData of - Success (ORDRD uri int) -> do - nfp <- getNormalizedFilePath uri - CRSR _ crsDetails exts <- collectRecSelResult ideState nfp - pragma <- getFirstPragma pId ideState nfp - pure $ ca {_edit = mkWorkspaceEdit uri int crsDetails exts pragma} - _ -> throwE "Unable to deserialize the data" + Success (ORDRD uri int) <- pure $ fromJSON resData + nfp <- getNormalizedFilePath uri + CRSR _ crsDetails exts <- collectRecSelResult ideState nfp + pragma <- getFirstPragma pId ideState nfp + case IntMap.lookup int crsDetails of + Just rse -> pure $ ca {_edit = mkWorkspaceEdit uri rse exts pragma} + -- We need to throw a content modified error here, but we need fendor's + -- plugin error response pr to make it convenient to use here. + _ -> throwE "Content Modified Error" codeActionProvider :: PluginMethodHandler IdeState 'Method_TextDocumentCodeAction codeActionProvider ideState pId (CodeActionParams _ _ caDocId caRange _) = @@ -216,18 +218,17 @@ codeActionProvider ideState pId (CodeActionParams _ _ caDocId caRange _) = where title = "Convert `" <> printOutputable se <> "` to record dot syntax" -mkWorkspaceEdit:: Uri -> Int -> IntMap.IntMap RecordSelectorExpr -> [Extension] -> NextPragmaInfo-> Maybe WorkspaceEdit -mkWorkspaceEdit uri crsM crsD exts pragma = +mkWorkspaceEdit:: Uri -> RecordSelectorExpr -> [Extension] -> NextPragmaInfo-> Maybe WorkspaceEdit +mkWorkspaceEdit uri recSel exts pragma = Just $ WorkspaceEdit - { _changes = Just (Map.singleton uri (edits (IntMap.lookup crsM crsD))) + { _changes = + Just (Map.singleton uri (convertRecordSelectors recSel : maybeToList pragmaEdit)) , _documentChanges = Nothing , _changeAnnotations = Nothing} where pragmaEdit = if OverloadedRecordDot `elem` exts then Nothing else Just $ insertNewPragma pragma OverloadedRecordDot - edits (Just crs) = convertRecordSelectors crs : maybeToList pragmaEdit - edits _ = [] collectRecSelsRule :: Recorder (WithPriority Log) -> Rules () collectRecSelsRule recorder = define (cmapWithPrio LogShake recorder) $ From 9985195987663e0e68a17151b33c24917cb950ef Mon Sep 17 00:00:00 2001 From: Nathan Maxson Date: Mon, 26 Jun 2023 20:11:33 +0300 Subject: [PATCH 11/18] Oh well, if only we had MonadFail --- .../src/Ide/Plugin/OverloadedRecordDot.hs | 20 ++++++++++--------- 1 file changed, 11 insertions(+), 9 deletions(-) diff --git a/plugins/hls-overloaded-record-dot-plugin/src/Ide/Plugin/OverloadedRecordDot.hs b/plugins/hls-overloaded-record-dot-plugin/src/Ide/Plugin/OverloadedRecordDot.hs index 8e574df868..75bf30558a 100644 --- a/plugins/hls-overloaded-record-dot-plugin/src/Ide/Plugin/OverloadedRecordDot.hs +++ b/plugins/hls-overloaded-record-dot-plugin/src/Ide/Plugin/OverloadedRecordDot.hs @@ -176,15 +176,17 @@ descriptor recorder plId = (defaultPluginDescriptor plId) resolveProvider :: PluginMethodHandler IdeState 'Method_CodeActionResolve resolveProvider ideState pId ca@(CodeAction _ _ _ _ _ _ _ (Just resData)) = pluginResponse $ do - Success (ORDRD uri int) <- pure $ fromJSON resData - nfp <- getNormalizedFilePath uri - CRSR _ crsDetails exts <- collectRecSelResult ideState nfp - pragma <- getFirstPragma pId ideState nfp - case IntMap.lookup int crsDetails of - Just rse -> pure $ ca {_edit = mkWorkspaceEdit uri rse exts pragma} - -- We need to throw a content modified error here, but we need fendor's - -- plugin error response pr to make it convenient to use here. - _ -> throwE "Content Modified Error" + case fromJSON resData of + Success (ORDRD uri int) -> do + nfp <- getNormalizedFilePath uri + CRSR _ crsDetails exts <- collectRecSelResult ideState nfp + pragma <- getFirstPragma pId ideState nfp + case IntMap.lookup int crsDetails of + Just rse -> pure $ ca {_edit = mkWorkspaceEdit uri rse exts pragma} + -- We need to throw a content modified error here, but we need fendor's + -- plugin error response pr to make it convenient to use here. + _ -> throwE "Content Modified Error" + _ -> throwE "Unable to deserialize the data" codeActionProvider :: PluginMethodHandler IdeState 'Method_TextDocumentCodeAction codeActionProvider ideState pId (CodeActionParams _ _ caDocId caRange _) = From 355e95c7ab58a097ca152be22245ca4e9180b3d6 Mon Sep 17 00:00:00 2001 From: Nathan Maxson Date: Tue, 27 Jun 2023 17:10:07 +0300 Subject: [PATCH 12/18] Generic support for resolve in hls packages --- hls-plugin-api/hls-plugin-api.cabal | 1 + hls-plugin-api/src/Ide/Types.hs | 146 ++++++++++++++++++++++------ hls-test-utils/src/Test/Hls.hs | 22 +++++ 3 files changed, 139 insertions(+), 30 deletions(-) diff --git a/hls-plugin-api/hls-plugin-api.cabal b/hls-plugin-api/hls-plugin-api.cabal index 2762f335ff..64d1aa8263 100644 --- a/hls-plugin-api/hls-plugin-api.cabal +++ b/hls-plugin-api/hls-plugin-api.cabal @@ -62,6 +62,7 @@ library , opentelemetry >=0.4 , optparse-applicative , regex-tdfa >=1.3.1.0 + , row-types , text , transformers , unordered-containers diff --git a/hls-plugin-api/src/Ide/Types.hs b/hls-plugin-api/src/Ide/Types.hs index c32b7173d0..f993544edc 100644 --- a/hls-plugin-api/src/Ide/Types.hs +++ b/hls-plugin-api/src/Ide/Types.hs @@ -12,6 +12,7 @@ {-# LANGUAGE MonadComprehensions #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE NamedFieldPuns #-} +{-# LANGUAGE OverloadedLabels #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE PatternSynonyms #-} {-# LANGUAGE PolyKinds #-} @@ -47,6 +48,8 @@ module Ide.Types , installSigUsr1Handler , responseError , lookupCommandProvider +, OwnedResolveData(..) +, mkCodeActionHandlerWithResolve ) where @@ -59,7 +62,9 @@ import System.Posix.Signals #endif import Control.Applicative ((<|>)) import Control.Arrow ((&&&)) -import Control.Lens ((.~), (^.)) +import Control.Lens (_Just, (.~), (?~), (^.), (^?)) +import Control.Monad.Trans.Class (lift) +import Control.Monad.Trans.Except (ExceptT (..), runExceptT) import Data.Aeson hiding (Null, defaultOptions) import Data.Default import Data.Dependent.Map (DMap) @@ -74,6 +79,7 @@ import Data.List.NonEmpty (NonEmpty (..), toList) import qualified Data.Map as Map import Data.Maybe import Data.Ord +import Data.Row ((.!)) import Data.Semigroup import Data.String import qualified Data.Text as T @@ -85,7 +91,9 @@ import Ide.Plugin.Properties import qualified Language.LSP.Protocol.Lens as L import Language.LSP.Protocol.Message import Language.LSP.Protocol.Types -import Language.LSP.Server (LspM, getVirtualFile) +import Language.LSP.Server (LspM, LspT, + getClientCapabilities, + getVirtualFile) import Language.LSP.VFS import Numeric.Natural import OpenTelemetry.Eventlog @@ -403,32 +411,10 @@ instance PluginMethod Request Method_TextDocumentCodeAction where where uri = msgParams ^. L.textDocument . L.uri -instance PluginRequestMethod Method_TextDocumentCodeAction where - combineResponses _method _config (ClientCapabilities _ textDocCaps _ _ _ _) (CodeActionParams _ _ _ _ context) resps = - InL $ fmap compat $ filter wasRequested $ concat $ mapMaybe nullToMaybe $ toList resps - where - compat :: (Command |? CodeAction) -> (Command |? CodeAction) - compat x@(InL _) = x - compat x@(InR action) - | Just _ <- textDocCaps >>= _codeAction >>= _codeActionLiteralSupport - = x - | otherwise = InL cmd - where - cmd = mkLspCommand "hls" "fallbackCodeAction" (action ^. L.title) (Just cmdParams) - cmdParams = [toJSON (FallbackCodeActionParams (action ^. L.edit) (action ^. L.command))] - - wasRequested :: (Command |? CodeAction) -> Bool - wasRequested (InL _) = True - wasRequested (InR ca) - | Nothing <- _only context = True - | Just allowed <- _only context - -- See https://github.com/microsoft/language-server-protocol/issues/970 - -- This is somewhat vague, but due to the hierarchical nature of action kinds, we - -- should check whether the requested kind is a *prefix* of the action kind. - -- That means, for example, we will return actions with kinds `quickfix.import` and - -- `quickfix.somethingElse` if the requested kind is `quickfix`. - , Just caKind <- ca ^. L.kind = any (\k -> k `codeActionKindSubsumes` caKind) allowed - | otherwise = False +instance PluginMethod Request Method_CodeActionResolve where + pluginEnabled _ msgParams pluginDesc config = + pluginResolverResponsible (msgParams ^. L.data_) pluginDesc + && pluginEnabledConfig plcCodeActionsOn (configForPlugin config pluginDesc) instance PluginMethod Request Method_TextDocumentDefinition where pluginEnabled _ msgParams pluginDesc _ = @@ -535,6 +521,38 @@ instance PluginMethod Request (Method_CustomMethod m) where pluginEnabled _ _ _ _ = True --- +instance PluginRequestMethod Method_TextDocumentCodeAction where + combineResponses _method _config (ClientCapabilities _ textDocCaps _ _ _ _) (CodeActionParams _ _ _ _ context) resps = + InL $ fmap compat $ filter wasRequested $ concat $ mapMaybe nullToMaybe $ toList resps + where + compat :: (Command |? CodeAction) -> (Command |? CodeAction) + compat x@(InL _) = x + compat x@(InR action) + | Just _ <- textDocCaps >>= _codeAction >>= _codeActionLiteralSupport + = x + | otherwise = InL cmd + where + cmd = mkLspCommand "hls" "fallbackCodeAction" (action ^. L.title) (Just cmdParams) + cmdParams = [toJSON (FallbackCodeActionParams (action ^. L.edit) (action ^. L.command))] + + wasRequested :: (Command |? CodeAction) -> Bool + wasRequested (InL _) = True + wasRequested (InR ca) + | Nothing <- _only context = True + | Just allowed <- _only context + -- See https://github.com/microsoft/language-server-protocol/issues/970 + -- This is somewhat vague, but due to the hierarchical nature of action kinds, we + -- should check whether the requested kind is a *prefix* of the action kind. + -- That means, for example, we will return actions with kinds `quickfix.import` and + -- `quickfix.somethingElse` if the requested kind is `quickfix`. + , Just caKind <- ca ^. L.kind = any (\k -> k `codeActionKindSubsumes` caKind) allowed + | otherwise = False + +instance PluginRequestMethod Method_CodeActionResolve where + -- CodeAction resolve is currently only used to changed the edit field, thus + -- that's the only field we are combining. + combineResponses _ _ _ codeAction (toList -> codeActions) = codeAction & L.edit .~ mconcat ((^. L.edit) <$> codeActions) + instance PluginRequestMethod Method_TextDocumentDefinition where combineResponses _ _ _ _ (x :| _) = x @@ -848,7 +866,7 @@ type CommandFunction ideState a newtype PluginId = PluginId T.Text deriving (Show, Read, Eq, Ord) - deriving newtype (FromJSON, Hashable) + deriving newtype (ToJSON, FromJSON, Hashable) instance IsString PluginId where fromString = PluginId . T.pack @@ -949,7 +967,7 @@ instance HasTracing WorkspaceSymbolParams where instance HasTracing CallHierarchyIncomingCallsParams instance HasTracing CallHierarchyOutgoingCallsParams instance HasTracing CompletionItem - +instance HasTracing CodeAction -- --------------------------------------------------------------------- {-# NOINLINE pROCESS_ID #-} @@ -983,3 +1001,71 @@ getProcessID = fromIntegral <$> P.getProcessID installSigUsr1Handler h = void $ installHandler sigUSR1 (Catch h) Nothing #endif + +-- |When provided with both a codeAction provider and an affiliated codeAction +-- resolve provider, this function creates a handler that automatically uses +-- your resolve provider to fill out you original codeAction if the client doesn't +-- have codeAction resolve support. This means you don't have to check whether +-- the client supports resolve and act accordingly in your own providers. +mkCodeActionHandlerWithResolve + :: forall ideState. (ideState -> PluginId -> CodeActionParams -> LspM Config (Either ResponseError ([Command |? CodeAction] |? Null))) + -> (ideState -> PluginId -> CodeAction -> LspM Config (Either ResponseError CodeAction)) + -> PluginHandlers ideState +mkCodeActionHandlerWithResolve codeActionMethod codeResolveMethod = + let newCodeActionMethod ideState pid params = runExceptT $ + do codeActionReturn <- ExceptT $ codeActionMethod ideState pid params + caps <- lift getClientCapabilities + case codeActionReturn of + r@(InR _) -> pure r + (InL ls) | -- If the client supports resolve, we will wrap the resolve data in a owned + -- resolve data type to allow the server to know who to send the resolve request to + supportsResolve caps -> pure $ InL (wrapResolveData pid <$> ls) + --This is the actual part where we call resolveCodeAction which fills in the edit data for the client + | otherwise -> InL <$> traverse (resolveCodeAction ideState pid) ls + newCodeResolveMethod ideState pid params = + codeResolveMethod ideState pid (unwrapResolveData params) + in mkPluginHandler SMethod_TextDocumentCodeAction newCodeActionMethod + <> mkPluginHandler SMethod_CodeActionResolve newCodeResolveMethod + where + supportsResolve :: ClientCapabilities -> Bool + supportsResolve caps = + caps ^? L.textDocument . _Just . L.codeAction . _Just . L.dataSupport . _Just == Just True + && case caps ^? L.textDocument . _Just . L.codeAction . _Just . L.resolveSupport . _Just of + Just row -> "edit" `elem` row .! #properties + _ -> False + dropData :: CodeAction -> CodeAction + dropData ca = ca & L.data_ .~ Nothing + resolveCodeAction :: ideState -> PluginId -> (Command |? CodeAction) -> ExceptT ResponseError (LspT Config IO) (Command |? CodeAction) + resolveCodeAction _ideState _pid c@(InL _) = pure c + resolveCodeAction ideState pid (InR codeAction) = + fmap (InR . dropData) $ ExceptT $ codeResolveMethod ideState pid codeAction + -- We don't wrap commands + wrapResolveData _pid c@(InL _) = c + wrapResolveData pid (InR c@(CodeAction{_data_=Just x})) = + InR $ c & L.data_ ?~ toJSON (ORD pid x) + -- Neither do we wrap code actions's without data fields, + wrapResolveData _pid c@(InR (CodeAction{_data_=Nothing})) = c + unwrapResolveData c@CodeAction{_data_ = Just x} + | Success ORD {value = v} <- fromJSON x = c & L.data_ ?~ v + -- If we can't successfully decode the value as a ORD type than + -- we just return the codeAction untouched. + unwrapResolveData c = c + +-- |Allow plugins to "own" resolve data, allowing only them to be queried for +-- the resolve action. This design has added flexibility at the cost of nested +-- Value types +data OwnedResolveData = ORD { + owner :: PluginId +, value :: Value +} deriving (Generic, Show) +instance ToJSON OwnedResolveData +instance FromJSON OwnedResolveData + +pluginResolverResponsible :: Maybe Value -> PluginDescriptor c -> Bool +pluginResolverResponsible (Just val) pluginDesc = + case fromJSON val of + (Success (ORD o _)) -> pluginId pluginDesc == o + _ -> True -- We want to fail open in case our resolver is not using the ORD type +-- This is a wierd case, because anything that gets resolved should have a data +-- field, but in any case, failing open is safe enough. +pluginResolverResponsible Nothing _ = True diff --git a/hls-test-utils/src/Test/Hls.hs b/hls-test-utils/src/Test/Hls.hs index 1864fdab49..97c0e03fe1 100644 --- a/hls-test-utils/src/Test/Hls.hs +++ b/hls-test-utils/src/Test/Hls.hs @@ -20,6 +20,7 @@ module Test.Hls defaultTestRunner, goldenGitDiff, goldenWithHaskellDoc, + goldenWithHaskellAndCaps, goldenWithCabalDoc, goldenWithHaskellDocFormatter, goldenWithCabalDocFormatter, @@ -143,6 +144,27 @@ goldenWithHaskellDoc -> TestTree goldenWithHaskellDoc = goldenWithDoc "haskell" +goldenWithHaskellAndCaps + :: Pretty b + => ClientCapabilities + -> PluginTestDescriptor b + -> TestName + -> FilePath + -> FilePath + -> FilePath + -> FilePath + -> (TextDocumentIdentifier -> Session ()) + -> TestTree +goldenWithHaskellAndCaps clientCaps plugin title testDataDir path desc ext act = + goldenGitDiff title (testDataDir path <.> desc <.> ext) + $ runSessionWithServerAndCaps plugin clientCaps testDataDir + $ TL.encodeUtf8 . TL.fromStrict + <$> do + doc <- openDoc (path <.> ext) "haskell" + void waitForBuildQueue + act doc + documentContents doc + goldenWithCabalDoc :: Pretty b => PluginTestDescriptor b From fb49c3131cb98d16465b2aad6691453639fa3319 Mon Sep 17 00:00:00 2001 From: Nathan Maxson Date: Tue, 27 Jun 2023 17:18:28 +0300 Subject: [PATCH 13/18] Add a new code action resolve helper that falls backs to commands --- hls-plugin-api/src/Ide/Types.hs | 77 ++++++++++++++++++++++++--------- 1 file changed, 57 insertions(+), 20 deletions(-) diff --git a/hls-plugin-api/src/Ide/Types.hs b/hls-plugin-api/src/Ide/Types.hs index f993544edc..04025b16ec 100644 --- a/hls-plugin-api/src/Ide/Types.hs +++ b/hls-plugin-api/src/Ide/Types.hs @@ -50,6 +50,7 @@ module Ide.Types , lookupCommandProvider , OwnedResolveData(..) , mkCodeActionHandlerWithResolve +, mkCodeActionWithResolveAndCommand ) where @@ -1016,40 +1017,76 @@ mkCodeActionHandlerWithResolve codeActionMethod codeResolveMethod = do codeActionReturn <- ExceptT $ codeActionMethod ideState pid params caps <- lift getClientCapabilities case codeActionReturn of - r@(InR _) -> pure r + r@(InR Null) -> pure r (InL ls) | -- If the client supports resolve, we will wrap the resolve data in a owned -- resolve data type to allow the server to know who to send the resolve request to - supportsResolve caps -> pure $ InL (wrapResolveData pid <$> ls) + supportsCodeActionResolve caps -> pure $ InL (wrapCodeActionResolveData pid <$> ls) --This is the actual part where we call resolveCodeAction which fills in the edit data for the client | otherwise -> InL <$> traverse (resolveCodeAction ideState pid) ls newCodeResolveMethod ideState pid params = - codeResolveMethod ideState pid (unwrapResolveData params) + codeResolveMethod ideState pid (unwrapCodeActionResolveData params) in mkPluginHandler SMethod_TextDocumentCodeAction newCodeActionMethod <> mkPluginHandler SMethod_CodeActionResolve newCodeResolveMethod where - supportsResolve :: ClientCapabilities -> Bool - supportsResolve caps = - caps ^? L.textDocument . _Just . L.codeAction . _Just . L.dataSupport . _Just == Just True - && case caps ^? L.textDocument . _Just . L.codeAction . _Just . L.resolveSupport . _Just of - Just row -> "edit" `elem` row .! #properties - _ -> False dropData :: CodeAction -> CodeAction dropData ca = ca & L.data_ .~ Nothing resolveCodeAction :: ideState -> PluginId -> (Command |? CodeAction) -> ExceptT ResponseError (LspT Config IO) (Command |? CodeAction) resolveCodeAction _ideState _pid c@(InL _) = pure c resolveCodeAction ideState pid (InR codeAction) = fmap (InR . dropData) $ ExceptT $ codeResolveMethod ideState pid codeAction - -- We don't wrap commands - wrapResolveData _pid c@(InL _) = c - wrapResolveData pid (InR c@(CodeAction{_data_=Just x})) = - InR $ c & L.data_ ?~ toJSON (ORD pid x) - -- Neither do we wrap code actions's without data fields, - wrapResolveData _pid c@(InR (CodeAction{_data_=Nothing})) = c - unwrapResolveData c@CodeAction{_data_ = Just x} - | Success ORD {value = v} <- fromJSON x = c & L.data_ ?~ v - -- If we can't successfully decode the value as a ORD type than - -- we just return the codeAction untouched. - unwrapResolveData c = c + +-- |When provided with both a codeAction provider that includes both a command +-- and a data field and a resolve provider, this function creates a handler that +-- defaults to using your command if the client doesn't have code action resolve +-- support. This means you don't have to check whether the client supports resolve +-- and act accordingly in your own providers. +mkCodeActionWithResolveAndCommand + :: forall ideState. (ideState -> PluginId -> CodeActionParams -> LspM Config (Either ResponseError ([Command |? CodeAction] |? Null))) + -> (ideState -> PluginId -> CodeAction -> LspM Config (Either ResponseError CodeAction)) + -> PluginHandlers ideState +mkCodeActionWithResolveAndCommand codeActionMethod codeResolveMethod = + let newCodeActionMethod ideState pid params = runExceptT $ + do codeActionReturn <- ExceptT $ codeActionMethod ideState pid params + caps <- lift getClientCapabilities + case codeActionReturn of + r@(InR Null) -> pure r + (InL ls) | -- If the client supports resolve, we will wrap the resolve data in a owned + -- resolve data type to allow the server to know who to send the resolve request to + -- and dump the command fields. + supportsCodeActionResolve caps -> + pure $ InL (dropCommands . wrapCodeActionResolveData pid <$> ls) + -- If they do not we will drop the data field. + | otherwise -> pure $ InL $ dropData <$> ls + newCodeResolveMethod ideState pid params = + codeResolveMethod ideState pid (unwrapCodeActionResolveData params) + in mkPluginHandler SMethod_TextDocumentCodeAction newCodeActionMethod + <> mkPluginHandler SMethod_CodeActionResolve newCodeResolveMethod + where dropData :: Command |? CodeAction -> Command |? CodeAction + dropData ca = ca & _R . L.data_ .~ Nothing + dropCommands :: Command |? CodeAction -> Command |? CodeAction + dropCommands ca = ca & _R . L.command .~ Nothing + +supportsCodeActionResolve :: ClientCapabilities -> Bool +supportsCodeActionResolve caps = + caps ^? L.textDocument . _Just . L.codeAction . _Just . L.dataSupport . _Just == Just True + && case caps ^? L.textDocument . _Just . L.codeAction . _Just . L.resolveSupport . _Just of + Just row -> "edit" `elem` row .! #properties + _ -> False + +-- We don't wrap commands +wrapCodeActionResolveData :: PluginId -> (a |? CodeAction) -> a |? CodeAction +wrapCodeActionResolveData _pid c@(InL _) = c +wrapCodeActionResolveData pid (InR c@(CodeAction{_data_=Just x})) = + InR $ c & L.data_ ?~ toJSON (ORD pid x) +-- Neither do we wrap code actions's without data fields, +wrapCodeActionResolveData _pid c@(InR (CodeAction{_data_=Nothing})) = c + +unwrapCodeActionResolveData :: CodeAction -> CodeAction +unwrapCodeActionResolveData c@CodeAction{_data_ = Just x} + | Success ORD {value = v} <- fromJSON x = c & L.data_ ?~ v +-- If we can't successfully decode the value as a ORD type than +-- we just return the codeAction untouched. +unwrapCodeActionResolveData c = c -- |Allow plugins to "own" resolve data, allowing only them to be queried for -- the resolve action. This design has added flexibility at the cost of nested From d1d299b3a10805274f920a8ffa3410e5e109097d Mon Sep 17 00:00:00 2001 From: Nathan Maxson Date: Wed, 28 Jun 2023 17:17:37 +0300 Subject: [PATCH 14/18] add resolve capability set to hls-test-utils --- hls-test-utils/src/Test/Hls/Util.hs | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/hls-test-utils/src/Test/Hls/Util.hs b/hls-test-utils/src/Test/Hls/Util.hs index d361b0a8ec..a3e2146743 100644 --- a/hls-test-utils/src/Test/Hls/Util.hs +++ b/hls-test-utils/src/Test/Hls/Util.hs @@ -10,7 +10,9 @@ {-# LANGUAGE DataKinds #-} module Test.Hls.Util ( -- * Test Capabilities - codeActionSupportCaps + codeActionResolveCaps + , codeActionNoResolveCaps + , codeActionSupportCaps , expectCodeAction -- * Environment specifications -- for ignoring tests @@ -51,7 +53,7 @@ where import Control.Applicative.Combinators (skipManyTill, (<|>)) import Control.Exception (catch, throwIO) -import Control.Lens ((&), (?~), (^.)) +import Control.Lens ((&), (?~), (^.), _Just, (.~)) import Control.Monad import Control.Monad.IO.Class import qualified Data.Aeson as A @@ -92,6 +94,15 @@ codeActionSupportCaps = def & L.textDocument ?~ textDocumentCaps codeActionCaps = CodeActionClientCapabilities (Just True) (Just literalSupport) (Just True) Nothing Nothing Nothing Nothing literalSupport = #codeActionKind .== (#valueSet .== []) +codeActionResolveCaps :: ClientCapabilities +codeActionResolveCaps = Test.fullCaps + & (L.textDocument . _Just . L.codeAction . _Just . L.resolveSupport . _Just) .~ (#properties .== ["edit"]) + & (L.textDocument . _Just . L.codeAction . _Just . L.dataSupport . _Just) .~ True + +codeActionNoResolveCaps :: ClientCapabilities +codeActionNoResolveCaps = Test.fullCaps + & (L.textDocument . _Just . L.codeAction . _Just . L.resolveSupport) .~ Nothing + & (L.textDocument . _Just . L.codeAction . _Just . L.dataSupport . _Just) .~ False -- --------------------------------------------------------------------- -- Environment specification for ignoring tests -- --------------------------------------------------------------------- From 0b57d5a70140d5cd503205a353b2b23d98e51c7d Mon Sep 17 00:00:00 2001 From: Nathan Maxson Date: Wed, 28 Jun 2023 17:25:21 +0300 Subject: [PATCH 15/18] use caps defined at hls-test-utils --- plugins/hls-overloaded-record-dot-plugin/test/Main.hs | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/plugins/hls-overloaded-record-dot-plugin/test/Main.hs b/plugins/hls-overloaded-record-dot-plugin/test/Main.hs index 94b0666eaf..458cbd345d 100644 --- a/plugins/hls-overloaded-record-dot-plugin/test/Main.hs +++ b/plugins/hls-overloaded-record-dot-plugin/test/Main.hs @@ -1,12 +1,11 @@ {-# LANGUAGE DuplicateRecordFields #-} {-# LANGUAGE NamedFieldPuns #-} -{-# LANGUAGE OverloadedLabels #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TypeOperators #-} module Main ( main ) where -import Control.Lens (_Just, set, (^.)) +import Control.Lens ((^.)) import Data.Either (rights) import Data.Functor (void) import Data.Maybe (isNothing) @@ -25,6 +24,8 @@ import qualified Ide.Plugin.OverloadedRecordDot as OverloadedRecordDot import Language.LSP.Protocol.Lens as L import System.FilePath ((<.>), ()) import Test.Hls +import Test.Hls.Util (codeActionNoResolveCaps, + codeActionResolveCaps) main :: IO () main = @@ -52,17 +53,15 @@ mkTest title fp selectorName x1 y1 x2 y2 = mkNoResolveTest :: TestName -> FilePath -> T.Text -> UInt -> UInt -> UInt -> UInt -> TestTree mkNoResolveTest title fp selectorName x1 y1 x2 y2 = - goldenWithHaskellAndCaps noResolveCaps plugin title testDataDir fp "expected" "hs" $ \doc -> do + goldenWithHaskellAndCaps codeActionNoResolveCaps plugin title testDataDir fp "expected" "hs" $ \doc -> do (act:_) <- getExplicitFieldsActions doc selectorName x1 y1 x2 y2 executeCodeAction act - where noResolveCaps = set (L.textDocument . _Just . L.codeAction . _Just . L.dataSupport . _Just) False fullCaps mkResolveTest :: TestName -> FilePath -> T.Text -> UInt -> UInt -> UInt -> UInt -> TestTree mkResolveTest title fp selectorName x1 y1 x2 y2 = - goldenWithHaskellAndCaps resolveCaps plugin title testDataDir fp "expected" "hs" $ \doc -> do + goldenWithHaskellAndCaps codeActionResolveCaps plugin title testDataDir fp "expected" "hs" $ \doc -> do ((Right act):_) <- getAndResolveExplicitFieldsActions doc selectorName x1 y1 x2 y2 executeCodeAction act - where resolveCaps = set (L.textDocument . _Just . L.codeAction . _Just . L.resolveSupport . _Just) (#properties .== ["edit"]) fullCaps getExplicitFieldsActions From 735feca0c5f7337237ea686ad5c376fbd9b2a755 Mon Sep 17 00:00:00 2001 From: Nathan Maxson Date: Thu, 29 Jun 2023 15:49:51 +0300 Subject: [PATCH 16/18] Add code lens resolve support --- hls-plugin-api/src/Ide/Types.hs | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/hls-plugin-api/src/Ide/Types.hs b/hls-plugin-api/src/Ide/Types.hs index 04025b16ec..f752c17244 100644 --- a/hls-plugin-api/src/Ide/Types.hs +++ b/hls-plugin-api/src/Ide/Types.hs @@ -451,6 +451,11 @@ instance PluginMethod Request Method_TextDocumentCodeLens where where uri = msgParams ^. L.textDocument . L.uri +instance PluginMethod Request Method_CodeLensResolve where + pluginEnabled _ msgParams pluginDesc config = + pluginResolverResponsible (msgParams ^. L.data_) pluginDesc + && pluginEnabledConfig plcCodeActionsOn (configForPlugin config pluginDesc) + instance PluginMethod Request Method_TextDocumentRename where pluginEnabled _ msgParams pluginDesc config = pluginResponsible uri pluginDesc && pluginEnabledConfig plcRenameOn (configForPlugin config pluginDesc) @@ -571,6 +576,10 @@ instance PluginRequestMethod Method_WorkspaceSymbol where instance PluginRequestMethod Method_TextDocumentCodeLens where +instance PluginRequestMethod Method_CodeLensResolve where + -- A resolve request should only ever get one response + combineResponses _ _ _ _ (x :| _) = x + instance PluginRequestMethod Method_TextDocumentRename where instance PluginRequestMethod Method_TextDocumentHover where @@ -969,6 +978,7 @@ instance HasTracing CallHierarchyIncomingCallsParams instance HasTracing CallHierarchyOutgoingCallsParams instance HasTracing CompletionItem instance HasTracing CodeAction +instance HasTracing CodeLens -- --------------------------------------------------------------------- {-# NOINLINE pROCESS_ID #-} From 0271ce212af57dc8ff52e6a80d0ed404cb57853e Mon Sep 17 00:00:00 2001 From: Nathan Maxson Date: Thu, 29 Jun 2023 18:37:12 +0300 Subject: [PATCH 17/18] Improve comments --- .../src/Ide/Plugin/OverloadedRecordDot.hs | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/plugins/hls-overloaded-record-dot-plugin/src/Ide/Plugin/OverloadedRecordDot.hs b/plugins/hls-overloaded-record-dot-plugin/src/Ide/Plugin/OverloadedRecordDot.hs index 75bf30558a..7a743bcdd5 100644 --- a/plugins/hls-overloaded-record-dot-plugin/src/Ide/Plugin/OverloadedRecordDot.hs +++ b/plugins/hls-overloaded-record-dot-plugin/src/Ide/Plugin/OverloadedRecordDot.hs @@ -118,8 +118,8 @@ instance NFData CollectRecordSelectors data CollectRecordSelectorsResult = CRSR { -- |We store everything in here that we need to create the unresolved - -- codeAction, the range, an uniquely identifiable int, and the expression - -- for the selector expression that we use to generate the name + -- codeAction: the range, an uniquely identifiable int, and the selector + --selector expression (HSExpr) that we use to generate the name records :: RangeMap (Int, HsExpr (GhcPass 'Renamed)) -- |This is for when we need to fully generate a textEdit. It contains the -- whole expression we are interested in indexed to the unique id we got @@ -183,8 +183,10 @@ resolveProvider ideState pId ca@(CodeAction _ _ _ _ _ _ _ (Just resData)) = pragma <- getFirstPragma pId ideState nfp case IntMap.lookup int crsDetails of Just rse -> pure $ ca {_edit = mkWorkspaceEdit uri rse exts pragma} - -- We need to throw a content modified error here, but we need fendor's - -- plugin error response pr to make it convenient to use here. + -- We need to throw a content modified error here, see + -- https://github.com/microsoft/language-server-protocol/issues/1738 + -- but we need fendor's plugin error response pr to make it + -- convenient to use here, so we will wait to do that till that's merged _ -> throwE "Content Modified Error" _ -> throwE "Unable to deserialize the data" @@ -247,6 +249,9 @@ collectRecSelsRule recorder = define (cmapWithPrio LogShake recorder) $ -- the OverloadedRecordDot pragma exts = getEnabledExtensions tmr recSels = mapMaybe (rewriteRange pm) (getRecordSelectors tmr) + -- We are creating a list as long as our rec selectors of unique int s + -- created by calling hashUnique on a Unique. The reason why we are + -- extracting the ints is because they don't need any work to serialize. uniques <- liftIO $ replicateM (length recSels) (hashUnique <$> newUnique) logWith recorder Debug (LogCollectedRecordSelectors recSels) let crsUniquesAndDetails = zip uniques recSels From 794034bf4487d5ca9959cb7dc4af57e95819383a Mon Sep 17 00:00:00 2001 From: Nathan Maxson Date: Fri, 30 Jun 2023 18:52:01 +0300 Subject: [PATCH 18/18] remove Benchmark as it wasn't that useful and triggered a lsp-test bug --- .../test/Main.hs | 3 +- .../test/testdata/Benchmark.expected.hs | 1805 ----------------- .../test/testdata/Benchmark.hs | 1804 ---------------- 3 files changed, 1 insertion(+), 3611 deletions(-) delete mode 100644 plugins/hls-overloaded-record-dot-plugin/test/testdata/Benchmark.expected.hs delete mode 100644 plugins/hls-overloaded-record-dot-plugin/test/testdata/Benchmark.hs diff --git a/plugins/hls-overloaded-record-dot-plugin/test/Main.hs b/plugins/hls-overloaded-record-dot-plugin/test/Main.hs index 458cbd345d..6015eedcba 100644 --- a/plugins/hls-overloaded-record-dot-plugin/test/Main.hs +++ b/plugins/hls-overloaded-record-dot-plugin/test/Main.hs @@ -43,8 +43,7 @@ test = testGroup "overloaded-record-dot" <> mkTest "NestedDollar" "NestedDollar" "name" 15 7 15 24 <> mkTest "MultilineCase" "MultilineCase" "name" 10 7 12 15 <> mkTest "Multiline" "Multiline" "name" 10 7 11 15 - <> mkTest "MultilineExpanded" "MultilineExpanded" "owner" 28 8 28 19 - <> mkTest "Benchmark" "Benchmark" "name1298" 1797 11 1797 27) + <> mkTest "MultilineExpanded" "MultilineExpanded" "owner" 28 8 28 19) mkTest :: TestName -> FilePath -> T.Text -> UInt -> UInt -> UInt -> UInt -> [TestTree] mkTest title fp selectorName x1 y1 x2 y2 = diff --git a/plugins/hls-overloaded-record-dot-plugin/test/testdata/Benchmark.expected.hs b/plugins/hls-overloaded-record-dot-plugin/test/testdata/Benchmark.expected.hs deleted file mode 100644 index 3f9bba1011..0000000000 --- a/plugins/hls-overloaded-record-dot-plugin/test/testdata/Benchmark.expected.hs +++ /dev/null @@ -1,1805 +0,0 @@ -{-# LANGUAGE OverloadedRecordDot #-} - -main :: IO () -main = do - putStrLn test1000 - -data Happy1000 = Happy1000 {name1000 :: String, age1000 :: Int, happy1000 :: Bool} -man1000 :: Happy1000 -man1000 = Happy1000 {name1000 = "Happy", age1000 = 1, happy1000 = True} -test1000 :: String -test1000 = name1000 man1000 - -data Happy1001 = Happy1001 {name1001 :: String, age1001 :: Int, happy1001 :: Bool} -man1001 :: Happy1001 -man1001 = Happy1001 {name1001 = "Happy", age1001 = 1, happy1001 = True} -test1001 :: String -test1001 = name1001 man1001 - -data Happy1002 = Happy1002 {name1002 :: String, age1002 :: Int, happy1002 :: Bool} -man1002 :: Happy1002 -man1002 = Happy1002 {name1002 = "Happy", age1002 = 1, happy1002 = True} -test1002 :: String -test1002 = name1002 man1002 - -data Happy1003 = Happy1003 {name1003 :: String, age1003 :: Int, happy1003 :: Bool} -man1003 :: Happy1003 -man1003 = Happy1003 {name1003 = "Happy", age1003 = 1, happy1003 = True} -test1003 :: String -test1003 = name1003 man1003 - -data Happy1004 = Happy1004 {name1004 :: String, age1004 :: Int, happy1004 :: Bool} -man1004 :: Happy1004 -man1004 = Happy1004 {name1004 = "Happy", age1004 = 1, happy1004 = True} -test1004 :: String -test1004 = name1004 man1004 - -data Happy1005 = Happy1005 {name1005 :: String, age1005 :: Int, happy1005 :: Bool} -man1005 :: Happy1005 -man1005 = Happy1005 {name1005 = "Happy", age1005 = 1, happy1005 = True} -test1005 :: String -test1005 = name1005 man1005 - -data Happy1006 = Happy1006 {name1006 :: String, age1006 :: Int, happy1006 :: Bool} -man1006 :: Happy1006 -man1006 = Happy1006 {name1006 = "Happy", age1006 = 1, happy1006 = True} -test1006 :: String -test1006 = name1006 man1006 - -data Happy1007 = Happy1007 {name1007 :: String, age1007 :: Int, happy1007 :: Bool} -man1007 :: Happy1007 -man1007 = Happy1007 {name1007 = "Happy", age1007 = 1, happy1007 = True} -test1007 :: String -test1007 = name1007 man1007 - -data Happy1008 = Happy1008 {name1008 :: String, age1008 :: Int, happy1008 :: Bool} -man1008 :: Happy1008 -man1008 = Happy1008 {name1008 = "Happy", age1008 = 1, happy1008 = True} -test1008 :: String -test1008 = name1008 man1008 - -data Happy1009 = Happy1009 {name1009 :: String, age1009 :: Int, happy1009 :: Bool} -man1009 :: Happy1009 -man1009 = Happy1009 {name1009 = "Happy", age1009 = 1, happy1009 = True} -test1009 :: String -test1009 = name1009 man1009 - -data Happy1010 = Happy1010 {name1010 :: String, age1010 :: Int, happy1010 :: Bool} -man1010 :: Happy1010 -man1010 = Happy1010 {name1010 = "Happy", age1010 = 1, happy1010 = True} -test1010 :: String -test1010 = name1010 man1010 - -data Happy1011 = Happy1011 {name1011 :: String, age1011 :: Int, happy1011 :: Bool} -man1011 :: Happy1011 -man1011 = Happy1011 {name1011 = "Happy", age1011 = 1, happy1011 = True} -test1011 :: String -test1011 = name1011 man1011 - -data Happy1012 = Happy1012 {name1012 :: String, age1012 :: Int, happy1012 :: Bool} -man1012 :: Happy1012 -man1012 = Happy1012 {name1012 = "Happy", age1012 = 1, happy1012 = True} -test1012 :: String -test1012 = name1012 man1012 - -data Happy1013 = Happy1013 {name1013 :: String, age1013 :: Int, happy1013 :: Bool} -man1013 :: Happy1013 -man1013 = Happy1013 {name1013 = "Happy", age1013 = 1, happy1013 = True} -test1013 :: String -test1013 = name1013 man1013 - -data Happy1014 = Happy1014 {name1014 :: String, age1014 :: Int, happy1014 :: Bool} -man1014 :: Happy1014 -man1014 = Happy1014 {name1014 = "Happy", age1014 = 1, happy1014 = True} -test1014 :: String -test1014 = name1014 man1014 - -data Happy1015 = Happy1015 {name1015 :: String, age1015 :: Int, happy1015 :: Bool} -man1015 :: Happy1015 -man1015 = Happy1015 {name1015 = "Happy", age1015 = 1, happy1015 = True} -test1015 :: String -test1015 = name1015 man1015 - -data Happy1016 = Happy1016 {name1016 :: String, age1016 :: Int, happy1016 :: Bool} -man1016 :: Happy1016 -man1016 = Happy1016 {name1016 = "Happy", age1016 = 1, happy1016 = True} -test1016 :: String -test1016 = name1016 man1016 - -data Happy1017 = Happy1017 {name1017 :: String, age1017 :: Int, happy1017 :: Bool} -man1017 :: Happy1017 -man1017 = Happy1017 {name1017 = "Happy", age1017 = 1, happy1017 = True} -test1017 :: String -test1017 = name1017 man1017 - -data Happy1018 = Happy1018 {name1018 :: String, age1018 :: Int, happy1018 :: Bool} -man1018 :: Happy1018 -man1018 = Happy1018 {name1018 = "Happy", age1018 = 1, happy1018 = True} -test1018 :: String -test1018 = name1018 man1018 - -data Happy1019 = Happy1019 {name1019 :: String, age1019 :: Int, happy1019 :: Bool} -man1019 :: Happy1019 -man1019 = Happy1019 {name1019 = "Happy", age1019 = 1, happy1019 = True} -test1019 :: String -test1019 = name1019 man1019 - -data Happy1020 = Happy1020 {name1020 :: String, age1020 :: Int, happy1020 :: Bool} -man1020 :: Happy1020 -man1020 = Happy1020 {name1020 = "Happy", age1020 = 1, happy1020 = True} -test1020 :: String -test1020 = name1020 man1020 - -data Happy1021 = Happy1021 {name1021 :: String, age1021 :: Int, happy1021 :: Bool} -man1021 :: Happy1021 -man1021 = Happy1021 {name1021 = "Happy", age1021 = 1, happy1021 = True} -test1021 :: String -test1021 = name1021 man1021 - -data Happy1022 = Happy1022 {name1022 :: String, age1022 :: Int, happy1022 :: Bool} -man1022 :: Happy1022 -man1022 = Happy1022 {name1022 = "Happy", age1022 = 1, happy1022 = True} -test1022 :: String -test1022 = name1022 man1022 - -data Happy1023 = Happy1023 {name1023 :: String, age1023 :: Int, happy1023 :: Bool} -man1023 :: Happy1023 -man1023 = Happy1023 {name1023 = "Happy", age1023 = 1, happy1023 = True} -test1023 :: String -test1023 = name1023 man1023 - -data Happy1024 = Happy1024 {name1024 :: String, age1024 :: Int, happy1024 :: Bool} -man1024 :: Happy1024 -man1024 = Happy1024 {name1024 = "Happy", age1024 = 1, happy1024 = True} -test1024 :: String -test1024 = name1024 man1024 - -data Happy1025 = Happy1025 {name1025 :: String, age1025 :: Int, happy1025 :: Bool} -man1025 :: Happy1025 -man1025 = Happy1025 {name1025 = "Happy", age1025 = 1, happy1025 = True} -test1025 :: String -test1025 = name1025 man1025 - -data Happy1026 = Happy1026 {name1026 :: String, age1026 :: Int, happy1026 :: Bool} -man1026 :: Happy1026 -man1026 = Happy1026 {name1026 = "Happy", age1026 = 1, happy1026 = True} -test1026 :: String -test1026 = name1026 man1026 - -data Happy1027 = Happy1027 {name1027 :: String, age1027 :: Int, happy1027 :: Bool} -man1027 :: Happy1027 -man1027 = Happy1027 {name1027 = "Happy", age1027 = 1, happy1027 = True} -test1027 :: String -test1027 = name1027 man1027 - -data Happy1028 = Happy1028 {name1028 :: String, age1028 :: Int, happy1028 :: Bool} -man1028 :: Happy1028 -man1028 = Happy1028 {name1028 = "Happy", age1028 = 1, happy1028 = True} -test1028 :: String -test1028 = name1028 man1028 - -data Happy1029 = Happy1029 {name1029 :: String, age1029 :: Int, happy1029 :: Bool} -man1029 :: Happy1029 -man1029 = Happy1029 {name1029 = "Happy", age1029 = 1, happy1029 = True} -test1029 :: String -test1029 = name1029 man1029 - -data Happy1030 = Happy1030 {name1030 :: String, age1030 :: Int, happy1030 :: Bool} -man1030 :: Happy1030 -man1030 = Happy1030 {name1030 = "Happy", age1030 = 1, happy1030 = True} -test1030 :: String -test1030 = name1030 man1030 - -data Happy1031 = Happy1031 {name1031 :: String, age1031 :: Int, happy1031 :: Bool} -man1031 :: Happy1031 -man1031 = Happy1031 {name1031 = "Happy", age1031 = 1, happy1031 = True} -test1031 :: String -test1031 = name1031 man1031 - -data Happy1032 = Happy1032 {name1032 :: String, age1032 :: Int, happy1032 :: Bool} -man1032 :: Happy1032 -man1032 = Happy1032 {name1032 = "Happy", age1032 = 1, happy1032 = True} -test1032 :: String -test1032 = name1032 man1032 - -data Happy1033 = Happy1033 {name1033 :: String, age1033 :: Int, happy1033 :: Bool} -man1033 :: Happy1033 -man1033 = Happy1033 {name1033 = "Happy", age1033 = 1, happy1033 = True} -test1033 :: String -test1033 = name1033 man1033 - -data Happy1034 = Happy1034 {name1034 :: String, age1034 :: Int, happy1034 :: Bool} -man1034 :: Happy1034 -man1034 = Happy1034 {name1034 = "Happy", age1034 = 1, happy1034 = True} -test1034 :: String -test1034 = name1034 man1034 - -data Happy1035 = Happy1035 {name1035 :: String, age1035 :: Int, happy1035 :: Bool} -man1035 :: Happy1035 -man1035 = Happy1035 {name1035 = "Happy", age1035 = 1, happy1035 = True} -test1035 :: String -test1035 = name1035 man1035 - -data Happy1036 = Happy1036 {name1036 :: String, age1036 :: Int, happy1036 :: Bool} -man1036 :: Happy1036 -man1036 = Happy1036 {name1036 = "Happy", age1036 = 1, happy1036 = True} -test1036 :: String -test1036 = name1036 man1036 - -data Happy1037 = Happy1037 {name1037 :: String, age1037 :: Int, happy1037 :: Bool} -man1037 :: Happy1037 -man1037 = Happy1037 {name1037 = "Happy", age1037 = 1, happy1037 = True} -test1037 :: String -test1037 = name1037 man1037 - -data Happy1038 = Happy1038 {name1038 :: String, age1038 :: Int, happy1038 :: Bool} -man1038 :: Happy1038 -man1038 = Happy1038 {name1038 = "Happy", age1038 = 1, happy1038 = True} -test1038 :: String -test1038 = name1038 man1038 - -data Happy1039 = Happy1039 {name1039 :: String, age1039 :: Int, happy1039 :: Bool} -man1039 :: Happy1039 -man1039 = Happy1039 {name1039 = "Happy", age1039 = 1, happy1039 = True} -test1039 :: String -test1039 = name1039 man1039 - -data Happy1040 = Happy1040 {name1040 :: String, age1040 :: Int, happy1040 :: Bool} -man1040 :: Happy1040 -man1040 = Happy1040 {name1040 = "Happy", age1040 = 1, happy1040 = True} -test1040 :: String -test1040 = name1040 man1040 - -data Happy1041 = Happy1041 {name1041 :: String, age1041 :: Int, happy1041 :: Bool} -man1041 :: Happy1041 -man1041 = Happy1041 {name1041 = "Happy", age1041 = 1, happy1041 = True} -test1041 :: String -test1041 = name1041 man1041 - -data Happy1042 = Happy1042 {name1042 :: String, age1042 :: Int, happy1042 :: Bool} -man1042 :: Happy1042 -man1042 = Happy1042 {name1042 = "Happy", age1042 = 1, happy1042 = True} -test1042 :: String -test1042 = name1042 man1042 - -data Happy1043 = Happy1043 {name1043 :: String, age1043 :: Int, happy1043 :: Bool} -man1043 :: Happy1043 -man1043 = Happy1043 {name1043 = "Happy", age1043 = 1, happy1043 = True} -test1043 :: String -test1043 = name1043 man1043 - -data Happy1044 = Happy1044 {name1044 :: String, age1044 :: Int, happy1044 :: Bool} -man1044 :: Happy1044 -man1044 = Happy1044 {name1044 = "Happy", age1044 = 1, happy1044 = True} -test1044 :: String -test1044 = name1044 man1044 - -data Happy1045 = Happy1045 {name1045 :: String, age1045 :: Int, happy1045 :: Bool} -man1045 :: Happy1045 -man1045 = Happy1045 {name1045 = "Happy", age1045 = 1, happy1045 = True} -test1045 :: String -test1045 = name1045 man1045 - -data Happy1046 = Happy1046 {name1046 :: String, age1046 :: Int, happy1046 :: Bool} -man1046 :: Happy1046 -man1046 = Happy1046 {name1046 = "Happy", age1046 = 1, happy1046 = True} -test1046 :: String -test1046 = name1046 man1046 - -data Happy1047 = Happy1047 {name1047 :: String, age1047 :: Int, happy1047 :: Bool} -man1047 :: Happy1047 -man1047 = Happy1047 {name1047 = "Happy", age1047 = 1, happy1047 = True} -test1047 :: String -test1047 = name1047 man1047 - -data Happy1048 = Happy1048 {name1048 :: String, age1048 :: Int, happy1048 :: Bool} -man1048 :: Happy1048 -man1048 = Happy1048 {name1048 = "Happy", age1048 = 1, happy1048 = True} -test1048 :: String -test1048 = name1048 man1048 - -data Happy1049 = Happy1049 {name1049 :: String, age1049 :: Int, happy1049 :: Bool} -man1049 :: Happy1049 -man1049 = Happy1049 {name1049 = "Happy", age1049 = 1, happy1049 = True} -test1049 :: String -test1049 = name1049 man1049 - -data Happy1050 = Happy1050 {name1050 :: String, age1050 :: Int, happy1050 :: Bool} -man1050 :: Happy1050 -man1050 = Happy1050 {name1050 = "Happy", age1050 = 1, happy1050 = True} -test1050 :: String -test1050 = name1050 man1050 - -data Happy1051 = Happy1051 {name1051 :: String, age1051 :: Int, happy1051 :: Bool} -man1051 :: Happy1051 -man1051 = Happy1051 {name1051 = "Happy", age1051 = 1, happy1051 = True} -test1051 :: String -test1051 = name1051 man1051 - -data Happy1052 = Happy1052 {name1052 :: String, age1052 :: Int, happy1052 :: Bool} -man1052 :: Happy1052 -man1052 = Happy1052 {name1052 = "Happy", age1052 = 1, happy1052 = True} -test1052 :: String -test1052 = name1052 man1052 - -data Happy1053 = Happy1053 {name1053 :: String, age1053 :: Int, happy1053 :: Bool} -man1053 :: Happy1053 -man1053 = Happy1053 {name1053 = "Happy", age1053 = 1, happy1053 = True} -test1053 :: String -test1053 = name1053 man1053 - -data Happy1054 = Happy1054 {name1054 :: String, age1054 :: Int, happy1054 :: Bool} -man1054 :: Happy1054 -man1054 = Happy1054 {name1054 = "Happy", age1054 = 1, happy1054 = True} -test1054 :: String -test1054 = name1054 man1054 - -data Happy1055 = Happy1055 {name1055 :: String, age1055 :: Int, happy1055 :: Bool} -man1055 :: Happy1055 -man1055 = Happy1055 {name1055 = "Happy", age1055 = 1, happy1055 = True} -test1055 :: String -test1055 = name1055 man1055 - -data Happy1056 = Happy1056 {name1056 :: String, age1056 :: Int, happy1056 :: Bool} -man1056 :: Happy1056 -man1056 = Happy1056 {name1056 = "Happy", age1056 = 1, happy1056 = True} -test1056 :: String -test1056 = name1056 man1056 - -data Happy1057 = Happy1057 {name1057 :: String, age1057 :: Int, happy1057 :: Bool} -man1057 :: Happy1057 -man1057 = Happy1057 {name1057 = "Happy", age1057 = 1, happy1057 = True} -test1057 :: String -test1057 = name1057 man1057 - -data Happy1058 = Happy1058 {name1058 :: String, age1058 :: Int, happy1058 :: Bool} -man1058 :: Happy1058 -man1058 = Happy1058 {name1058 = "Happy", age1058 = 1, happy1058 = True} -test1058 :: String -test1058 = name1058 man1058 - -data Happy1059 = Happy1059 {name1059 :: String, age1059 :: Int, happy1059 :: Bool} -man1059 :: Happy1059 -man1059 = Happy1059 {name1059 = "Happy", age1059 = 1, happy1059 = True} -test1059 :: String -test1059 = name1059 man1059 - -data Happy1060 = Happy1060 {name1060 :: String, age1060 :: Int, happy1060 :: Bool} -man1060 :: Happy1060 -man1060 = Happy1060 {name1060 = "Happy", age1060 = 1, happy1060 = True} -test1060 :: String -test1060 = name1060 man1060 - -data Happy1061 = Happy1061 {name1061 :: String, age1061 :: Int, happy1061 :: Bool} -man1061 :: Happy1061 -man1061 = Happy1061 {name1061 = "Happy", age1061 = 1, happy1061 = True} -test1061 :: String -test1061 = name1061 man1061 - -data Happy1062 = Happy1062 {name1062 :: String, age1062 :: Int, happy1062 :: Bool} -man1062 :: Happy1062 -man1062 = Happy1062 {name1062 = "Happy", age1062 = 1, happy1062 = True} -test1062 :: String -test1062 = name1062 man1062 - -data Happy1063 = Happy1063 {name1063 :: String, age1063 :: Int, happy1063 :: Bool} -man1063 :: Happy1063 -man1063 = Happy1063 {name1063 = "Happy", age1063 = 1, happy1063 = True} -test1063 :: String -test1063 = name1063 man1063 - -data Happy1064 = Happy1064 {name1064 :: String, age1064 :: Int, happy1064 :: Bool} -man1064 :: Happy1064 -man1064 = Happy1064 {name1064 = "Happy", age1064 = 1, happy1064 = True} -test1064 :: String -test1064 = name1064 man1064 - -data Happy1065 = Happy1065 {name1065 :: String, age1065 :: Int, happy1065 :: Bool} -man1065 :: Happy1065 -man1065 = Happy1065 {name1065 = "Happy", age1065 = 1, happy1065 = True} -test1065 :: String -test1065 = name1065 man1065 - -data Happy1066 = Happy1066 {name1066 :: String, age1066 :: Int, happy1066 :: Bool} -man1066 :: Happy1066 -man1066 = Happy1066 {name1066 = "Happy", age1066 = 1, happy1066 = True} -test1066 :: String -test1066 = name1066 man1066 - -data Happy1067 = Happy1067 {name1067 :: String, age1067 :: Int, happy1067 :: Bool} -man1067 :: Happy1067 -man1067 = Happy1067 {name1067 = "Happy", age1067 = 1, happy1067 = True} -test1067 :: String -test1067 = name1067 man1067 - -data Happy1068 = Happy1068 {name1068 :: String, age1068 :: Int, happy1068 :: Bool} -man1068 :: Happy1068 -man1068 = Happy1068 {name1068 = "Happy", age1068 = 1, happy1068 = True} -test1068 :: String -test1068 = name1068 man1068 - -data Happy1069 = Happy1069 {name1069 :: String, age1069 :: Int, happy1069 :: Bool} -man1069 :: Happy1069 -man1069 = Happy1069 {name1069 = "Happy", age1069 = 1, happy1069 = True} -test1069 :: String -test1069 = name1069 man1069 - -data Happy1070 = Happy1070 {name1070 :: String, age1070 :: Int, happy1070 :: Bool} -man1070 :: Happy1070 -man1070 = Happy1070 {name1070 = "Happy", age1070 = 1, happy1070 = True} -test1070 :: String -test1070 = name1070 man1070 - -data Happy1071 = Happy1071 {name1071 :: String, age1071 :: Int, happy1071 :: Bool} -man1071 :: Happy1071 -man1071 = Happy1071 {name1071 = "Happy", age1071 = 1, happy1071 = True} -test1071 :: String -test1071 = name1071 man1071 - -data Happy1072 = Happy1072 {name1072 :: String, age1072 :: Int, happy1072 :: Bool} -man1072 :: Happy1072 -man1072 = Happy1072 {name1072 = "Happy", age1072 = 1, happy1072 = True} -test1072 :: String -test1072 = name1072 man1072 - -data Happy1073 = Happy1073 {name1073 :: String, age1073 :: Int, happy1073 :: Bool} -man1073 :: Happy1073 -man1073 = Happy1073 {name1073 = "Happy", age1073 = 1, happy1073 = True} -test1073 :: String -test1073 = name1073 man1073 - -data Happy1074 = Happy1074 {name1074 :: String, age1074 :: Int, happy1074 :: Bool} -man1074 :: Happy1074 -man1074 = Happy1074 {name1074 = "Happy", age1074 = 1, happy1074 = True} -test1074 :: String -test1074 = name1074 man1074 - -data Happy1075 = Happy1075 {name1075 :: String, age1075 :: Int, happy1075 :: Bool} -man1075 :: Happy1075 -man1075 = Happy1075 {name1075 = "Happy", age1075 = 1, happy1075 = True} -test1075 :: String -test1075 = name1075 man1075 - -data Happy1076 = Happy1076 {name1076 :: String, age1076 :: Int, happy1076 :: Bool} -man1076 :: Happy1076 -man1076 = Happy1076 {name1076 = "Happy", age1076 = 1, happy1076 = True} -test1076 :: String -test1076 = name1076 man1076 - -data Happy1077 = Happy1077 {name1077 :: String, age1077 :: Int, happy1077 :: Bool} -man1077 :: Happy1077 -man1077 = Happy1077 {name1077 = "Happy", age1077 = 1, happy1077 = True} -test1077 :: String -test1077 = name1077 man1077 - -data Happy1078 = Happy1078 {name1078 :: String, age1078 :: Int, happy1078 :: Bool} -man1078 :: Happy1078 -man1078 = Happy1078 {name1078 = "Happy", age1078 = 1, happy1078 = True} -test1078 :: String -test1078 = name1078 man1078 - -data Happy1079 = Happy1079 {name1079 :: String, age1079 :: Int, happy1079 :: Bool} -man1079 :: Happy1079 -man1079 = Happy1079 {name1079 = "Happy", age1079 = 1, happy1079 = True} -test1079 :: String -test1079 = name1079 man1079 - -data Happy1080 = Happy1080 {name1080 :: String, age1080 :: Int, happy1080 :: Bool} -man1080 :: Happy1080 -man1080 = Happy1080 {name1080 = "Happy", age1080 = 1, happy1080 = True} -test1080 :: String -test1080 = name1080 man1080 - -data Happy1081 = Happy1081 {name1081 :: String, age1081 :: Int, happy1081 :: Bool} -man1081 :: Happy1081 -man1081 = Happy1081 {name1081 = "Happy", age1081 = 1, happy1081 = True} -test1081 :: String -test1081 = name1081 man1081 - -data Happy1082 = Happy1082 {name1082 :: String, age1082 :: Int, happy1082 :: Bool} -man1082 :: Happy1082 -man1082 = Happy1082 {name1082 = "Happy", age1082 = 1, happy1082 = True} -test1082 :: String -test1082 = name1082 man1082 - -data Happy1083 = Happy1083 {name1083 :: String, age1083 :: Int, happy1083 :: Bool} -man1083 :: Happy1083 -man1083 = Happy1083 {name1083 = "Happy", age1083 = 1, happy1083 = True} -test1083 :: String -test1083 = name1083 man1083 - -data Happy1084 = Happy1084 {name1084 :: String, age1084 :: Int, happy1084 :: Bool} -man1084 :: Happy1084 -man1084 = Happy1084 {name1084 = "Happy", age1084 = 1, happy1084 = True} -test1084 :: String -test1084 = name1084 man1084 - -data Happy1085 = Happy1085 {name1085 :: String, age1085 :: Int, happy1085 :: Bool} -man1085 :: Happy1085 -man1085 = Happy1085 {name1085 = "Happy", age1085 = 1, happy1085 = True} -test1085 :: String -test1085 = name1085 man1085 - -data Happy1086 = Happy1086 {name1086 :: String, age1086 :: Int, happy1086 :: Bool} -man1086 :: Happy1086 -man1086 = Happy1086 {name1086 = "Happy", age1086 = 1, happy1086 = True} -test1086 :: String -test1086 = name1086 man1086 - -data Happy1087 = Happy1087 {name1087 :: String, age1087 :: Int, happy1087 :: Bool} -man1087 :: Happy1087 -man1087 = Happy1087 {name1087 = "Happy", age1087 = 1, happy1087 = True} -test1087 :: String -test1087 = name1087 man1087 - -data Happy1088 = Happy1088 {name1088 :: String, age1088 :: Int, happy1088 :: Bool} -man1088 :: Happy1088 -man1088 = Happy1088 {name1088 = "Happy", age1088 = 1, happy1088 = True} -test1088 :: String -test1088 = name1088 man1088 - -data Happy1089 = Happy1089 {name1089 :: String, age1089 :: Int, happy1089 :: Bool} -man1089 :: Happy1089 -man1089 = Happy1089 {name1089 = "Happy", age1089 = 1, happy1089 = True} -test1089 :: String -test1089 = name1089 man1089 - -data Happy1090 = Happy1090 {name1090 :: String, age1090 :: Int, happy1090 :: Bool} -man1090 :: Happy1090 -man1090 = Happy1090 {name1090 = "Happy", age1090 = 1, happy1090 = True} -test1090 :: String -test1090 = name1090 man1090 - -data Happy1091 = Happy1091 {name1091 :: String, age1091 :: Int, happy1091 :: Bool} -man1091 :: Happy1091 -man1091 = Happy1091 {name1091 = "Happy", age1091 = 1, happy1091 = True} -test1091 :: String -test1091 = name1091 man1091 - -data Happy1092 = Happy1092 {name1092 :: String, age1092 :: Int, happy1092 :: Bool} -man1092 :: Happy1092 -man1092 = Happy1092 {name1092 = "Happy", age1092 = 1, happy1092 = True} -test1092 :: String -test1092 = name1092 man1092 - -data Happy1093 = Happy1093 {name1093 :: String, age1093 :: Int, happy1093 :: Bool} -man1093 :: Happy1093 -man1093 = Happy1093 {name1093 = "Happy", age1093 = 1, happy1093 = True} -test1093 :: String -test1093 = name1093 man1093 - -data Happy1094 = Happy1094 {name1094 :: String, age1094 :: Int, happy1094 :: Bool} -man1094 :: Happy1094 -man1094 = Happy1094 {name1094 = "Happy", age1094 = 1, happy1094 = True} -test1094 :: String -test1094 = name1094 man1094 - -data Happy1095 = Happy1095 {name1095 :: String, age1095 :: Int, happy1095 :: Bool} -man1095 :: Happy1095 -man1095 = Happy1095 {name1095 = "Happy", age1095 = 1, happy1095 = True} -test1095 :: String -test1095 = name1095 man1095 - -data Happy1096 = Happy1096 {name1096 :: String, age1096 :: Int, happy1096 :: Bool} -man1096 :: Happy1096 -man1096 = Happy1096 {name1096 = "Happy", age1096 = 1, happy1096 = True} -test1096 :: String -test1096 = name1096 man1096 - -data Happy1097 = Happy1097 {name1097 :: String, age1097 :: Int, happy1097 :: Bool} -man1097 :: Happy1097 -man1097 = Happy1097 {name1097 = "Happy", age1097 = 1, happy1097 = True} -test1097 :: String -test1097 = name1097 man1097 - -data Happy1098 = Happy1098 {name1098 :: String, age1098 :: Int, happy1098 :: Bool} -man1098 :: Happy1098 -man1098 = Happy1098 {name1098 = "Happy", age1098 = 1, happy1098 = True} -test1098 :: String -test1098 = name1098 man1098 - -data Happy1099 = Happy1099 {name1099 :: String, age1099 :: Int, happy1099 :: Bool} -man1099 :: Happy1099 -man1099 = Happy1099 {name1099 = "Happy", age1099 = 1, happy1099 = True} -test1099 :: String -test1099 = name1099 man1099 - -data Happy1100 = Happy1100 {name1100 :: String, age1100 :: Int, happy1100 :: Bool} -man1100 :: Happy1100 -man1100 = Happy1100 {name1100 = "Happy", age1100 = 1, happy1100 = True} -test1100 :: String -test1100 = name1100 man1100 - -data Happy1101 = Happy1101 {name1101 :: String, age1101 :: Int, happy1101 :: Bool} -man1101 :: Happy1101 -man1101 = Happy1101 {name1101 = "Happy", age1101 = 1, happy1101 = True} -test1101 :: String -test1101 = name1101 man1101 - -data Happy1102 = Happy1102 {name1102 :: String, age1102 :: Int, happy1102 :: Bool} -man1102 :: Happy1102 -man1102 = Happy1102 {name1102 = "Happy", age1102 = 1, happy1102 = True} -test1102 :: String -test1102 = name1102 man1102 - -data Happy1103 = Happy1103 {name1103 :: String, age1103 :: Int, happy1103 :: Bool} -man1103 :: Happy1103 -man1103 = Happy1103 {name1103 = "Happy", age1103 = 1, happy1103 = True} -test1103 :: String -test1103 = name1103 man1103 - -data Happy1104 = Happy1104 {name1104 :: String, age1104 :: Int, happy1104 :: Bool} -man1104 :: Happy1104 -man1104 = Happy1104 {name1104 = "Happy", age1104 = 1, happy1104 = True} -test1104 :: String -test1104 = name1104 man1104 - -data Happy1105 = Happy1105 {name1105 :: String, age1105 :: Int, happy1105 :: Bool} -man1105 :: Happy1105 -man1105 = Happy1105 {name1105 = "Happy", age1105 = 1, happy1105 = True} -test1105 :: String -test1105 = name1105 man1105 - -data Happy1106 = Happy1106 {name1106 :: String, age1106 :: Int, happy1106 :: Bool} -man1106 :: Happy1106 -man1106 = Happy1106 {name1106 = "Happy", age1106 = 1, happy1106 = True} -test1106 :: String -test1106 = name1106 man1106 - -data Happy1107 = Happy1107 {name1107 :: String, age1107 :: Int, happy1107 :: Bool} -man1107 :: Happy1107 -man1107 = Happy1107 {name1107 = "Happy", age1107 = 1, happy1107 = True} -test1107 :: String -test1107 = name1107 man1107 - -data Happy1108 = Happy1108 {name1108 :: String, age1108 :: Int, happy1108 :: Bool} -man1108 :: Happy1108 -man1108 = Happy1108 {name1108 = "Happy", age1108 = 1, happy1108 = True} -test1108 :: String -test1108 = name1108 man1108 - -data Happy1109 = Happy1109 {name1109 :: String, age1109 :: Int, happy1109 :: Bool} -man1109 :: Happy1109 -man1109 = Happy1109 {name1109 = "Happy", age1109 = 1, happy1109 = True} -test1109 :: String -test1109 = name1109 man1109 - -data Happy1110 = Happy1110 {name1110 :: String, age1110 :: Int, happy1110 :: Bool} -man1110 :: Happy1110 -man1110 = Happy1110 {name1110 = "Happy", age1110 = 1, happy1110 = True} -test1110 :: String -test1110 = name1110 man1110 - -data Happy1111 = Happy1111 {name1111 :: String, age1111 :: Int, happy1111 :: Bool} -man1111 :: Happy1111 -man1111 = Happy1111 {name1111 = "Happy", age1111 = 1, happy1111 = True} -test1111 :: String -test1111 = name1111 man1111 - -data Happy1112 = Happy1112 {name1112 :: String, age1112 :: Int, happy1112 :: Bool} -man1112 :: Happy1112 -man1112 = Happy1112 {name1112 = "Happy", age1112 = 1, happy1112 = True} -test1112 :: String -test1112 = name1112 man1112 - -data Happy1113 = Happy1113 {name1113 :: String, age1113 :: Int, happy1113 :: Bool} -man1113 :: Happy1113 -man1113 = Happy1113 {name1113 = "Happy", age1113 = 1, happy1113 = True} -test1113 :: String -test1113 = name1113 man1113 - -data Happy1114 = Happy1114 {name1114 :: String, age1114 :: Int, happy1114 :: Bool} -man1114 :: Happy1114 -man1114 = Happy1114 {name1114 = "Happy", age1114 = 1, happy1114 = True} -test1114 :: String -test1114 = name1114 man1114 - -data Happy1115 = Happy1115 {name1115 :: String, age1115 :: Int, happy1115 :: Bool} -man1115 :: Happy1115 -man1115 = Happy1115 {name1115 = "Happy", age1115 = 1, happy1115 = True} -test1115 :: String -test1115 = name1115 man1115 - -data Happy1116 = Happy1116 {name1116 :: String, age1116 :: Int, happy1116 :: Bool} -man1116 :: Happy1116 -man1116 = Happy1116 {name1116 = "Happy", age1116 = 1, happy1116 = True} -test1116 :: String -test1116 = name1116 man1116 - -data Happy1117 = Happy1117 {name1117 :: String, age1117 :: Int, happy1117 :: Bool} -man1117 :: Happy1117 -man1117 = Happy1117 {name1117 = "Happy", age1117 = 1, happy1117 = True} -test1117 :: String -test1117 = name1117 man1117 - -data Happy1118 = Happy1118 {name1118 :: String, age1118 :: Int, happy1118 :: Bool} -man1118 :: Happy1118 -man1118 = Happy1118 {name1118 = "Happy", age1118 = 1, happy1118 = True} -test1118 :: String -test1118 = name1118 man1118 - -data Happy1119 = Happy1119 {name1119 :: String, age1119 :: Int, happy1119 :: Bool} -man1119 :: Happy1119 -man1119 = Happy1119 {name1119 = "Happy", age1119 = 1, happy1119 = True} -test1119 :: String -test1119 = name1119 man1119 - -data Happy1120 = Happy1120 {name1120 :: String, age1120 :: Int, happy1120 :: Bool} -man1120 :: Happy1120 -man1120 = Happy1120 {name1120 = "Happy", age1120 = 1, happy1120 = True} -test1120 :: String -test1120 = name1120 man1120 - -data Happy1121 = Happy1121 {name1121 :: String, age1121 :: Int, happy1121 :: Bool} -man1121 :: Happy1121 -man1121 = Happy1121 {name1121 = "Happy", age1121 = 1, happy1121 = True} -test1121 :: String -test1121 = name1121 man1121 - -data Happy1122 = Happy1122 {name1122 :: String, age1122 :: Int, happy1122 :: Bool} -man1122 :: Happy1122 -man1122 = Happy1122 {name1122 = "Happy", age1122 = 1, happy1122 = True} -test1122 :: String -test1122 = name1122 man1122 - -data Happy1123 = Happy1123 {name1123 :: String, age1123 :: Int, happy1123 :: Bool} -man1123 :: Happy1123 -man1123 = Happy1123 {name1123 = "Happy", age1123 = 1, happy1123 = True} -test1123 :: String -test1123 = name1123 man1123 - -data Happy1124 = Happy1124 {name1124 :: String, age1124 :: Int, happy1124 :: Bool} -man1124 :: Happy1124 -man1124 = Happy1124 {name1124 = "Happy", age1124 = 1, happy1124 = True} -test1124 :: String -test1124 = name1124 man1124 - -data Happy1125 = Happy1125 {name1125 :: String, age1125 :: Int, happy1125 :: Bool} -man1125 :: Happy1125 -man1125 = Happy1125 {name1125 = "Happy", age1125 = 1, happy1125 = True} -test1125 :: String -test1125 = name1125 man1125 - -data Happy1126 = Happy1126 {name1126 :: String, age1126 :: Int, happy1126 :: Bool} -man1126 :: Happy1126 -man1126 = Happy1126 {name1126 = "Happy", age1126 = 1, happy1126 = True} -test1126 :: String -test1126 = name1126 man1126 - -data Happy1127 = Happy1127 {name1127 :: String, age1127 :: Int, happy1127 :: Bool} -man1127 :: Happy1127 -man1127 = Happy1127 {name1127 = "Happy", age1127 = 1, happy1127 = True} -test1127 :: String -test1127 = name1127 man1127 - -data Happy1128 = Happy1128 {name1128 :: String, age1128 :: Int, happy1128 :: Bool} -man1128 :: Happy1128 -man1128 = Happy1128 {name1128 = "Happy", age1128 = 1, happy1128 = True} -test1128 :: String -test1128 = name1128 man1128 - -data Happy1129 = Happy1129 {name1129 :: String, age1129 :: Int, happy1129 :: Bool} -man1129 :: Happy1129 -man1129 = Happy1129 {name1129 = "Happy", age1129 = 1, happy1129 = True} -test1129 :: String -test1129 = name1129 man1129 - -data Happy1130 = Happy1130 {name1130 :: String, age1130 :: Int, happy1130 :: Bool} -man1130 :: Happy1130 -man1130 = Happy1130 {name1130 = "Happy", age1130 = 1, happy1130 = True} -test1130 :: String -test1130 = name1130 man1130 - -data Happy1131 = Happy1131 {name1131 :: String, age1131 :: Int, happy1131 :: Bool} -man1131 :: Happy1131 -man1131 = Happy1131 {name1131 = "Happy", age1131 = 1, happy1131 = True} -test1131 :: String -test1131 = name1131 man1131 - -data Happy1132 = Happy1132 {name1132 :: String, age1132 :: Int, happy1132 :: Bool} -man1132 :: Happy1132 -man1132 = Happy1132 {name1132 = "Happy", age1132 = 1, happy1132 = True} -test1132 :: String -test1132 = name1132 man1132 - -data Happy1133 = Happy1133 {name1133 :: String, age1133 :: Int, happy1133 :: Bool} -man1133 :: Happy1133 -man1133 = Happy1133 {name1133 = "Happy", age1133 = 1, happy1133 = True} -test1133 :: String -test1133 = name1133 man1133 - -data Happy1134 = Happy1134 {name1134 :: String, age1134 :: Int, happy1134 :: Bool} -man1134 :: Happy1134 -man1134 = Happy1134 {name1134 = "Happy", age1134 = 1, happy1134 = True} -test1134 :: String -test1134 = name1134 man1134 - -data Happy1135 = Happy1135 {name1135 :: String, age1135 :: Int, happy1135 :: Bool} -man1135 :: Happy1135 -man1135 = Happy1135 {name1135 = "Happy", age1135 = 1, happy1135 = True} -test1135 :: String -test1135 = name1135 man1135 - -data Happy1136 = Happy1136 {name1136 :: String, age1136 :: Int, happy1136 :: Bool} -man1136 :: Happy1136 -man1136 = Happy1136 {name1136 = "Happy", age1136 = 1, happy1136 = True} -test1136 :: String -test1136 = name1136 man1136 - -data Happy1137 = Happy1137 {name1137 :: String, age1137 :: Int, happy1137 :: Bool} -man1137 :: Happy1137 -man1137 = Happy1137 {name1137 = "Happy", age1137 = 1, happy1137 = True} -test1137 :: String -test1137 = name1137 man1137 - -data Happy1138 = Happy1138 {name1138 :: String, age1138 :: Int, happy1138 :: Bool} -man1138 :: Happy1138 -man1138 = Happy1138 {name1138 = "Happy", age1138 = 1, happy1138 = True} -test1138 :: String -test1138 = name1138 man1138 - -data Happy1139 = Happy1139 {name1139 :: String, age1139 :: Int, happy1139 :: Bool} -man1139 :: Happy1139 -man1139 = Happy1139 {name1139 = "Happy", age1139 = 1, happy1139 = True} -test1139 :: String -test1139 = name1139 man1139 - -data Happy1140 = Happy1140 {name1140 :: String, age1140 :: Int, happy1140 :: Bool} -man1140 :: Happy1140 -man1140 = Happy1140 {name1140 = "Happy", age1140 = 1, happy1140 = True} -test1140 :: String -test1140 = name1140 man1140 - -data Happy1141 = Happy1141 {name1141 :: String, age1141 :: Int, happy1141 :: Bool} -man1141 :: Happy1141 -man1141 = Happy1141 {name1141 = "Happy", age1141 = 1, happy1141 = True} -test1141 :: String -test1141 = name1141 man1141 - -data Happy1142 = Happy1142 {name1142 :: String, age1142 :: Int, happy1142 :: Bool} -man1142 :: Happy1142 -man1142 = Happy1142 {name1142 = "Happy", age1142 = 1, happy1142 = True} -test1142 :: String -test1142 = name1142 man1142 - -data Happy1143 = Happy1143 {name1143 :: String, age1143 :: Int, happy1143 :: Bool} -man1143 :: Happy1143 -man1143 = Happy1143 {name1143 = "Happy", age1143 = 1, happy1143 = True} -test1143 :: String -test1143 = name1143 man1143 - -data Happy1144 = Happy1144 {name1144 :: String, age1144 :: Int, happy1144 :: Bool} -man1144 :: Happy1144 -man1144 = Happy1144 {name1144 = "Happy", age1144 = 1, happy1144 = True} -test1144 :: String -test1144 = name1144 man1144 - -data Happy1145 = Happy1145 {name1145 :: String, age1145 :: Int, happy1145 :: Bool} -man1145 :: Happy1145 -man1145 = Happy1145 {name1145 = "Happy", age1145 = 1, happy1145 = True} -test1145 :: String -test1145 = name1145 man1145 - -data Happy1146 = Happy1146 {name1146 :: String, age1146 :: Int, happy1146 :: Bool} -man1146 :: Happy1146 -man1146 = Happy1146 {name1146 = "Happy", age1146 = 1, happy1146 = True} -test1146 :: String -test1146 = name1146 man1146 - -data Happy1147 = Happy1147 {name1147 :: String, age1147 :: Int, happy1147 :: Bool} -man1147 :: Happy1147 -man1147 = Happy1147 {name1147 = "Happy", age1147 = 1, happy1147 = True} -test1147 :: String -test1147 = name1147 man1147 - -data Happy1148 = Happy1148 {name1148 :: String, age1148 :: Int, happy1148 :: Bool} -man1148 :: Happy1148 -man1148 = Happy1148 {name1148 = "Happy", age1148 = 1, happy1148 = True} -test1148 :: String -test1148 = name1148 man1148 - -data Happy1149 = Happy1149 {name1149 :: String, age1149 :: Int, happy1149 :: Bool} -man1149 :: Happy1149 -man1149 = Happy1149 {name1149 = "Happy", age1149 = 1, happy1149 = True} -test1149 :: String -test1149 = name1149 man1149 - -data Happy1150 = Happy1150 {name1150 :: String, age1150 :: Int, happy1150 :: Bool} -man1150 :: Happy1150 -man1150 = Happy1150 {name1150 = "Happy", age1150 = 1, happy1150 = True} -test1150 :: String -test1150 = name1150 man1150 - -data Happy1151 = Happy1151 {name1151 :: String, age1151 :: Int, happy1151 :: Bool} -man1151 :: Happy1151 -man1151 = Happy1151 {name1151 = "Happy", age1151 = 1, happy1151 = True} -test1151 :: String -test1151 = name1151 man1151 - -data Happy1152 = Happy1152 {name1152 :: String, age1152 :: Int, happy1152 :: Bool} -man1152 :: Happy1152 -man1152 = Happy1152 {name1152 = "Happy", age1152 = 1, happy1152 = True} -test1152 :: String -test1152 = name1152 man1152 - -data Happy1153 = Happy1153 {name1153 :: String, age1153 :: Int, happy1153 :: Bool} -man1153 :: Happy1153 -man1153 = Happy1153 {name1153 = "Happy", age1153 = 1, happy1153 = True} -test1153 :: String -test1153 = name1153 man1153 - -data Happy1154 = Happy1154 {name1154 :: String, age1154 :: Int, happy1154 :: Bool} -man1154 :: Happy1154 -man1154 = Happy1154 {name1154 = "Happy", age1154 = 1, happy1154 = True} -test1154 :: String -test1154 = name1154 man1154 - -data Happy1155 = Happy1155 {name1155 :: String, age1155 :: Int, happy1155 :: Bool} -man1155 :: Happy1155 -man1155 = Happy1155 {name1155 = "Happy", age1155 = 1, happy1155 = True} -test1155 :: String -test1155 = name1155 man1155 - -data Happy1156 = Happy1156 {name1156 :: String, age1156 :: Int, happy1156 :: Bool} -man1156 :: Happy1156 -man1156 = Happy1156 {name1156 = "Happy", age1156 = 1, happy1156 = True} -test1156 :: String -test1156 = name1156 man1156 - -data Happy1157 = Happy1157 {name1157 :: String, age1157 :: Int, happy1157 :: Bool} -man1157 :: Happy1157 -man1157 = Happy1157 {name1157 = "Happy", age1157 = 1, happy1157 = True} -test1157 :: String -test1157 = name1157 man1157 - -data Happy1158 = Happy1158 {name1158 :: String, age1158 :: Int, happy1158 :: Bool} -man1158 :: Happy1158 -man1158 = Happy1158 {name1158 = "Happy", age1158 = 1, happy1158 = True} -test1158 :: String -test1158 = name1158 man1158 - -data Happy1159 = Happy1159 {name1159 :: String, age1159 :: Int, happy1159 :: Bool} -man1159 :: Happy1159 -man1159 = Happy1159 {name1159 = "Happy", age1159 = 1, happy1159 = True} -test1159 :: String -test1159 = name1159 man1159 - -data Happy1160 = Happy1160 {name1160 :: String, age1160 :: Int, happy1160 :: Bool} -man1160 :: Happy1160 -man1160 = Happy1160 {name1160 = "Happy", age1160 = 1, happy1160 = True} -test1160 :: String -test1160 = name1160 man1160 - -data Happy1161 = Happy1161 {name1161 :: String, age1161 :: Int, happy1161 :: Bool} -man1161 :: Happy1161 -man1161 = Happy1161 {name1161 = "Happy", age1161 = 1, happy1161 = True} -test1161 :: String -test1161 = name1161 man1161 - -data Happy1162 = Happy1162 {name1162 :: String, age1162 :: Int, happy1162 :: Bool} -man1162 :: Happy1162 -man1162 = Happy1162 {name1162 = "Happy", age1162 = 1, happy1162 = True} -test1162 :: String -test1162 = name1162 man1162 - -data Happy1163 = Happy1163 {name1163 :: String, age1163 :: Int, happy1163 :: Bool} -man1163 :: Happy1163 -man1163 = Happy1163 {name1163 = "Happy", age1163 = 1, happy1163 = True} -test1163 :: String -test1163 = name1163 man1163 - -data Happy1164 = Happy1164 {name1164 :: String, age1164 :: Int, happy1164 :: Bool} -man1164 :: Happy1164 -man1164 = Happy1164 {name1164 = "Happy", age1164 = 1, happy1164 = True} -test1164 :: String -test1164 = name1164 man1164 - -data Happy1165 = Happy1165 {name1165 :: String, age1165 :: Int, happy1165 :: Bool} -man1165 :: Happy1165 -man1165 = Happy1165 {name1165 = "Happy", age1165 = 1, happy1165 = True} -test1165 :: String -test1165 = name1165 man1165 - -data Happy1166 = Happy1166 {name1166 :: String, age1166 :: Int, happy1166 :: Bool} -man1166 :: Happy1166 -man1166 = Happy1166 {name1166 = "Happy", age1166 = 1, happy1166 = True} -test1166 :: String -test1166 = name1166 man1166 - -data Happy1167 = Happy1167 {name1167 :: String, age1167 :: Int, happy1167 :: Bool} -man1167 :: Happy1167 -man1167 = Happy1167 {name1167 = "Happy", age1167 = 1, happy1167 = True} -test1167 :: String -test1167 = name1167 man1167 - -data Happy1168 = Happy1168 {name1168 :: String, age1168 :: Int, happy1168 :: Bool} -man1168 :: Happy1168 -man1168 = Happy1168 {name1168 = "Happy", age1168 = 1, happy1168 = True} -test1168 :: String -test1168 = name1168 man1168 - -data Happy1169 = Happy1169 {name1169 :: String, age1169 :: Int, happy1169 :: Bool} -man1169 :: Happy1169 -man1169 = Happy1169 {name1169 = "Happy", age1169 = 1, happy1169 = True} -test1169 :: String -test1169 = name1169 man1169 - -data Happy1170 = Happy1170 {name1170 :: String, age1170 :: Int, happy1170 :: Bool} -man1170 :: Happy1170 -man1170 = Happy1170 {name1170 = "Happy", age1170 = 1, happy1170 = True} -test1170 :: String -test1170 = name1170 man1170 - -data Happy1171 = Happy1171 {name1171 :: String, age1171 :: Int, happy1171 :: Bool} -man1171 :: Happy1171 -man1171 = Happy1171 {name1171 = "Happy", age1171 = 1, happy1171 = True} -test1171 :: String -test1171 = name1171 man1171 - -data Happy1172 = Happy1172 {name1172 :: String, age1172 :: Int, happy1172 :: Bool} -man1172 :: Happy1172 -man1172 = Happy1172 {name1172 = "Happy", age1172 = 1, happy1172 = True} -test1172 :: String -test1172 = name1172 man1172 - -data Happy1173 = Happy1173 {name1173 :: String, age1173 :: Int, happy1173 :: Bool} -man1173 :: Happy1173 -man1173 = Happy1173 {name1173 = "Happy", age1173 = 1, happy1173 = True} -test1173 :: String -test1173 = name1173 man1173 - -data Happy1174 = Happy1174 {name1174 :: String, age1174 :: Int, happy1174 :: Bool} -man1174 :: Happy1174 -man1174 = Happy1174 {name1174 = "Happy", age1174 = 1, happy1174 = True} -test1174 :: String -test1174 = name1174 man1174 - -data Happy1175 = Happy1175 {name1175 :: String, age1175 :: Int, happy1175 :: Bool} -man1175 :: Happy1175 -man1175 = Happy1175 {name1175 = "Happy", age1175 = 1, happy1175 = True} -test1175 :: String -test1175 = name1175 man1175 - -data Happy1176 = Happy1176 {name1176 :: String, age1176 :: Int, happy1176 :: Bool} -man1176 :: Happy1176 -man1176 = Happy1176 {name1176 = "Happy", age1176 = 1, happy1176 = True} -test1176 :: String -test1176 = name1176 man1176 - -data Happy1177 = Happy1177 {name1177 :: String, age1177 :: Int, happy1177 :: Bool} -man1177 :: Happy1177 -man1177 = Happy1177 {name1177 = "Happy", age1177 = 1, happy1177 = True} -test1177 :: String -test1177 = name1177 man1177 - -data Happy1178 = Happy1178 {name1178 :: String, age1178 :: Int, happy1178 :: Bool} -man1178 :: Happy1178 -man1178 = Happy1178 {name1178 = "Happy", age1178 = 1, happy1178 = True} -test1178 :: String -test1178 = name1178 man1178 - -data Happy1179 = Happy1179 {name1179 :: String, age1179 :: Int, happy1179 :: Bool} -man1179 :: Happy1179 -man1179 = Happy1179 {name1179 = "Happy", age1179 = 1, happy1179 = True} -test1179 :: String -test1179 = name1179 man1179 - -data Happy1180 = Happy1180 {name1180 :: String, age1180 :: Int, happy1180 :: Bool} -man1180 :: Happy1180 -man1180 = Happy1180 {name1180 = "Happy", age1180 = 1, happy1180 = True} -test1180 :: String -test1180 = name1180 man1180 - -data Happy1181 = Happy1181 {name1181 :: String, age1181 :: Int, happy1181 :: Bool} -man1181 :: Happy1181 -man1181 = Happy1181 {name1181 = "Happy", age1181 = 1, happy1181 = True} -test1181 :: String -test1181 = name1181 man1181 - -data Happy1182 = Happy1182 {name1182 :: String, age1182 :: Int, happy1182 :: Bool} -man1182 :: Happy1182 -man1182 = Happy1182 {name1182 = "Happy", age1182 = 1, happy1182 = True} -test1182 :: String -test1182 = name1182 man1182 - -data Happy1183 = Happy1183 {name1183 :: String, age1183 :: Int, happy1183 :: Bool} -man1183 :: Happy1183 -man1183 = Happy1183 {name1183 = "Happy", age1183 = 1, happy1183 = True} -test1183 :: String -test1183 = name1183 man1183 - -data Happy1184 = Happy1184 {name1184 :: String, age1184 :: Int, happy1184 :: Bool} -man1184 :: Happy1184 -man1184 = Happy1184 {name1184 = "Happy", age1184 = 1, happy1184 = True} -test1184 :: String -test1184 = name1184 man1184 - -data Happy1185 = Happy1185 {name1185 :: String, age1185 :: Int, happy1185 :: Bool} -man1185 :: Happy1185 -man1185 = Happy1185 {name1185 = "Happy", age1185 = 1, happy1185 = True} -test1185 :: String -test1185 = name1185 man1185 - -data Happy1186 = Happy1186 {name1186 :: String, age1186 :: Int, happy1186 :: Bool} -man1186 :: Happy1186 -man1186 = Happy1186 {name1186 = "Happy", age1186 = 1, happy1186 = True} -test1186 :: String -test1186 = name1186 man1186 - -data Happy1187 = Happy1187 {name1187 :: String, age1187 :: Int, happy1187 :: Bool} -man1187 :: Happy1187 -man1187 = Happy1187 {name1187 = "Happy", age1187 = 1, happy1187 = True} -test1187 :: String -test1187 = name1187 man1187 - -data Happy1188 = Happy1188 {name1188 :: String, age1188 :: Int, happy1188 :: Bool} -man1188 :: Happy1188 -man1188 = Happy1188 {name1188 = "Happy", age1188 = 1, happy1188 = True} -test1188 :: String -test1188 = name1188 man1188 - -data Happy1189 = Happy1189 {name1189 :: String, age1189 :: Int, happy1189 :: Bool} -man1189 :: Happy1189 -man1189 = Happy1189 {name1189 = "Happy", age1189 = 1, happy1189 = True} -test1189 :: String -test1189 = name1189 man1189 - -data Happy1190 = Happy1190 {name1190 :: String, age1190 :: Int, happy1190 :: Bool} -man1190 :: Happy1190 -man1190 = Happy1190 {name1190 = "Happy", age1190 = 1, happy1190 = True} -test1190 :: String -test1190 = name1190 man1190 - -data Happy1191 = Happy1191 {name1191 :: String, age1191 :: Int, happy1191 :: Bool} -man1191 :: Happy1191 -man1191 = Happy1191 {name1191 = "Happy", age1191 = 1, happy1191 = True} -test1191 :: String -test1191 = name1191 man1191 - -data Happy1192 = Happy1192 {name1192 :: String, age1192 :: Int, happy1192 :: Bool} -man1192 :: Happy1192 -man1192 = Happy1192 {name1192 = "Happy", age1192 = 1, happy1192 = True} -test1192 :: String -test1192 = name1192 man1192 - -data Happy1193 = Happy1193 {name1193 :: String, age1193 :: Int, happy1193 :: Bool} -man1193 :: Happy1193 -man1193 = Happy1193 {name1193 = "Happy", age1193 = 1, happy1193 = True} -test1193 :: String -test1193 = name1193 man1193 - -data Happy1194 = Happy1194 {name1194 :: String, age1194 :: Int, happy1194 :: Bool} -man1194 :: Happy1194 -man1194 = Happy1194 {name1194 = "Happy", age1194 = 1, happy1194 = True} -test1194 :: String -test1194 = name1194 man1194 - -data Happy1195 = Happy1195 {name1195 :: String, age1195 :: Int, happy1195 :: Bool} -man1195 :: Happy1195 -man1195 = Happy1195 {name1195 = "Happy", age1195 = 1, happy1195 = True} -test1195 :: String -test1195 = name1195 man1195 - -data Happy1196 = Happy1196 {name1196 :: String, age1196 :: Int, happy1196 :: Bool} -man1196 :: Happy1196 -man1196 = Happy1196 {name1196 = "Happy", age1196 = 1, happy1196 = True} -test1196 :: String -test1196 = name1196 man1196 - -data Happy1197 = Happy1197 {name1197 :: String, age1197 :: Int, happy1197 :: Bool} -man1197 :: Happy1197 -man1197 = Happy1197 {name1197 = "Happy", age1197 = 1, happy1197 = True} -test1197 :: String -test1197 = name1197 man1197 - -data Happy1198 = Happy1198 {name1198 :: String, age1198 :: Int, happy1198 :: Bool} -man1198 :: Happy1198 -man1198 = Happy1198 {name1198 = "Happy", age1198 = 1, happy1198 = True} -test1198 :: String -test1198 = name1198 man1198 - -data Happy1199 = Happy1199 {name1199 :: String, age1199 :: Int, happy1199 :: Bool} -man1199 :: Happy1199 -man1199 = Happy1199 {name1199 = "Happy", age1199 = 1, happy1199 = True} -test1199 :: String -test1199 = name1199 man1199 - -data Happy1200 = Happy1200 {name1200 :: String, age1200 :: Int, happy1200 :: Bool} -man1200 :: Happy1200 -man1200 = Happy1200 {name1200 = "Happy", age1200 = 1, happy1200 = True} -test1200 :: String -test1200 = name1200 man1200 - -data Happy1201 = Happy1201 {name1201 :: String, age1201 :: Int, happy1201 :: Bool} -man1201 :: Happy1201 -man1201 = Happy1201 {name1201 = "Happy", age1201 = 1, happy1201 = True} -test1201 :: String -test1201 = name1201 man1201 - -data Happy1202 = Happy1202 {name1202 :: String, age1202 :: Int, happy1202 :: Bool} -man1202 :: Happy1202 -man1202 = Happy1202 {name1202 = "Happy", age1202 = 1, happy1202 = True} -test1202 :: String -test1202 = name1202 man1202 - -data Happy1203 = Happy1203 {name1203 :: String, age1203 :: Int, happy1203 :: Bool} -man1203 :: Happy1203 -man1203 = Happy1203 {name1203 = "Happy", age1203 = 1, happy1203 = True} -test1203 :: String -test1203 = name1203 man1203 - -data Happy1204 = Happy1204 {name1204 :: String, age1204 :: Int, happy1204 :: Bool} -man1204 :: Happy1204 -man1204 = Happy1204 {name1204 = "Happy", age1204 = 1, happy1204 = True} -test1204 :: String -test1204 = name1204 man1204 - -data Happy1205 = Happy1205 {name1205 :: String, age1205 :: Int, happy1205 :: Bool} -man1205 :: Happy1205 -man1205 = Happy1205 {name1205 = "Happy", age1205 = 1, happy1205 = True} -test1205 :: String -test1205 = name1205 man1205 - -data Happy1206 = Happy1206 {name1206 :: String, age1206 :: Int, happy1206 :: Bool} -man1206 :: Happy1206 -man1206 = Happy1206 {name1206 = "Happy", age1206 = 1, happy1206 = True} -test1206 :: String -test1206 = name1206 man1206 - -data Happy1207 = Happy1207 {name1207 :: String, age1207 :: Int, happy1207 :: Bool} -man1207 :: Happy1207 -man1207 = Happy1207 {name1207 = "Happy", age1207 = 1, happy1207 = True} -test1207 :: String -test1207 = name1207 man1207 - -data Happy1208 = Happy1208 {name1208 :: String, age1208 :: Int, happy1208 :: Bool} -man1208 :: Happy1208 -man1208 = Happy1208 {name1208 = "Happy", age1208 = 1, happy1208 = True} -test1208 :: String -test1208 = name1208 man1208 - -data Happy1209 = Happy1209 {name1209 :: String, age1209 :: Int, happy1209 :: Bool} -man1209 :: Happy1209 -man1209 = Happy1209 {name1209 = "Happy", age1209 = 1, happy1209 = True} -test1209 :: String -test1209 = name1209 man1209 - -data Happy1210 = Happy1210 {name1210 :: String, age1210 :: Int, happy1210 :: Bool} -man1210 :: Happy1210 -man1210 = Happy1210 {name1210 = "Happy", age1210 = 1, happy1210 = True} -test1210 :: String -test1210 = name1210 man1210 - -data Happy1211 = Happy1211 {name1211 :: String, age1211 :: Int, happy1211 :: Bool} -man1211 :: Happy1211 -man1211 = Happy1211 {name1211 = "Happy", age1211 = 1, happy1211 = True} -test1211 :: String -test1211 = name1211 man1211 - -data Happy1212 = Happy1212 {name1212 :: String, age1212 :: Int, happy1212 :: Bool} -man1212 :: Happy1212 -man1212 = Happy1212 {name1212 = "Happy", age1212 = 1, happy1212 = True} -test1212 :: String -test1212 = name1212 man1212 - -data Happy1213 = Happy1213 {name1213 :: String, age1213 :: Int, happy1213 :: Bool} -man1213 :: Happy1213 -man1213 = Happy1213 {name1213 = "Happy", age1213 = 1, happy1213 = True} -test1213 :: String -test1213 = name1213 man1213 - -data Happy1214 = Happy1214 {name1214 :: String, age1214 :: Int, happy1214 :: Bool} -man1214 :: Happy1214 -man1214 = Happy1214 {name1214 = "Happy", age1214 = 1, happy1214 = True} -test1214 :: String -test1214 = name1214 man1214 - -data Happy1215 = Happy1215 {name1215 :: String, age1215 :: Int, happy1215 :: Bool} -man1215 :: Happy1215 -man1215 = Happy1215 {name1215 = "Happy", age1215 = 1, happy1215 = True} -test1215 :: String -test1215 = name1215 man1215 - -data Happy1216 = Happy1216 {name1216 :: String, age1216 :: Int, happy1216 :: Bool} -man1216 :: Happy1216 -man1216 = Happy1216 {name1216 = "Happy", age1216 = 1, happy1216 = True} -test1216 :: String -test1216 = name1216 man1216 - -data Happy1217 = Happy1217 {name1217 :: String, age1217 :: Int, happy1217 :: Bool} -man1217 :: Happy1217 -man1217 = Happy1217 {name1217 = "Happy", age1217 = 1, happy1217 = True} -test1217 :: String -test1217 = name1217 man1217 - -data Happy1218 = Happy1218 {name1218 :: String, age1218 :: Int, happy1218 :: Bool} -man1218 :: Happy1218 -man1218 = Happy1218 {name1218 = "Happy", age1218 = 1, happy1218 = True} -test1218 :: String -test1218 = name1218 man1218 - -data Happy1219 = Happy1219 {name1219 :: String, age1219 :: Int, happy1219 :: Bool} -man1219 :: Happy1219 -man1219 = Happy1219 {name1219 = "Happy", age1219 = 1, happy1219 = True} -test1219 :: String -test1219 = name1219 man1219 - -data Happy1220 = Happy1220 {name1220 :: String, age1220 :: Int, happy1220 :: Bool} -man1220 :: Happy1220 -man1220 = Happy1220 {name1220 = "Happy", age1220 = 1, happy1220 = True} -test1220 :: String -test1220 = name1220 man1220 - -data Happy1221 = Happy1221 {name1221 :: String, age1221 :: Int, happy1221 :: Bool} -man1221 :: Happy1221 -man1221 = Happy1221 {name1221 = "Happy", age1221 = 1, happy1221 = True} -test1221 :: String -test1221 = name1221 man1221 - -data Happy1222 = Happy1222 {name1222 :: String, age1222 :: Int, happy1222 :: Bool} -man1222 :: Happy1222 -man1222 = Happy1222 {name1222 = "Happy", age1222 = 1, happy1222 = True} -test1222 :: String -test1222 = name1222 man1222 - -data Happy1223 = Happy1223 {name1223 :: String, age1223 :: Int, happy1223 :: Bool} -man1223 :: Happy1223 -man1223 = Happy1223 {name1223 = "Happy", age1223 = 1, happy1223 = True} -test1223 :: String -test1223 = name1223 man1223 - -data Happy1224 = Happy1224 {name1224 :: String, age1224 :: Int, happy1224 :: Bool} -man1224 :: Happy1224 -man1224 = Happy1224 {name1224 = "Happy", age1224 = 1, happy1224 = True} -test1224 :: String -test1224 = name1224 man1224 - -data Happy1225 = Happy1225 {name1225 :: String, age1225 :: Int, happy1225 :: Bool} -man1225 :: Happy1225 -man1225 = Happy1225 {name1225 = "Happy", age1225 = 1, happy1225 = True} -test1225 :: String -test1225 = name1225 man1225 - -data Happy1226 = Happy1226 {name1226 :: String, age1226 :: Int, happy1226 :: Bool} -man1226 :: Happy1226 -man1226 = Happy1226 {name1226 = "Happy", age1226 = 1, happy1226 = True} -test1226 :: String -test1226 = name1226 man1226 - -data Happy1227 = Happy1227 {name1227 :: String, age1227 :: Int, happy1227 :: Bool} -man1227 :: Happy1227 -man1227 = Happy1227 {name1227 = "Happy", age1227 = 1, happy1227 = True} -test1227 :: String -test1227 = name1227 man1227 - -data Happy1228 = Happy1228 {name1228 :: String, age1228 :: Int, happy1228 :: Bool} -man1228 :: Happy1228 -man1228 = Happy1228 {name1228 = "Happy", age1228 = 1, happy1228 = True} -test1228 :: String -test1228 = name1228 man1228 - -data Happy1229 = Happy1229 {name1229 :: String, age1229 :: Int, happy1229 :: Bool} -man1229 :: Happy1229 -man1229 = Happy1229 {name1229 = "Happy", age1229 = 1, happy1229 = True} -test1229 :: String -test1229 = name1229 man1229 - -data Happy1230 = Happy1230 {name1230 :: String, age1230 :: Int, happy1230 :: Bool} -man1230 :: Happy1230 -man1230 = Happy1230 {name1230 = "Happy", age1230 = 1, happy1230 = True} -test1230 :: String -test1230 = name1230 man1230 - -data Happy1231 = Happy1231 {name1231 :: String, age1231 :: Int, happy1231 :: Bool} -man1231 :: Happy1231 -man1231 = Happy1231 {name1231 = "Happy", age1231 = 1, happy1231 = True} -test1231 :: String -test1231 = name1231 man1231 - -data Happy1232 = Happy1232 {name1232 :: String, age1232 :: Int, happy1232 :: Bool} -man1232 :: Happy1232 -man1232 = Happy1232 {name1232 = "Happy", age1232 = 1, happy1232 = True} -test1232 :: String -test1232 = name1232 man1232 - -data Happy1233 = Happy1233 {name1233 :: String, age1233 :: Int, happy1233 :: Bool} -man1233 :: Happy1233 -man1233 = Happy1233 {name1233 = "Happy", age1233 = 1, happy1233 = True} -test1233 :: String -test1233 = name1233 man1233 - -data Happy1234 = Happy1234 {name1234 :: String, age1234 :: Int, happy1234 :: Bool} -man1234 :: Happy1234 -man1234 = Happy1234 {name1234 = "Happy", age1234 = 1, happy1234 = True} -test1234 :: String -test1234 = name1234 man1234 - -data Happy1235 = Happy1235 {name1235 :: String, age1235 :: Int, happy1235 :: Bool} -man1235 :: Happy1235 -man1235 = Happy1235 {name1235 = "Happy", age1235 = 1, happy1235 = True} -test1235 :: String -test1235 = name1235 man1235 - -data Happy1236 = Happy1236 {name1236 :: String, age1236 :: Int, happy1236 :: Bool} -man1236 :: Happy1236 -man1236 = Happy1236 {name1236 = "Happy", age1236 = 1, happy1236 = True} -test1236 :: String -test1236 = name1236 man1236 - -data Happy1237 = Happy1237 {name1237 :: String, age1237 :: Int, happy1237 :: Bool} -man1237 :: Happy1237 -man1237 = Happy1237 {name1237 = "Happy", age1237 = 1, happy1237 = True} -test1237 :: String -test1237 = name1237 man1237 - -data Happy1238 = Happy1238 {name1238 :: String, age1238 :: Int, happy1238 :: Bool} -man1238 :: Happy1238 -man1238 = Happy1238 {name1238 = "Happy", age1238 = 1, happy1238 = True} -test1238 :: String -test1238 = name1238 man1238 - -data Happy1239 = Happy1239 {name1239 :: String, age1239 :: Int, happy1239 :: Bool} -man1239 :: Happy1239 -man1239 = Happy1239 {name1239 = "Happy", age1239 = 1, happy1239 = True} -test1239 :: String -test1239 = name1239 man1239 - -data Happy1240 = Happy1240 {name1240 :: String, age1240 :: Int, happy1240 :: Bool} -man1240 :: Happy1240 -man1240 = Happy1240 {name1240 = "Happy", age1240 = 1, happy1240 = True} -test1240 :: String -test1240 = name1240 man1240 - -data Happy1241 = Happy1241 {name1241 :: String, age1241 :: Int, happy1241 :: Bool} -man1241 :: Happy1241 -man1241 = Happy1241 {name1241 = "Happy", age1241 = 1, happy1241 = True} -test1241 :: String -test1241 = name1241 man1241 - -data Happy1242 = Happy1242 {name1242 :: String, age1242 :: Int, happy1242 :: Bool} -man1242 :: Happy1242 -man1242 = Happy1242 {name1242 = "Happy", age1242 = 1, happy1242 = True} -test1242 :: String -test1242 = name1242 man1242 - -data Happy1243 = Happy1243 {name1243 :: String, age1243 :: Int, happy1243 :: Bool} -man1243 :: Happy1243 -man1243 = Happy1243 {name1243 = "Happy", age1243 = 1, happy1243 = True} -test1243 :: String -test1243 = name1243 man1243 - -data Happy1244 = Happy1244 {name1244 :: String, age1244 :: Int, happy1244 :: Bool} -man1244 :: Happy1244 -man1244 = Happy1244 {name1244 = "Happy", age1244 = 1, happy1244 = True} -test1244 :: String -test1244 = name1244 man1244 - -data Happy1245 = Happy1245 {name1245 :: String, age1245 :: Int, happy1245 :: Bool} -man1245 :: Happy1245 -man1245 = Happy1245 {name1245 = "Happy", age1245 = 1, happy1245 = True} -test1245 :: String -test1245 = name1245 man1245 - -data Happy1246 = Happy1246 {name1246 :: String, age1246 :: Int, happy1246 :: Bool} -man1246 :: Happy1246 -man1246 = Happy1246 {name1246 = "Happy", age1246 = 1, happy1246 = True} -test1246 :: String -test1246 = name1246 man1246 - -data Happy1247 = Happy1247 {name1247 :: String, age1247 :: Int, happy1247 :: Bool} -man1247 :: Happy1247 -man1247 = Happy1247 {name1247 = "Happy", age1247 = 1, happy1247 = True} -test1247 :: String -test1247 = name1247 man1247 - -data Happy1248 = Happy1248 {name1248 :: String, age1248 :: Int, happy1248 :: Bool} -man1248 :: Happy1248 -man1248 = Happy1248 {name1248 = "Happy", age1248 = 1, happy1248 = True} -test1248 :: String -test1248 = name1248 man1248 - -data Happy1249 = Happy1249 {name1249 :: String, age1249 :: Int, happy1249 :: Bool} -man1249 :: Happy1249 -man1249 = Happy1249 {name1249 = "Happy", age1249 = 1, happy1249 = True} -test1249 :: String -test1249 = name1249 man1249 - -data Happy1250 = Happy1250 {name1250 :: String, age1250 :: Int, happy1250 :: Bool} -man1250 :: Happy1250 -man1250 = Happy1250 {name1250 = "Happy", age1250 = 1, happy1250 = True} -test1250 :: String -test1250 = name1250 man1250 - -data Happy1251 = Happy1251 {name1251 :: String, age1251 :: Int, happy1251 :: Bool} -man1251 :: Happy1251 -man1251 = Happy1251 {name1251 = "Happy", age1251 = 1, happy1251 = True} -test1251 :: String -test1251 = name1251 man1251 - -data Happy1252 = Happy1252 {name1252 :: String, age1252 :: Int, happy1252 :: Bool} -man1252 :: Happy1252 -man1252 = Happy1252 {name1252 = "Happy", age1252 = 1, happy1252 = True} -test1252 :: String -test1252 = name1252 man1252 - -data Happy1253 = Happy1253 {name1253 :: String, age1253 :: Int, happy1253 :: Bool} -man1253 :: Happy1253 -man1253 = Happy1253 {name1253 = "Happy", age1253 = 1, happy1253 = True} -test1253 :: String -test1253 = name1253 man1253 - -data Happy1254 = Happy1254 {name1254 :: String, age1254 :: Int, happy1254 :: Bool} -man1254 :: Happy1254 -man1254 = Happy1254 {name1254 = "Happy", age1254 = 1, happy1254 = True} -test1254 :: String -test1254 = name1254 man1254 - -data Happy1255 = Happy1255 {name1255 :: String, age1255 :: Int, happy1255 :: Bool} -man1255 :: Happy1255 -man1255 = Happy1255 {name1255 = "Happy", age1255 = 1, happy1255 = True} -test1255 :: String -test1255 = name1255 man1255 - -data Happy1256 = Happy1256 {name1256 :: String, age1256 :: Int, happy1256 :: Bool} -man1256 :: Happy1256 -man1256 = Happy1256 {name1256 = "Happy", age1256 = 1, happy1256 = True} -test1256 :: String -test1256 = name1256 man1256 - -data Happy1257 = Happy1257 {name1257 :: String, age1257 :: Int, happy1257 :: Bool} -man1257 :: Happy1257 -man1257 = Happy1257 {name1257 = "Happy", age1257 = 1, happy1257 = True} -test1257 :: String -test1257 = name1257 man1257 - -data Happy1258 = Happy1258 {name1258 :: String, age1258 :: Int, happy1258 :: Bool} -man1258 :: Happy1258 -man1258 = Happy1258 {name1258 = "Happy", age1258 = 1, happy1258 = True} -test1258 :: String -test1258 = name1258 man1258 - -data Happy1259 = Happy1259 {name1259 :: String, age1259 :: Int, happy1259 :: Bool} -man1259 :: Happy1259 -man1259 = Happy1259 {name1259 = "Happy", age1259 = 1, happy1259 = True} -test1259 :: String -test1259 = name1259 man1259 - -data Happy1260 = Happy1260 {name1260 :: String, age1260 :: Int, happy1260 :: Bool} -man1260 :: Happy1260 -man1260 = Happy1260 {name1260 = "Happy", age1260 = 1, happy1260 = True} -test1260 :: String -test1260 = name1260 man1260 - -data Happy1261 = Happy1261 {name1261 :: String, age1261 :: Int, happy1261 :: Bool} -man1261 :: Happy1261 -man1261 = Happy1261 {name1261 = "Happy", age1261 = 1, happy1261 = True} -test1261 :: String -test1261 = name1261 man1261 - -data Happy1262 = Happy1262 {name1262 :: String, age1262 :: Int, happy1262 :: Bool} -man1262 :: Happy1262 -man1262 = Happy1262 {name1262 = "Happy", age1262 = 1, happy1262 = True} -test1262 :: String -test1262 = name1262 man1262 - -data Happy1263 = Happy1263 {name1263 :: String, age1263 :: Int, happy1263 :: Bool} -man1263 :: Happy1263 -man1263 = Happy1263 {name1263 = "Happy", age1263 = 1, happy1263 = True} -test1263 :: String -test1263 = name1263 man1263 - -data Happy1264 = Happy1264 {name1264 :: String, age1264 :: Int, happy1264 :: Bool} -man1264 :: Happy1264 -man1264 = Happy1264 {name1264 = "Happy", age1264 = 1, happy1264 = True} -test1264 :: String -test1264 = name1264 man1264 - -data Happy1265 = Happy1265 {name1265 :: String, age1265 :: Int, happy1265 :: Bool} -man1265 :: Happy1265 -man1265 = Happy1265 {name1265 = "Happy", age1265 = 1, happy1265 = True} -test1265 :: String -test1265 = name1265 man1265 - -data Happy1266 = Happy1266 {name1266 :: String, age1266 :: Int, happy1266 :: Bool} -man1266 :: Happy1266 -man1266 = Happy1266 {name1266 = "Happy", age1266 = 1, happy1266 = True} -test1266 :: String -test1266 = name1266 man1266 - -data Happy1267 = Happy1267 {name1267 :: String, age1267 :: Int, happy1267 :: Bool} -man1267 :: Happy1267 -man1267 = Happy1267 {name1267 = "Happy", age1267 = 1, happy1267 = True} -test1267 :: String -test1267 = name1267 man1267 - -data Happy1268 = Happy1268 {name1268 :: String, age1268 :: Int, happy1268 :: Bool} -man1268 :: Happy1268 -man1268 = Happy1268 {name1268 = "Happy", age1268 = 1, happy1268 = True} -test1268 :: String -test1268 = name1268 man1268 - -data Happy1269 = Happy1269 {name1269 :: String, age1269 :: Int, happy1269 :: Bool} -man1269 :: Happy1269 -man1269 = Happy1269 {name1269 = "Happy", age1269 = 1, happy1269 = True} -test1269 :: String -test1269 = name1269 man1269 - -data Happy1270 = Happy1270 {name1270 :: String, age1270 :: Int, happy1270 :: Bool} -man1270 :: Happy1270 -man1270 = Happy1270 {name1270 = "Happy", age1270 = 1, happy1270 = True} -test1270 :: String -test1270 = name1270 man1270 - -data Happy1271 = Happy1271 {name1271 :: String, age1271 :: Int, happy1271 :: Bool} -man1271 :: Happy1271 -man1271 = Happy1271 {name1271 = "Happy", age1271 = 1, happy1271 = True} -test1271 :: String -test1271 = name1271 man1271 - -data Happy1272 = Happy1272 {name1272 :: String, age1272 :: Int, happy1272 :: Bool} -man1272 :: Happy1272 -man1272 = Happy1272 {name1272 = "Happy", age1272 = 1, happy1272 = True} -test1272 :: String -test1272 = name1272 man1272 - -data Happy1273 = Happy1273 {name1273 :: String, age1273 :: Int, happy1273 :: Bool} -man1273 :: Happy1273 -man1273 = Happy1273 {name1273 = "Happy", age1273 = 1, happy1273 = True} -test1273 :: String -test1273 = name1273 man1273 - -data Happy1274 = Happy1274 {name1274 :: String, age1274 :: Int, happy1274 :: Bool} -man1274 :: Happy1274 -man1274 = Happy1274 {name1274 = "Happy", age1274 = 1, happy1274 = True} -test1274 :: String -test1274 = name1274 man1274 - -data Happy1275 = Happy1275 {name1275 :: String, age1275 :: Int, happy1275 :: Bool} -man1275 :: Happy1275 -man1275 = Happy1275 {name1275 = "Happy", age1275 = 1, happy1275 = True} -test1275 :: String -test1275 = name1275 man1275 - -data Happy1276 = Happy1276 {name1276 :: String, age1276 :: Int, happy1276 :: Bool} -man1276 :: Happy1276 -man1276 = Happy1276 {name1276 = "Happy", age1276 = 1, happy1276 = True} -test1276 :: String -test1276 = name1276 man1276 - -data Happy1277 = Happy1277 {name1277 :: String, age1277 :: Int, happy1277 :: Bool} -man1277 :: Happy1277 -man1277 = Happy1277 {name1277 = "Happy", age1277 = 1, happy1277 = True} -test1277 :: String -test1277 = name1277 man1277 - -data Happy1278 = Happy1278 {name1278 :: String, age1278 :: Int, happy1278 :: Bool} -man1278 :: Happy1278 -man1278 = Happy1278 {name1278 = "Happy", age1278 = 1, happy1278 = True} -test1278 :: String -test1278 = name1278 man1278 - -data Happy1279 = Happy1279 {name1279 :: String, age1279 :: Int, happy1279 :: Bool} -man1279 :: Happy1279 -man1279 = Happy1279 {name1279 = "Happy", age1279 = 1, happy1279 = True} -test1279 :: String -test1279 = name1279 man1279 - -data Happy1280 = Happy1280 {name1280 :: String, age1280 :: Int, happy1280 :: Bool} -man1280 :: Happy1280 -man1280 = Happy1280 {name1280 = "Happy", age1280 = 1, happy1280 = True} -test1280 :: String -test1280 = name1280 man1280 - -data Happy1281 = Happy1281 {name1281 :: String, age1281 :: Int, happy1281 :: Bool} -man1281 :: Happy1281 -man1281 = Happy1281 {name1281 = "Happy", age1281 = 1, happy1281 = True} -test1281 :: String -test1281 = name1281 man1281 - -data Happy1282 = Happy1282 {name1282 :: String, age1282 :: Int, happy1282 :: Bool} -man1282 :: Happy1282 -man1282 = Happy1282 {name1282 = "Happy", age1282 = 1, happy1282 = True} -test1282 :: String -test1282 = name1282 man1282 - -data Happy1283 = Happy1283 {name1283 :: String, age1283 :: Int, happy1283 :: Bool} -man1283 :: Happy1283 -man1283 = Happy1283 {name1283 = "Happy", age1283 = 1, happy1283 = True} -test1283 :: String -test1283 = name1283 man1283 - -data Happy1284 = Happy1284 {name1284 :: String, age1284 :: Int, happy1284 :: Bool} -man1284 :: Happy1284 -man1284 = Happy1284 {name1284 = "Happy", age1284 = 1, happy1284 = True} -test1284 :: String -test1284 = name1284 man1284 - -data Happy1285 = Happy1285 {name1285 :: String, age1285 :: Int, happy1285 :: Bool} -man1285 :: Happy1285 -man1285 = Happy1285 {name1285 = "Happy", age1285 = 1, happy1285 = True} -test1285 :: String -test1285 = name1285 man1285 - -data Happy1286 = Happy1286 {name1286 :: String, age1286 :: Int, happy1286 :: Bool} -man1286 :: Happy1286 -man1286 = Happy1286 {name1286 = "Happy", age1286 = 1, happy1286 = True} -test1286 :: String -test1286 = name1286 man1286 - -data Happy1287 = Happy1287 {name1287 :: String, age1287 :: Int, happy1287 :: Bool} -man1287 :: Happy1287 -man1287 = Happy1287 {name1287 = "Happy", age1287 = 1, happy1287 = True} -test1287 :: String -test1287 = name1287 man1287 - -data Happy1288 = Happy1288 {name1288 :: String, age1288 :: Int, happy1288 :: Bool} -man1288 :: Happy1288 -man1288 = Happy1288 {name1288 = "Happy", age1288 = 1, happy1288 = True} -test1288 :: String -test1288 = name1288 man1288 - -data Happy1289 = Happy1289 {name1289 :: String, age1289 :: Int, happy1289 :: Bool} -man1289 :: Happy1289 -man1289 = Happy1289 {name1289 = "Happy", age1289 = 1, happy1289 = True} -test1289 :: String -test1289 = name1289 man1289 - -data Happy1290 = Happy1290 {name1290 :: String, age1290 :: Int, happy1290 :: Bool} -man1290 :: Happy1290 -man1290 = Happy1290 {name1290 = "Happy", age1290 = 1, happy1290 = True} -test1290 :: String -test1290 = name1290 man1290 - -data Happy1291 = Happy1291 {name1291 :: String, age1291 :: Int, happy1291 :: Bool} -man1291 :: Happy1291 -man1291 = Happy1291 {name1291 = "Happy", age1291 = 1, happy1291 = True} -test1291 :: String -test1291 = name1291 man1291 - -data Happy1292 = Happy1292 {name1292 :: String, age1292 :: Int, happy1292 :: Bool} -man1292 :: Happy1292 -man1292 = Happy1292 {name1292 = "Happy", age1292 = 1, happy1292 = True} -test1292 :: String -test1292 = name1292 man1292 - -data Happy1293 = Happy1293 {name1293 :: String, age1293 :: Int, happy1293 :: Bool} -man1293 :: Happy1293 -man1293 = Happy1293 {name1293 = "Happy", age1293 = 1, happy1293 = True} -test1293 :: String -test1293 = name1293 man1293 - -data Happy1294 = Happy1294 {name1294 :: String, age1294 :: Int, happy1294 :: Bool} -man1294 :: Happy1294 -man1294 = Happy1294 {name1294 = "Happy", age1294 = 1, happy1294 = True} -test1294 :: String -test1294 = name1294 man1294 - -data Happy1295 = Happy1295 {name1295 :: String, age1295 :: Int, happy1295 :: Bool} -man1295 :: Happy1295 -man1295 = Happy1295 {name1295 = "Happy", age1295 = 1, happy1295 = True} -test1295 :: String -test1295 = name1295 man1295 - -data Happy1296 = Happy1296 {name1296 :: String, age1296 :: Int, happy1296 :: Bool} -man1296 :: Happy1296 -man1296 = Happy1296 {name1296 = "Happy", age1296 = 1, happy1296 = True} -test1296 :: String -test1296 = name1296 man1296 - -data Happy1297 = Happy1297 {name1297 :: String, age1297 :: Int, happy1297 :: Bool} -man1297 :: Happy1297 -man1297 = Happy1297 {name1297 = "Happy", age1297 = 1, happy1297 = True} -test1297 :: String -test1297 = name1297 man1297 - -data Happy1298 = Happy1298 {name1298 :: String, age1298 :: Int, happy1298 :: Bool} -man1298 :: Happy1298 -man1298 = Happy1298 {name1298 = "Happy", age1298 = 1, happy1298 = True} -test1298 :: String -test1298 = man1298.name1298 - -data Happy1299 = Happy1299 {name1299 :: String, age1299 :: Int, happy1299 :: Bool} -man1299 :: Happy1299 -man1299 = Happy1299 {name1299 = "Happy", age1299 = 1, happy1299 = True} -test1299 :: String -test1299 = name1299 man1299 diff --git a/plugins/hls-overloaded-record-dot-plugin/test/testdata/Benchmark.hs b/plugins/hls-overloaded-record-dot-plugin/test/testdata/Benchmark.hs deleted file mode 100644 index 5cb49507a8..0000000000 --- a/plugins/hls-overloaded-record-dot-plugin/test/testdata/Benchmark.hs +++ /dev/null @@ -1,1804 +0,0 @@ - -main :: IO () -main = do - putStrLn test1000 - -data Happy1000 = Happy1000 {name1000 :: String, age1000 :: Int, happy1000 :: Bool} -man1000 :: Happy1000 -man1000 = Happy1000 {name1000 = "Happy", age1000 = 1, happy1000 = True} -test1000 :: String -test1000 = name1000 man1000 - -data Happy1001 = Happy1001 {name1001 :: String, age1001 :: Int, happy1001 :: Bool} -man1001 :: Happy1001 -man1001 = Happy1001 {name1001 = "Happy", age1001 = 1, happy1001 = True} -test1001 :: String -test1001 = name1001 man1001 - -data Happy1002 = Happy1002 {name1002 :: String, age1002 :: Int, happy1002 :: Bool} -man1002 :: Happy1002 -man1002 = Happy1002 {name1002 = "Happy", age1002 = 1, happy1002 = True} -test1002 :: String -test1002 = name1002 man1002 - -data Happy1003 = Happy1003 {name1003 :: String, age1003 :: Int, happy1003 :: Bool} -man1003 :: Happy1003 -man1003 = Happy1003 {name1003 = "Happy", age1003 = 1, happy1003 = True} -test1003 :: String -test1003 = name1003 man1003 - -data Happy1004 = Happy1004 {name1004 :: String, age1004 :: Int, happy1004 :: Bool} -man1004 :: Happy1004 -man1004 = Happy1004 {name1004 = "Happy", age1004 = 1, happy1004 = True} -test1004 :: String -test1004 = name1004 man1004 - -data Happy1005 = Happy1005 {name1005 :: String, age1005 :: Int, happy1005 :: Bool} -man1005 :: Happy1005 -man1005 = Happy1005 {name1005 = "Happy", age1005 = 1, happy1005 = True} -test1005 :: String -test1005 = name1005 man1005 - -data Happy1006 = Happy1006 {name1006 :: String, age1006 :: Int, happy1006 :: Bool} -man1006 :: Happy1006 -man1006 = Happy1006 {name1006 = "Happy", age1006 = 1, happy1006 = True} -test1006 :: String -test1006 = name1006 man1006 - -data Happy1007 = Happy1007 {name1007 :: String, age1007 :: Int, happy1007 :: Bool} -man1007 :: Happy1007 -man1007 = Happy1007 {name1007 = "Happy", age1007 = 1, happy1007 = True} -test1007 :: String -test1007 = name1007 man1007 - -data Happy1008 = Happy1008 {name1008 :: String, age1008 :: Int, happy1008 :: Bool} -man1008 :: Happy1008 -man1008 = Happy1008 {name1008 = "Happy", age1008 = 1, happy1008 = True} -test1008 :: String -test1008 = name1008 man1008 - -data Happy1009 = Happy1009 {name1009 :: String, age1009 :: Int, happy1009 :: Bool} -man1009 :: Happy1009 -man1009 = Happy1009 {name1009 = "Happy", age1009 = 1, happy1009 = True} -test1009 :: String -test1009 = name1009 man1009 - -data Happy1010 = Happy1010 {name1010 :: String, age1010 :: Int, happy1010 :: Bool} -man1010 :: Happy1010 -man1010 = Happy1010 {name1010 = "Happy", age1010 = 1, happy1010 = True} -test1010 :: String -test1010 = name1010 man1010 - -data Happy1011 = Happy1011 {name1011 :: String, age1011 :: Int, happy1011 :: Bool} -man1011 :: Happy1011 -man1011 = Happy1011 {name1011 = "Happy", age1011 = 1, happy1011 = True} -test1011 :: String -test1011 = name1011 man1011 - -data Happy1012 = Happy1012 {name1012 :: String, age1012 :: Int, happy1012 :: Bool} -man1012 :: Happy1012 -man1012 = Happy1012 {name1012 = "Happy", age1012 = 1, happy1012 = True} -test1012 :: String -test1012 = name1012 man1012 - -data Happy1013 = Happy1013 {name1013 :: String, age1013 :: Int, happy1013 :: Bool} -man1013 :: Happy1013 -man1013 = Happy1013 {name1013 = "Happy", age1013 = 1, happy1013 = True} -test1013 :: String -test1013 = name1013 man1013 - -data Happy1014 = Happy1014 {name1014 :: String, age1014 :: Int, happy1014 :: Bool} -man1014 :: Happy1014 -man1014 = Happy1014 {name1014 = "Happy", age1014 = 1, happy1014 = True} -test1014 :: String -test1014 = name1014 man1014 - -data Happy1015 = Happy1015 {name1015 :: String, age1015 :: Int, happy1015 :: Bool} -man1015 :: Happy1015 -man1015 = Happy1015 {name1015 = "Happy", age1015 = 1, happy1015 = True} -test1015 :: String -test1015 = name1015 man1015 - -data Happy1016 = Happy1016 {name1016 :: String, age1016 :: Int, happy1016 :: Bool} -man1016 :: Happy1016 -man1016 = Happy1016 {name1016 = "Happy", age1016 = 1, happy1016 = True} -test1016 :: String -test1016 = name1016 man1016 - -data Happy1017 = Happy1017 {name1017 :: String, age1017 :: Int, happy1017 :: Bool} -man1017 :: Happy1017 -man1017 = Happy1017 {name1017 = "Happy", age1017 = 1, happy1017 = True} -test1017 :: String -test1017 = name1017 man1017 - -data Happy1018 = Happy1018 {name1018 :: String, age1018 :: Int, happy1018 :: Bool} -man1018 :: Happy1018 -man1018 = Happy1018 {name1018 = "Happy", age1018 = 1, happy1018 = True} -test1018 :: String -test1018 = name1018 man1018 - -data Happy1019 = Happy1019 {name1019 :: String, age1019 :: Int, happy1019 :: Bool} -man1019 :: Happy1019 -man1019 = Happy1019 {name1019 = "Happy", age1019 = 1, happy1019 = True} -test1019 :: String -test1019 = name1019 man1019 - -data Happy1020 = Happy1020 {name1020 :: String, age1020 :: Int, happy1020 :: Bool} -man1020 :: Happy1020 -man1020 = Happy1020 {name1020 = "Happy", age1020 = 1, happy1020 = True} -test1020 :: String -test1020 = name1020 man1020 - -data Happy1021 = Happy1021 {name1021 :: String, age1021 :: Int, happy1021 :: Bool} -man1021 :: Happy1021 -man1021 = Happy1021 {name1021 = "Happy", age1021 = 1, happy1021 = True} -test1021 :: String -test1021 = name1021 man1021 - -data Happy1022 = Happy1022 {name1022 :: String, age1022 :: Int, happy1022 :: Bool} -man1022 :: Happy1022 -man1022 = Happy1022 {name1022 = "Happy", age1022 = 1, happy1022 = True} -test1022 :: String -test1022 = name1022 man1022 - -data Happy1023 = Happy1023 {name1023 :: String, age1023 :: Int, happy1023 :: Bool} -man1023 :: Happy1023 -man1023 = Happy1023 {name1023 = "Happy", age1023 = 1, happy1023 = True} -test1023 :: String -test1023 = name1023 man1023 - -data Happy1024 = Happy1024 {name1024 :: String, age1024 :: Int, happy1024 :: Bool} -man1024 :: Happy1024 -man1024 = Happy1024 {name1024 = "Happy", age1024 = 1, happy1024 = True} -test1024 :: String -test1024 = name1024 man1024 - -data Happy1025 = Happy1025 {name1025 :: String, age1025 :: Int, happy1025 :: Bool} -man1025 :: Happy1025 -man1025 = Happy1025 {name1025 = "Happy", age1025 = 1, happy1025 = True} -test1025 :: String -test1025 = name1025 man1025 - -data Happy1026 = Happy1026 {name1026 :: String, age1026 :: Int, happy1026 :: Bool} -man1026 :: Happy1026 -man1026 = Happy1026 {name1026 = "Happy", age1026 = 1, happy1026 = True} -test1026 :: String -test1026 = name1026 man1026 - -data Happy1027 = Happy1027 {name1027 :: String, age1027 :: Int, happy1027 :: Bool} -man1027 :: Happy1027 -man1027 = Happy1027 {name1027 = "Happy", age1027 = 1, happy1027 = True} -test1027 :: String -test1027 = name1027 man1027 - -data Happy1028 = Happy1028 {name1028 :: String, age1028 :: Int, happy1028 :: Bool} -man1028 :: Happy1028 -man1028 = Happy1028 {name1028 = "Happy", age1028 = 1, happy1028 = True} -test1028 :: String -test1028 = name1028 man1028 - -data Happy1029 = Happy1029 {name1029 :: String, age1029 :: Int, happy1029 :: Bool} -man1029 :: Happy1029 -man1029 = Happy1029 {name1029 = "Happy", age1029 = 1, happy1029 = True} -test1029 :: String -test1029 = name1029 man1029 - -data Happy1030 = Happy1030 {name1030 :: String, age1030 :: Int, happy1030 :: Bool} -man1030 :: Happy1030 -man1030 = Happy1030 {name1030 = "Happy", age1030 = 1, happy1030 = True} -test1030 :: String -test1030 = name1030 man1030 - -data Happy1031 = Happy1031 {name1031 :: String, age1031 :: Int, happy1031 :: Bool} -man1031 :: Happy1031 -man1031 = Happy1031 {name1031 = "Happy", age1031 = 1, happy1031 = True} -test1031 :: String -test1031 = name1031 man1031 - -data Happy1032 = Happy1032 {name1032 :: String, age1032 :: Int, happy1032 :: Bool} -man1032 :: Happy1032 -man1032 = Happy1032 {name1032 = "Happy", age1032 = 1, happy1032 = True} -test1032 :: String -test1032 = name1032 man1032 - -data Happy1033 = Happy1033 {name1033 :: String, age1033 :: Int, happy1033 :: Bool} -man1033 :: Happy1033 -man1033 = Happy1033 {name1033 = "Happy", age1033 = 1, happy1033 = True} -test1033 :: String -test1033 = name1033 man1033 - -data Happy1034 = Happy1034 {name1034 :: String, age1034 :: Int, happy1034 :: Bool} -man1034 :: Happy1034 -man1034 = Happy1034 {name1034 = "Happy", age1034 = 1, happy1034 = True} -test1034 :: String -test1034 = name1034 man1034 - -data Happy1035 = Happy1035 {name1035 :: String, age1035 :: Int, happy1035 :: Bool} -man1035 :: Happy1035 -man1035 = Happy1035 {name1035 = "Happy", age1035 = 1, happy1035 = True} -test1035 :: String -test1035 = name1035 man1035 - -data Happy1036 = Happy1036 {name1036 :: String, age1036 :: Int, happy1036 :: Bool} -man1036 :: Happy1036 -man1036 = Happy1036 {name1036 = "Happy", age1036 = 1, happy1036 = True} -test1036 :: String -test1036 = name1036 man1036 - -data Happy1037 = Happy1037 {name1037 :: String, age1037 :: Int, happy1037 :: Bool} -man1037 :: Happy1037 -man1037 = Happy1037 {name1037 = "Happy", age1037 = 1, happy1037 = True} -test1037 :: String -test1037 = name1037 man1037 - -data Happy1038 = Happy1038 {name1038 :: String, age1038 :: Int, happy1038 :: Bool} -man1038 :: Happy1038 -man1038 = Happy1038 {name1038 = "Happy", age1038 = 1, happy1038 = True} -test1038 :: String -test1038 = name1038 man1038 - -data Happy1039 = Happy1039 {name1039 :: String, age1039 :: Int, happy1039 :: Bool} -man1039 :: Happy1039 -man1039 = Happy1039 {name1039 = "Happy", age1039 = 1, happy1039 = True} -test1039 :: String -test1039 = name1039 man1039 - -data Happy1040 = Happy1040 {name1040 :: String, age1040 :: Int, happy1040 :: Bool} -man1040 :: Happy1040 -man1040 = Happy1040 {name1040 = "Happy", age1040 = 1, happy1040 = True} -test1040 :: String -test1040 = name1040 man1040 - -data Happy1041 = Happy1041 {name1041 :: String, age1041 :: Int, happy1041 :: Bool} -man1041 :: Happy1041 -man1041 = Happy1041 {name1041 = "Happy", age1041 = 1, happy1041 = True} -test1041 :: String -test1041 = name1041 man1041 - -data Happy1042 = Happy1042 {name1042 :: String, age1042 :: Int, happy1042 :: Bool} -man1042 :: Happy1042 -man1042 = Happy1042 {name1042 = "Happy", age1042 = 1, happy1042 = True} -test1042 :: String -test1042 = name1042 man1042 - -data Happy1043 = Happy1043 {name1043 :: String, age1043 :: Int, happy1043 :: Bool} -man1043 :: Happy1043 -man1043 = Happy1043 {name1043 = "Happy", age1043 = 1, happy1043 = True} -test1043 :: String -test1043 = name1043 man1043 - -data Happy1044 = Happy1044 {name1044 :: String, age1044 :: Int, happy1044 :: Bool} -man1044 :: Happy1044 -man1044 = Happy1044 {name1044 = "Happy", age1044 = 1, happy1044 = True} -test1044 :: String -test1044 = name1044 man1044 - -data Happy1045 = Happy1045 {name1045 :: String, age1045 :: Int, happy1045 :: Bool} -man1045 :: Happy1045 -man1045 = Happy1045 {name1045 = "Happy", age1045 = 1, happy1045 = True} -test1045 :: String -test1045 = name1045 man1045 - -data Happy1046 = Happy1046 {name1046 :: String, age1046 :: Int, happy1046 :: Bool} -man1046 :: Happy1046 -man1046 = Happy1046 {name1046 = "Happy", age1046 = 1, happy1046 = True} -test1046 :: String -test1046 = name1046 man1046 - -data Happy1047 = Happy1047 {name1047 :: String, age1047 :: Int, happy1047 :: Bool} -man1047 :: Happy1047 -man1047 = Happy1047 {name1047 = "Happy", age1047 = 1, happy1047 = True} -test1047 :: String -test1047 = name1047 man1047 - -data Happy1048 = Happy1048 {name1048 :: String, age1048 :: Int, happy1048 :: Bool} -man1048 :: Happy1048 -man1048 = Happy1048 {name1048 = "Happy", age1048 = 1, happy1048 = True} -test1048 :: String -test1048 = name1048 man1048 - -data Happy1049 = Happy1049 {name1049 :: String, age1049 :: Int, happy1049 :: Bool} -man1049 :: Happy1049 -man1049 = Happy1049 {name1049 = "Happy", age1049 = 1, happy1049 = True} -test1049 :: String -test1049 = name1049 man1049 - -data Happy1050 = Happy1050 {name1050 :: String, age1050 :: Int, happy1050 :: Bool} -man1050 :: Happy1050 -man1050 = Happy1050 {name1050 = "Happy", age1050 = 1, happy1050 = True} -test1050 :: String -test1050 = name1050 man1050 - -data Happy1051 = Happy1051 {name1051 :: String, age1051 :: Int, happy1051 :: Bool} -man1051 :: Happy1051 -man1051 = Happy1051 {name1051 = "Happy", age1051 = 1, happy1051 = True} -test1051 :: String -test1051 = name1051 man1051 - -data Happy1052 = Happy1052 {name1052 :: String, age1052 :: Int, happy1052 :: Bool} -man1052 :: Happy1052 -man1052 = Happy1052 {name1052 = "Happy", age1052 = 1, happy1052 = True} -test1052 :: String -test1052 = name1052 man1052 - -data Happy1053 = Happy1053 {name1053 :: String, age1053 :: Int, happy1053 :: Bool} -man1053 :: Happy1053 -man1053 = Happy1053 {name1053 = "Happy", age1053 = 1, happy1053 = True} -test1053 :: String -test1053 = name1053 man1053 - -data Happy1054 = Happy1054 {name1054 :: String, age1054 :: Int, happy1054 :: Bool} -man1054 :: Happy1054 -man1054 = Happy1054 {name1054 = "Happy", age1054 = 1, happy1054 = True} -test1054 :: String -test1054 = name1054 man1054 - -data Happy1055 = Happy1055 {name1055 :: String, age1055 :: Int, happy1055 :: Bool} -man1055 :: Happy1055 -man1055 = Happy1055 {name1055 = "Happy", age1055 = 1, happy1055 = True} -test1055 :: String -test1055 = name1055 man1055 - -data Happy1056 = Happy1056 {name1056 :: String, age1056 :: Int, happy1056 :: Bool} -man1056 :: Happy1056 -man1056 = Happy1056 {name1056 = "Happy", age1056 = 1, happy1056 = True} -test1056 :: String -test1056 = name1056 man1056 - -data Happy1057 = Happy1057 {name1057 :: String, age1057 :: Int, happy1057 :: Bool} -man1057 :: Happy1057 -man1057 = Happy1057 {name1057 = "Happy", age1057 = 1, happy1057 = True} -test1057 :: String -test1057 = name1057 man1057 - -data Happy1058 = Happy1058 {name1058 :: String, age1058 :: Int, happy1058 :: Bool} -man1058 :: Happy1058 -man1058 = Happy1058 {name1058 = "Happy", age1058 = 1, happy1058 = True} -test1058 :: String -test1058 = name1058 man1058 - -data Happy1059 = Happy1059 {name1059 :: String, age1059 :: Int, happy1059 :: Bool} -man1059 :: Happy1059 -man1059 = Happy1059 {name1059 = "Happy", age1059 = 1, happy1059 = True} -test1059 :: String -test1059 = name1059 man1059 - -data Happy1060 = Happy1060 {name1060 :: String, age1060 :: Int, happy1060 :: Bool} -man1060 :: Happy1060 -man1060 = Happy1060 {name1060 = "Happy", age1060 = 1, happy1060 = True} -test1060 :: String -test1060 = name1060 man1060 - -data Happy1061 = Happy1061 {name1061 :: String, age1061 :: Int, happy1061 :: Bool} -man1061 :: Happy1061 -man1061 = Happy1061 {name1061 = "Happy", age1061 = 1, happy1061 = True} -test1061 :: String -test1061 = name1061 man1061 - -data Happy1062 = Happy1062 {name1062 :: String, age1062 :: Int, happy1062 :: Bool} -man1062 :: Happy1062 -man1062 = Happy1062 {name1062 = "Happy", age1062 = 1, happy1062 = True} -test1062 :: String -test1062 = name1062 man1062 - -data Happy1063 = Happy1063 {name1063 :: String, age1063 :: Int, happy1063 :: Bool} -man1063 :: Happy1063 -man1063 = Happy1063 {name1063 = "Happy", age1063 = 1, happy1063 = True} -test1063 :: String -test1063 = name1063 man1063 - -data Happy1064 = Happy1064 {name1064 :: String, age1064 :: Int, happy1064 :: Bool} -man1064 :: Happy1064 -man1064 = Happy1064 {name1064 = "Happy", age1064 = 1, happy1064 = True} -test1064 :: String -test1064 = name1064 man1064 - -data Happy1065 = Happy1065 {name1065 :: String, age1065 :: Int, happy1065 :: Bool} -man1065 :: Happy1065 -man1065 = Happy1065 {name1065 = "Happy", age1065 = 1, happy1065 = True} -test1065 :: String -test1065 = name1065 man1065 - -data Happy1066 = Happy1066 {name1066 :: String, age1066 :: Int, happy1066 :: Bool} -man1066 :: Happy1066 -man1066 = Happy1066 {name1066 = "Happy", age1066 = 1, happy1066 = True} -test1066 :: String -test1066 = name1066 man1066 - -data Happy1067 = Happy1067 {name1067 :: String, age1067 :: Int, happy1067 :: Bool} -man1067 :: Happy1067 -man1067 = Happy1067 {name1067 = "Happy", age1067 = 1, happy1067 = True} -test1067 :: String -test1067 = name1067 man1067 - -data Happy1068 = Happy1068 {name1068 :: String, age1068 :: Int, happy1068 :: Bool} -man1068 :: Happy1068 -man1068 = Happy1068 {name1068 = "Happy", age1068 = 1, happy1068 = True} -test1068 :: String -test1068 = name1068 man1068 - -data Happy1069 = Happy1069 {name1069 :: String, age1069 :: Int, happy1069 :: Bool} -man1069 :: Happy1069 -man1069 = Happy1069 {name1069 = "Happy", age1069 = 1, happy1069 = True} -test1069 :: String -test1069 = name1069 man1069 - -data Happy1070 = Happy1070 {name1070 :: String, age1070 :: Int, happy1070 :: Bool} -man1070 :: Happy1070 -man1070 = Happy1070 {name1070 = "Happy", age1070 = 1, happy1070 = True} -test1070 :: String -test1070 = name1070 man1070 - -data Happy1071 = Happy1071 {name1071 :: String, age1071 :: Int, happy1071 :: Bool} -man1071 :: Happy1071 -man1071 = Happy1071 {name1071 = "Happy", age1071 = 1, happy1071 = True} -test1071 :: String -test1071 = name1071 man1071 - -data Happy1072 = Happy1072 {name1072 :: String, age1072 :: Int, happy1072 :: Bool} -man1072 :: Happy1072 -man1072 = Happy1072 {name1072 = "Happy", age1072 = 1, happy1072 = True} -test1072 :: String -test1072 = name1072 man1072 - -data Happy1073 = Happy1073 {name1073 :: String, age1073 :: Int, happy1073 :: Bool} -man1073 :: Happy1073 -man1073 = Happy1073 {name1073 = "Happy", age1073 = 1, happy1073 = True} -test1073 :: String -test1073 = name1073 man1073 - -data Happy1074 = Happy1074 {name1074 :: String, age1074 :: Int, happy1074 :: Bool} -man1074 :: Happy1074 -man1074 = Happy1074 {name1074 = "Happy", age1074 = 1, happy1074 = True} -test1074 :: String -test1074 = name1074 man1074 - -data Happy1075 = Happy1075 {name1075 :: String, age1075 :: Int, happy1075 :: Bool} -man1075 :: Happy1075 -man1075 = Happy1075 {name1075 = "Happy", age1075 = 1, happy1075 = True} -test1075 :: String -test1075 = name1075 man1075 - -data Happy1076 = Happy1076 {name1076 :: String, age1076 :: Int, happy1076 :: Bool} -man1076 :: Happy1076 -man1076 = Happy1076 {name1076 = "Happy", age1076 = 1, happy1076 = True} -test1076 :: String -test1076 = name1076 man1076 - -data Happy1077 = Happy1077 {name1077 :: String, age1077 :: Int, happy1077 :: Bool} -man1077 :: Happy1077 -man1077 = Happy1077 {name1077 = "Happy", age1077 = 1, happy1077 = True} -test1077 :: String -test1077 = name1077 man1077 - -data Happy1078 = Happy1078 {name1078 :: String, age1078 :: Int, happy1078 :: Bool} -man1078 :: Happy1078 -man1078 = Happy1078 {name1078 = "Happy", age1078 = 1, happy1078 = True} -test1078 :: String -test1078 = name1078 man1078 - -data Happy1079 = Happy1079 {name1079 :: String, age1079 :: Int, happy1079 :: Bool} -man1079 :: Happy1079 -man1079 = Happy1079 {name1079 = "Happy", age1079 = 1, happy1079 = True} -test1079 :: String -test1079 = name1079 man1079 - -data Happy1080 = Happy1080 {name1080 :: String, age1080 :: Int, happy1080 :: Bool} -man1080 :: Happy1080 -man1080 = Happy1080 {name1080 = "Happy", age1080 = 1, happy1080 = True} -test1080 :: String -test1080 = name1080 man1080 - -data Happy1081 = Happy1081 {name1081 :: String, age1081 :: Int, happy1081 :: Bool} -man1081 :: Happy1081 -man1081 = Happy1081 {name1081 = "Happy", age1081 = 1, happy1081 = True} -test1081 :: String -test1081 = name1081 man1081 - -data Happy1082 = Happy1082 {name1082 :: String, age1082 :: Int, happy1082 :: Bool} -man1082 :: Happy1082 -man1082 = Happy1082 {name1082 = "Happy", age1082 = 1, happy1082 = True} -test1082 :: String -test1082 = name1082 man1082 - -data Happy1083 = Happy1083 {name1083 :: String, age1083 :: Int, happy1083 :: Bool} -man1083 :: Happy1083 -man1083 = Happy1083 {name1083 = "Happy", age1083 = 1, happy1083 = True} -test1083 :: String -test1083 = name1083 man1083 - -data Happy1084 = Happy1084 {name1084 :: String, age1084 :: Int, happy1084 :: Bool} -man1084 :: Happy1084 -man1084 = Happy1084 {name1084 = "Happy", age1084 = 1, happy1084 = True} -test1084 :: String -test1084 = name1084 man1084 - -data Happy1085 = Happy1085 {name1085 :: String, age1085 :: Int, happy1085 :: Bool} -man1085 :: Happy1085 -man1085 = Happy1085 {name1085 = "Happy", age1085 = 1, happy1085 = True} -test1085 :: String -test1085 = name1085 man1085 - -data Happy1086 = Happy1086 {name1086 :: String, age1086 :: Int, happy1086 :: Bool} -man1086 :: Happy1086 -man1086 = Happy1086 {name1086 = "Happy", age1086 = 1, happy1086 = True} -test1086 :: String -test1086 = name1086 man1086 - -data Happy1087 = Happy1087 {name1087 :: String, age1087 :: Int, happy1087 :: Bool} -man1087 :: Happy1087 -man1087 = Happy1087 {name1087 = "Happy", age1087 = 1, happy1087 = True} -test1087 :: String -test1087 = name1087 man1087 - -data Happy1088 = Happy1088 {name1088 :: String, age1088 :: Int, happy1088 :: Bool} -man1088 :: Happy1088 -man1088 = Happy1088 {name1088 = "Happy", age1088 = 1, happy1088 = True} -test1088 :: String -test1088 = name1088 man1088 - -data Happy1089 = Happy1089 {name1089 :: String, age1089 :: Int, happy1089 :: Bool} -man1089 :: Happy1089 -man1089 = Happy1089 {name1089 = "Happy", age1089 = 1, happy1089 = True} -test1089 :: String -test1089 = name1089 man1089 - -data Happy1090 = Happy1090 {name1090 :: String, age1090 :: Int, happy1090 :: Bool} -man1090 :: Happy1090 -man1090 = Happy1090 {name1090 = "Happy", age1090 = 1, happy1090 = True} -test1090 :: String -test1090 = name1090 man1090 - -data Happy1091 = Happy1091 {name1091 :: String, age1091 :: Int, happy1091 :: Bool} -man1091 :: Happy1091 -man1091 = Happy1091 {name1091 = "Happy", age1091 = 1, happy1091 = True} -test1091 :: String -test1091 = name1091 man1091 - -data Happy1092 = Happy1092 {name1092 :: String, age1092 :: Int, happy1092 :: Bool} -man1092 :: Happy1092 -man1092 = Happy1092 {name1092 = "Happy", age1092 = 1, happy1092 = True} -test1092 :: String -test1092 = name1092 man1092 - -data Happy1093 = Happy1093 {name1093 :: String, age1093 :: Int, happy1093 :: Bool} -man1093 :: Happy1093 -man1093 = Happy1093 {name1093 = "Happy", age1093 = 1, happy1093 = True} -test1093 :: String -test1093 = name1093 man1093 - -data Happy1094 = Happy1094 {name1094 :: String, age1094 :: Int, happy1094 :: Bool} -man1094 :: Happy1094 -man1094 = Happy1094 {name1094 = "Happy", age1094 = 1, happy1094 = True} -test1094 :: String -test1094 = name1094 man1094 - -data Happy1095 = Happy1095 {name1095 :: String, age1095 :: Int, happy1095 :: Bool} -man1095 :: Happy1095 -man1095 = Happy1095 {name1095 = "Happy", age1095 = 1, happy1095 = True} -test1095 :: String -test1095 = name1095 man1095 - -data Happy1096 = Happy1096 {name1096 :: String, age1096 :: Int, happy1096 :: Bool} -man1096 :: Happy1096 -man1096 = Happy1096 {name1096 = "Happy", age1096 = 1, happy1096 = True} -test1096 :: String -test1096 = name1096 man1096 - -data Happy1097 = Happy1097 {name1097 :: String, age1097 :: Int, happy1097 :: Bool} -man1097 :: Happy1097 -man1097 = Happy1097 {name1097 = "Happy", age1097 = 1, happy1097 = True} -test1097 :: String -test1097 = name1097 man1097 - -data Happy1098 = Happy1098 {name1098 :: String, age1098 :: Int, happy1098 :: Bool} -man1098 :: Happy1098 -man1098 = Happy1098 {name1098 = "Happy", age1098 = 1, happy1098 = True} -test1098 :: String -test1098 = name1098 man1098 - -data Happy1099 = Happy1099 {name1099 :: String, age1099 :: Int, happy1099 :: Bool} -man1099 :: Happy1099 -man1099 = Happy1099 {name1099 = "Happy", age1099 = 1, happy1099 = True} -test1099 :: String -test1099 = name1099 man1099 - -data Happy1100 = Happy1100 {name1100 :: String, age1100 :: Int, happy1100 :: Bool} -man1100 :: Happy1100 -man1100 = Happy1100 {name1100 = "Happy", age1100 = 1, happy1100 = True} -test1100 :: String -test1100 = name1100 man1100 - -data Happy1101 = Happy1101 {name1101 :: String, age1101 :: Int, happy1101 :: Bool} -man1101 :: Happy1101 -man1101 = Happy1101 {name1101 = "Happy", age1101 = 1, happy1101 = True} -test1101 :: String -test1101 = name1101 man1101 - -data Happy1102 = Happy1102 {name1102 :: String, age1102 :: Int, happy1102 :: Bool} -man1102 :: Happy1102 -man1102 = Happy1102 {name1102 = "Happy", age1102 = 1, happy1102 = True} -test1102 :: String -test1102 = name1102 man1102 - -data Happy1103 = Happy1103 {name1103 :: String, age1103 :: Int, happy1103 :: Bool} -man1103 :: Happy1103 -man1103 = Happy1103 {name1103 = "Happy", age1103 = 1, happy1103 = True} -test1103 :: String -test1103 = name1103 man1103 - -data Happy1104 = Happy1104 {name1104 :: String, age1104 :: Int, happy1104 :: Bool} -man1104 :: Happy1104 -man1104 = Happy1104 {name1104 = "Happy", age1104 = 1, happy1104 = True} -test1104 :: String -test1104 = name1104 man1104 - -data Happy1105 = Happy1105 {name1105 :: String, age1105 :: Int, happy1105 :: Bool} -man1105 :: Happy1105 -man1105 = Happy1105 {name1105 = "Happy", age1105 = 1, happy1105 = True} -test1105 :: String -test1105 = name1105 man1105 - -data Happy1106 = Happy1106 {name1106 :: String, age1106 :: Int, happy1106 :: Bool} -man1106 :: Happy1106 -man1106 = Happy1106 {name1106 = "Happy", age1106 = 1, happy1106 = True} -test1106 :: String -test1106 = name1106 man1106 - -data Happy1107 = Happy1107 {name1107 :: String, age1107 :: Int, happy1107 :: Bool} -man1107 :: Happy1107 -man1107 = Happy1107 {name1107 = "Happy", age1107 = 1, happy1107 = True} -test1107 :: String -test1107 = name1107 man1107 - -data Happy1108 = Happy1108 {name1108 :: String, age1108 :: Int, happy1108 :: Bool} -man1108 :: Happy1108 -man1108 = Happy1108 {name1108 = "Happy", age1108 = 1, happy1108 = True} -test1108 :: String -test1108 = name1108 man1108 - -data Happy1109 = Happy1109 {name1109 :: String, age1109 :: Int, happy1109 :: Bool} -man1109 :: Happy1109 -man1109 = Happy1109 {name1109 = "Happy", age1109 = 1, happy1109 = True} -test1109 :: String -test1109 = name1109 man1109 - -data Happy1110 = Happy1110 {name1110 :: String, age1110 :: Int, happy1110 :: Bool} -man1110 :: Happy1110 -man1110 = Happy1110 {name1110 = "Happy", age1110 = 1, happy1110 = True} -test1110 :: String -test1110 = name1110 man1110 - -data Happy1111 = Happy1111 {name1111 :: String, age1111 :: Int, happy1111 :: Bool} -man1111 :: Happy1111 -man1111 = Happy1111 {name1111 = "Happy", age1111 = 1, happy1111 = True} -test1111 :: String -test1111 = name1111 man1111 - -data Happy1112 = Happy1112 {name1112 :: String, age1112 :: Int, happy1112 :: Bool} -man1112 :: Happy1112 -man1112 = Happy1112 {name1112 = "Happy", age1112 = 1, happy1112 = True} -test1112 :: String -test1112 = name1112 man1112 - -data Happy1113 = Happy1113 {name1113 :: String, age1113 :: Int, happy1113 :: Bool} -man1113 :: Happy1113 -man1113 = Happy1113 {name1113 = "Happy", age1113 = 1, happy1113 = True} -test1113 :: String -test1113 = name1113 man1113 - -data Happy1114 = Happy1114 {name1114 :: String, age1114 :: Int, happy1114 :: Bool} -man1114 :: Happy1114 -man1114 = Happy1114 {name1114 = "Happy", age1114 = 1, happy1114 = True} -test1114 :: String -test1114 = name1114 man1114 - -data Happy1115 = Happy1115 {name1115 :: String, age1115 :: Int, happy1115 :: Bool} -man1115 :: Happy1115 -man1115 = Happy1115 {name1115 = "Happy", age1115 = 1, happy1115 = True} -test1115 :: String -test1115 = name1115 man1115 - -data Happy1116 = Happy1116 {name1116 :: String, age1116 :: Int, happy1116 :: Bool} -man1116 :: Happy1116 -man1116 = Happy1116 {name1116 = "Happy", age1116 = 1, happy1116 = True} -test1116 :: String -test1116 = name1116 man1116 - -data Happy1117 = Happy1117 {name1117 :: String, age1117 :: Int, happy1117 :: Bool} -man1117 :: Happy1117 -man1117 = Happy1117 {name1117 = "Happy", age1117 = 1, happy1117 = True} -test1117 :: String -test1117 = name1117 man1117 - -data Happy1118 = Happy1118 {name1118 :: String, age1118 :: Int, happy1118 :: Bool} -man1118 :: Happy1118 -man1118 = Happy1118 {name1118 = "Happy", age1118 = 1, happy1118 = True} -test1118 :: String -test1118 = name1118 man1118 - -data Happy1119 = Happy1119 {name1119 :: String, age1119 :: Int, happy1119 :: Bool} -man1119 :: Happy1119 -man1119 = Happy1119 {name1119 = "Happy", age1119 = 1, happy1119 = True} -test1119 :: String -test1119 = name1119 man1119 - -data Happy1120 = Happy1120 {name1120 :: String, age1120 :: Int, happy1120 :: Bool} -man1120 :: Happy1120 -man1120 = Happy1120 {name1120 = "Happy", age1120 = 1, happy1120 = True} -test1120 :: String -test1120 = name1120 man1120 - -data Happy1121 = Happy1121 {name1121 :: String, age1121 :: Int, happy1121 :: Bool} -man1121 :: Happy1121 -man1121 = Happy1121 {name1121 = "Happy", age1121 = 1, happy1121 = True} -test1121 :: String -test1121 = name1121 man1121 - -data Happy1122 = Happy1122 {name1122 :: String, age1122 :: Int, happy1122 :: Bool} -man1122 :: Happy1122 -man1122 = Happy1122 {name1122 = "Happy", age1122 = 1, happy1122 = True} -test1122 :: String -test1122 = name1122 man1122 - -data Happy1123 = Happy1123 {name1123 :: String, age1123 :: Int, happy1123 :: Bool} -man1123 :: Happy1123 -man1123 = Happy1123 {name1123 = "Happy", age1123 = 1, happy1123 = True} -test1123 :: String -test1123 = name1123 man1123 - -data Happy1124 = Happy1124 {name1124 :: String, age1124 :: Int, happy1124 :: Bool} -man1124 :: Happy1124 -man1124 = Happy1124 {name1124 = "Happy", age1124 = 1, happy1124 = True} -test1124 :: String -test1124 = name1124 man1124 - -data Happy1125 = Happy1125 {name1125 :: String, age1125 :: Int, happy1125 :: Bool} -man1125 :: Happy1125 -man1125 = Happy1125 {name1125 = "Happy", age1125 = 1, happy1125 = True} -test1125 :: String -test1125 = name1125 man1125 - -data Happy1126 = Happy1126 {name1126 :: String, age1126 :: Int, happy1126 :: Bool} -man1126 :: Happy1126 -man1126 = Happy1126 {name1126 = "Happy", age1126 = 1, happy1126 = True} -test1126 :: String -test1126 = name1126 man1126 - -data Happy1127 = Happy1127 {name1127 :: String, age1127 :: Int, happy1127 :: Bool} -man1127 :: Happy1127 -man1127 = Happy1127 {name1127 = "Happy", age1127 = 1, happy1127 = True} -test1127 :: String -test1127 = name1127 man1127 - -data Happy1128 = Happy1128 {name1128 :: String, age1128 :: Int, happy1128 :: Bool} -man1128 :: Happy1128 -man1128 = Happy1128 {name1128 = "Happy", age1128 = 1, happy1128 = True} -test1128 :: String -test1128 = name1128 man1128 - -data Happy1129 = Happy1129 {name1129 :: String, age1129 :: Int, happy1129 :: Bool} -man1129 :: Happy1129 -man1129 = Happy1129 {name1129 = "Happy", age1129 = 1, happy1129 = True} -test1129 :: String -test1129 = name1129 man1129 - -data Happy1130 = Happy1130 {name1130 :: String, age1130 :: Int, happy1130 :: Bool} -man1130 :: Happy1130 -man1130 = Happy1130 {name1130 = "Happy", age1130 = 1, happy1130 = True} -test1130 :: String -test1130 = name1130 man1130 - -data Happy1131 = Happy1131 {name1131 :: String, age1131 :: Int, happy1131 :: Bool} -man1131 :: Happy1131 -man1131 = Happy1131 {name1131 = "Happy", age1131 = 1, happy1131 = True} -test1131 :: String -test1131 = name1131 man1131 - -data Happy1132 = Happy1132 {name1132 :: String, age1132 :: Int, happy1132 :: Bool} -man1132 :: Happy1132 -man1132 = Happy1132 {name1132 = "Happy", age1132 = 1, happy1132 = True} -test1132 :: String -test1132 = name1132 man1132 - -data Happy1133 = Happy1133 {name1133 :: String, age1133 :: Int, happy1133 :: Bool} -man1133 :: Happy1133 -man1133 = Happy1133 {name1133 = "Happy", age1133 = 1, happy1133 = True} -test1133 :: String -test1133 = name1133 man1133 - -data Happy1134 = Happy1134 {name1134 :: String, age1134 :: Int, happy1134 :: Bool} -man1134 :: Happy1134 -man1134 = Happy1134 {name1134 = "Happy", age1134 = 1, happy1134 = True} -test1134 :: String -test1134 = name1134 man1134 - -data Happy1135 = Happy1135 {name1135 :: String, age1135 :: Int, happy1135 :: Bool} -man1135 :: Happy1135 -man1135 = Happy1135 {name1135 = "Happy", age1135 = 1, happy1135 = True} -test1135 :: String -test1135 = name1135 man1135 - -data Happy1136 = Happy1136 {name1136 :: String, age1136 :: Int, happy1136 :: Bool} -man1136 :: Happy1136 -man1136 = Happy1136 {name1136 = "Happy", age1136 = 1, happy1136 = True} -test1136 :: String -test1136 = name1136 man1136 - -data Happy1137 = Happy1137 {name1137 :: String, age1137 :: Int, happy1137 :: Bool} -man1137 :: Happy1137 -man1137 = Happy1137 {name1137 = "Happy", age1137 = 1, happy1137 = True} -test1137 :: String -test1137 = name1137 man1137 - -data Happy1138 = Happy1138 {name1138 :: String, age1138 :: Int, happy1138 :: Bool} -man1138 :: Happy1138 -man1138 = Happy1138 {name1138 = "Happy", age1138 = 1, happy1138 = True} -test1138 :: String -test1138 = name1138 man1138 - -data Happy1139 = Happy1139 {name1139 :: String, age1139 :: Int, happy1139 :: Bool} -man1139 :: Happy1139 -man1139 = Happy1139 {name1139 = "Happy", age1139 = 1, happy1139 = True} -test1139 :: String -test1139 = name1139 man1139 - -data Happy1140 = Happy1140 {name1140 :: String, age1140 :: Int, happy1140 :: Bool} -man1140 :: Happy1140 -man1140 = Happy1140 {name1140 = "Happy", age1140 = 1, happy1140 = True} -test1140 :: String -test1140 = name1140 man1140 - -data Happy1141 = Happy1141 {name1141 :: String, age1141 :: Int, happy1141 :: Bool} -man1141 :: Happy1141 -man1141 = Happy1141 {name1141 = "Happy", age1141 = 1, happy1141 = True} -test1141 :: String -test1141 = name1141 man1141 - -data Happy1142 = Happy1142 {name1142 :: String, age1142 :: Int, happy1142 :: Bool} -man1142 :: Happy1142 -man1142 = Happy1142 {name1142 = "Happy", age1142 = 1, happy1142 = True} -test1142 :: String -test1142 = name1142 man1142 - -data Happy1143 = Happy1143 {name1143 :: String, age1143 :: Int, happy1143 :: Bool} -man1143 :: Happy1143 -man1143 = Happy1143 {name1143 = "Happy", age1143 = 1, happy1143 = True} -test1143 :: String -test1143 = name1143 man1143 - -data Happy1144 = Happy1144 {name1144 :: String, age1144 :: Int, happy1144 :: Bool} -man1144 :: Happy1144 -man1144 = Happy1144 {name1144 = "Happy", age1144 = 1, happy1144 = True} -test1144 :: String -test1144 = name1144 man1144 - -data Happy1145 = Happy1145 {name1145 :: String, age1145 :: Int, happy1145 :: Bool} -man1145 :: Happy1145 -man1145 = Happy1145 {name1145 = "Happy", age1145 = 1, happy1145 = True} -test1145 :: String -test1145 = name1145 man1145 - -data Happy1146 = Happy1146 {name1146 :: String, age1146 :: Int, happy1146 :: Bool} -man1146 :: Happy1146 -man1146 = Happy1146 {name1146 = "Happy", age1146 = 1, happy1146 = True} -test1146 :: String -test1146 = name1146 man1146 - -data Happy1147 = Happy1147 {name1147 :: String, age1147 :: Int, happy1147 :: Bool} -man1147 :: Happy1147 -man1147 = Happy1147 {name1147 = "Happy", age1147 = 1, happy1147 = True} -test1147 :: String -test1147 = name1147 man1147 - -data Happy1148 = Happy1148 {name1148 :: String, age1148 :: Int, happy1148 :: Bool} -man1148 :: Happy1148 -man1148 = Happy1148 {name1148 = "Happy", age1148 = 1, happy1148 = True} -test1148 :: String -test1148 = name1148 man1148 - -data Happy1149 = Happy1149 {name1149 :: String, age1149 :: Int, happy1149 :: Bool} -man1149 :: Happy1149 -man1149 = Happy1149 {name1149 = "Happy", age1149 = 1, happy1149 = True} -test1149 :: String -test1149 = name1149 man1149 - -data Happy1150 = Happy1150 {name1150 :: String, age1150 :: Int, happy1150 :: Bool} -man1150 :: Happy1150 -man1150 = Happy1150 {name1150 = "Happy", age1150 = 1, happy1150 = True} -test1150 :: String -test1150 = name1150 man1150 - -data Happy1151 = Happy1151 {name1151 :: String, age1151 :: Int, happy1151 :: Bool} -man1151 :: Happy1151 -man1151 = Happy1151 {name1151 = "Happy", age1151 = 1, happy1151 = True} -test1151 :: String -test1151 = name1151 man1151 - -data Happy1152 = Happy1152 {name1152 :: String, age1152 :: Int, happy1152 :: Bool} -man1152 :: Happy1152 -man1152 = Happy1152 {name1152 = "Happy", age1152 = 1, happy1152 = True} -test1152 :: String -test1152 = name1152 man1152 - -data Happy1153 = Happy1153 {name1153 :: String, age1153 :: Int, happy1153 :: Bool} -man1153 :: Happy1153 -man1153 = Happy1153 {name1153 = "Happy", age1153 = 1, happy1153 = True} -test1153 :: String -test1153 = name1153 man1153 - -data Happy1154 = Happy1154 {name1154 :: String, age1154 :: Int, happy1154 :: Bool} -man1154 :: Happy1154 -man1154 = Happy1154 {name1154 = "Happy", age1154 = 1, happy1154 = True} -test1154 :: String -test1154 = name1154 man1154 - -data Happy1155 = Happy1155 {name1155 :: String, age1155 :: Int, happy1155 :: Bool} -man1155 :: Happy1155 -man1155 = Happy1155 {name1155 = "Happy", age1155 = 1, happy1155 = True} -test1155 :: String -test1155 = name1155 man1155 - -data Happy1156 = Happy1156 {name1156 :: String, age1156 :: Int, happy1156 :: Bool} -man1156 :: Happy1156 -man1156 = Happy1156 {name1156 = "Happy", age1156 = 1, happy1156 = True} -test1156 :: String -test1156 = name1156 man1156 - -data Happy1157 = Happy1157 {name1157 :: String, age1157 :: Int, happy1157 :: Bool} -man1157 :: Happy1157 -man1157 = Happy1157 {name1157 = "Happy", age1157 = 1, happy1157 = True} -test1157 :: String -test1157 = name1157 man1157 - -data Happy1158 = Happy1158 {name1158 :: String, age1158 :: Int, happy1158 :: Bool} -man1158 :: Happy1158 -man1158 = Happy1158 {name1158 = "Happy", age1158 = 1, happy1158 = True} -test1158 :: String -test1158 = name1158 man1158 - -data Happy1159 = Happy1159 {name1159 :: String, age1159 :: Int, happy1159 :: Bool} -man1159 :: Happy1159 -man1159 = Happy1159 {name1159 = "Happy", age1159 = 1, happy1159 = True} -test1159 :: String -test1159 = name1159 man1159 - -data Happy1160 = Happy1160 {name1160 :: String, age1160 :: Int, happy1160 :: Bool} -man1160 :: Happy1160 -man1160 = Happy1160 {name1160 = "Happy", age1160 = 1, happy1160 = True} -test1160 :: String -test1160 = name1160 man1160 - -data Happy1161 = Happy1161 {name1161 :: String, age1161 :: Int, happy1161 :: Bool} -man1161 :: Happy1161 -man1161 = Happy1161 {name1161 = "Happy", age1161 = 1, happy1161 = True} -test1161 :: String -test1161 = name1161 man1161 - -data Happy1162 = Happy1162 {name1162 :: String, age1162 :: Int, happy1162 :: Bool} -man1162 :: Happy1162 -man1162 = Happy1162 {name1162 = "Happy", age1162 = 1, happy1162 = True} -test1162 :: String -test1162 = name1162 man1162 - -data Happy1163 = Happy1163 {name1163 :: String, age1163 :: Int, happy1163 :: Bool} -man1163 :: Happy1163 -man1163 = Happy1163 {name1163 = "Happy", age1163 = 1, happy1163 = True} -test1163 :: String -test1163 = name1163 man1163 - -data Happy1164 = Happy1164 {name1164 :: String, age1164 :: Int, happy1164 :: Bool} -man1164 :: Happy1164 -man1164 = Happy1164 {name1164 = "Happy", age1164 = 1, happy1164 = True} -test1164 :: String -test1164 = name1164 man1164 - -data Happy1165 = Happy1165 {name1165 :: String, age1165 :: Int, happy1165 :: Bool} -man1165 :: Happy1165 -man1165 = Happy1165 {name1165 = "Happy", age1165 = 1, happy1165 = True} -test1165 :: String -test1165 = name1165 man1165 - -data Happy1166 = Happy1166 {name1166 :: String, age1166 :: Int, happy1166 :: Bool} -man1166 :: Happy1166 -man1166 = Happy1166 {name1166 = "Happy", age1166 = 1, happy1166 = True} -test1166 :: String -test1166 = name1166 man1166 - -data Happy1167 = Happy1167 {name1167 :: String, age1167 :: Int, happy1167 :: Bool} -man1167 :: Happy1167 -man1167 = Happy1167 {name1167 = "Happy", age1167 = 1, happy1167 = True} -test1167 :: String -test1167 = name1167 man1167 - -data Happy1168 = Happy1168 {name1168 :: String, age1168 :: Int, happy1168 :: Bool} -man1168 :: Happy1168 -man1168 = Happy1168 {name1168 = "Happy", age1168 = 1, happy1168 = True} -test1168 :: String -test1168 = name1168 man1168 - -data Happy1169 = Happy1169 {name1169 :: String, age1169 :: Int, happy1169 :: Bool} -man1169 :: Happy1169 -man1169 = Happy1169 {name1169 = "Happy", age1169 = 1, happy1169 = True} -test1169 :: String -test1169 = name1169 man1169 - -data Happy1170 = Happy1170 {name1170 :: String, age1170 :: Int, happy1170 :: Bool} -man1170 :: Happy1170 -man1170 = Happy1170 {name1170 = "Happy", age1170 = 1, happy1170 = True} -test1170 :: String -test1170 = name1170 man1170 - -data Happy1171 = Happy1171 {name1171 :: String, age1171 :: Int, happy1171 :: Bool} -man1171 :: Happy1171 -man1171 = Happy1171 {name1171 = "Happy", age1171 = 1, happy1171 = True} -test1171 :: String -test1171 = name1171 man1171 - -data Happy1172 = Happy1172 {name1172 :: String, age1172 :: Int, happy1172 :: Bool} -man1172 :: Happy1172 -man1172 = Happy1172 {name1172 = "Happy", age1172 = 1, happy1172 = True} -test1172 :: String -test1172 = name1172 man1172 - -data Happy1173 = Happy1173 {name1173 :: String, age1173 :: Int, happy1173 :: Bool} -man1173 :: Happy1173 -man1173 = Happy1173 {name1173 = "Happy", age1173 = 1, happy1173 = True} -test1173 :: String -test1173 = name1173 man1173 - -data Happy1174 = Happy1174 {name1174 :: String, age1174 :: Int, happy1174 :: Bool} -man1174 :: Happy1174 -man1174 = Happy1174 {name1174 = "Happy", age1174 = 1, happy1174 = True} -test1174 :: String -test1174 = name1174 man1174 - -data Happy1175 = Happy1175 {name1175 :: String, age1175 :: Int, happy1175 :: Bool} -man1175 :: Happy1175 -man1175 = Happy1175 {name1175 = "Happy", age1175 = 1, happy1175 = True} -test1175 :: String -test1175 = name1175 man1175 - -data Happy1176 = Happy1176 {name1176 :: String, age1176 :: Int, happy1176 :: Bool} -man1176 :: Happy1176 -man1176 = Happy1176 {name1176 = "Happy", age1176 = 1, happy1176 = True} -test1176 :: String -test1176 = name1176 man1176 - -data Happy1177 = Happy1177 {name1177 :: String, age1177 :: Int, happy1177 :: Bool} -man1177 :: Happy1177 -man1177 = Happy1177 {name1177 = "Happy", age1177 = 1, happy1177 = True} -test1177 :: String -test1177 = name1177 man1177 - -data Happy1178 = Happy1178 {name1178 :: String, age1178 :: Int, happy1178 :: Bool} -man1178 :: Happy1178 -man1178 = Happy1178 {name1178 = "Happy", age1178 = 1, happy1178 = True} -test1178 :: String -test1178 = name1178 man1178 - -data Happy1179 = Happy1179 {name1179 :: String, age1179 :: Int, happy1179 :: Bool} -man1179 :: Happy1179 -man1179 = Happy1179 {name1179 = "Happy", age1179 = 1, happy1179 = True} -test1179 :: String -test1179 = name1179 man1179 - -data Happy1180 = Happy1180 {name1180 :: String, age1180 :: Int, happy1180 :: Bool} -man1180 :: Happy1180 -man1180 = Happy1180 {name1180 = "Happy", age1180 = 1, happy1180 = True} -test1180 :: String -test1180 = name1180 man1180 - -data Happy1181 = Happy1181 {name1181 :: String, age1181 :: Int, happy1181 :: Bool} -man1181 :: Happy1181 -man1181 = Happy1181 {name1181 = "Happy", age1181 = 1, happy1181 = True} -test1181 :: String -test1181 = name1181 man1181 - -data Happy1182 = Happy1182 {name1182 :: String, age1182 :: Int, happy1182 :: Bool} -man1182 :: Happy1182 -man1182 = Happy1182 {name1182 = "Happy", age1182 = 1, happy1182 = True} -test1182 :: String -test1182 = name1182 man1182 - -data Happy1183 = Happy1183 {name1183 :: String, age1183 :: Int, happy1183 :: Bool} -man1183 :: Happy1183 -man1183 = Happy1183 {name1183 = "Happy", age1183 = 1, happy1183 = True} -test1183 :: String -test1183 = name1183 man1183 - -data Happy1184 = Happy1184 {name1184 :: String, age1184 :: Int, happy1184 :: Bool} -man1184 :: Happy1184 -man1184 = Happy1184 {name1184 = "Happy", age1184 = 1, happy1184 = True} -test1184 :: String -test1184 = name1184 man1184 - -data Happy1185 = Happy1185 {name1185 :: String, age1185 :: Int, happy1185 :: Bool} -man1185 :: Happy1185 -man1185 = Happy1185 {name1185 = "Happy", age1185 = 1, happy1185 = True} -test1185 :: String -test1185 = name1185 man1185 - -data Happy1186 = Happy1186 {name1186 :: String, age1186 :: Int, happy1186 :: Bool} -man1186 :: Happy1186 -man1186 = Happy1186 {name1186 = "Happy", age1186 = 1, happy1186 = True} -test1186 :: String -test1186 = name1186 man1186 - -data Happy1187 = Happy1187 {name1187 :: String, age1187 :: Int, happy1187 :: Bool} -man1187 :: Happy1187 -man1187 = Happy1187 {name1187 = "Happy", age1187 = 1, happy1187 = True} -test1187 :: String -test1187 = name1187 man1187 - -data Happy1188 = Happy1188 {name1188 :: String, age1188 :: Int, happy1188 :: Bool} -man1188 :: Happy1188 -man1188 = Happy1188 {name1188 = "Happy", age1188 = 1, happy1188 = True} -test1188 :: String -test1188 = name1188 man1188 - -data Happy1189 = Happy1189 {name1189 :: String, age1189 :: Int, happy1189 :: Bool} -man1189 :: Happy1189 -man1189 = Happy1189 {name1189 = "Happy", age1189 = 1, happy1189 = True} -test1189 :: String -test1189 = name1189 man1189 - -data Happy1190 = Happy1190 {name1190 :: String, age1190 :: Int, happy1190 :: Bool} -man1190 :: Happy1190 -man1190 = Happy1190 {name1190 = "Happy", age1190 = 1, happy1190 = True} -test1190 :: String -test1190 = name1190 man1190 - -data Happy1191 = Happy1191 {name1191 :: String, age1191 :: Int, happy1191 :: Bool} -man1191 :: Happy1191 -man1191 = Happy1191 {name1191 = "Happy", age1191 = 1, happy1191 = True} -test1191 :: String -test1191 = name1191 man1191 - -data Happy1192 = Happy1192 {name1192 :: String, age1192 :: Int, happy1192 :: Bool} -man1192 :: Happy1192 -man1192 = Happy1192 {name1192 = "Happy", age1192 = 1, happy1192 = True} -test1192 :: String -test1192 = name1192 man1192 - -data Happy1193 = Happy1193 {name1193 :: String, age1193 :: Int, happy1193 :: Bool} -man1193 :: Happy1193 -man1193 = Happy1193 {name1193 = "Happy", age1193 = 1, happy1193 = True} -test1193 :: String -test1193 = name1193 man1193 - -data Happy1194 = Happy1194 {name1194 :: String, age1194 :: Int, happy1194 :: Bool} -man1194 :: Happy1194 -man1194 = Happy1194 {name1194 = "Happy", age1194 = 1, happy1194 = True} -test1194 :: String -test1194 = name1194 man1194 - -data Happy1195 = Happy1195 {name1195 :: String, age1195 :: Int, happy1195 :: Bool} -man1195 :: Happy1195 -man1195 = Happy1195 {name1195 = "Happy", age1195 = 1, happy1195 = True} -test1195 :: String -test1195 = name1195 man1195 - -data Happy1196 = Happy1196 {name1196 :: String, age1196 :: Int, happy1196 :: Bool} -man1196 :: Happy1196 -man1196 = Happy1196 {name1196 = "Happy", age1196 = 1, happy1196 = True} -test1196 :: String -test1196 = name1196 man1196 - -data Happy1197 = Happy1197 {name1197 :: String, age1197 :: Int, happy1197 :: Bool} -man1197 :: Happy1197 -man1197 = Happy1197 {name1197 = "Happy", age1197 = 1, happy1197 = True} -test1197 :: String -test1197 = name1197 man1197 - -data Happy1198 = Happy1198 {name1198 :: String, age1198 :: Int, happy1198 :: Bool} -man1198 :: Happy1198 -man1198 = Happy1198 {name1198 = "Happy", age1198 = 1, happy1198 = True} -test1198 :: String -test1198 = name1198 man1198 - -data Happy1199 = Happy1199 {name1199 :: String, age1199 :: Int, happy1199 :: Bool} -man1199 :: Happy1199 -man1199 = Happy1199 {name1199 = "Happy", age1199 = 1, happy1199 = True} -test1199 :: String -test1199 = name1199 man1199 - -data Happy1200 = Happy1200 {name1200 :: String, age1200 :: Int, happy1200 :: Bool} -man1200 :: Happy1200 -man1200 = Happy1200 {name1200 = "Happy", age1200 = 1, happy1200 = True} -test1200 :: String -test1200 = name1200 man1200 - -data Happy1201 = Happy1201 {name1201 :: String, age1201 :: Int, happy1201 :: Bool} -man1201 :: Happy1201 -man1201 = Happy1201 {name1201 = "Happy", age1201 = 1, happy1201 = True} -test1201 :: String -test1201 = name1201 man1201 - -data Happy1202 = Happy1202 {name1202 :: String, age1202 :: Int, happy1202 :: Bool} -man1202 :: Happy1202 -man1202 = Happy1202 {name1202 = "Happy", age1202 = 1, happy1202 = True} -test1202 :: String -test1202 = name1202 man1202 - -data Happy1203 = Happy1203 {name1203 :: String, age1203 :: Int, happy1203 :: Bool} -man1203 :: Happy1203 -man1203 = Happy1203 {name1203 = "Happy", age1203 = 1, happy1203 = True} -test1203 :: String -test1203 = name1203 man1203 - -data Happy1204 = Happy1204 {name1204 :: String, age1204 :: Int, happy1204 :: Bool} -man1204 :: Happy1204 -man1204 = Happy1204 {name1204 = "Happy", age1204 = 1, happy1204 = True} -test1204 :: String -test1204 = name1204 man1204 - -data Happy1205 = Happy1205 {name1205 :: String, age1205 :: Int, happy1205 :: Bool} -man1205 :: Happy1205 -man1205 = Happy1205 {name1205 = "Happy", age1205 = 1, happy1205 = True} -test1205 :: String -test1205 = name1205 man1205 - -data Happy1206 = Happy1206 {name1206 :: String, age1206 :: Int, happy1206 :: Bool} -man1206 :: Happy1206 -man1206 = Happy1206 {name1206 = "Happy", age1206 = 1, happy1206 = True} -test1206 :: String -test1206 = name1206 man1206 - -data Happy1207 = Happy1207 {name1207 :: String, age1207 :: Int, happy1207 :: Bool} -man1207 :: Happy1207 -man1207 = Happy1207 {name1207 = "Happy", age1207 = 1, happy1207 = True} -test1207 :: String -test1207 = name1207 man1207 - -data Happy1208 = Happy1208 {name1208 :: String, age1208 :: Int, happy1208 :: Bool} -man1208 :: Happy1208 -man1208 = Happy1208 {name1208 = "Happy", age1208 = 1, happy1208 = True} -test1208 :: String -test1208 = name1208 man1208 - -data Happy1209 = Happy1209 {name1209 :: String, age1209 :: Int, happy1209 :: Bool} -man1209 :: Happy1209 -man1209 = Happy1209 {name1209 = "Happy", age1209 = 1, happy1209 = True} -test1209 :: String -test1209 = name1209 man1209 - -data Happy1210 = Happy1210 {name1210 :: String, age1210 :: Int, happy1210 :: Bool} -man1210 :: Happy1210 -man1210 = Happy1210 {name1210 = "Happy", age1210 = 1, happy1210 = True} -test1210 :: String -test1210 = name1210 man1210 - -data Happy1211 = Happy1211 {name1211 :: String, age1211 :: Int, happy1211 :: Bool} -man1211 :: Happy1211 -man1211 = Happy1211 {name1211 = "Happy", age1211 = 1, happy1211 = True} -test1211 :: String -test1211 = name1211 man1211 - -data Happy1212 = Happy1212 {name1212 :: String, age1212 :: Int, happy1212 :: Bool} -man1212 :: Happy1212 -man1212 = Happy1212 {name1212 = "Happy", age1212 = 1, happy1212 = True} -test1212 :: String -test1212 = name1212 man1212 - -data Happy1213 = Happy1213 {name1213 :: String, age1213 :: Int, happy1213 :: Bool} -man1213 :: Happy1213 -man1213 = Happy1213 {name1213 = "Happy", age1213 = 1, happy1213 = True} -test1213 :: String -test1213 = name1213 man1213 - -data Happy1214 = Happy1214 {name1214 :: String, age1214 :: Int, happy1214 :: Bool} -man1214 :: Happy1214 -man1214 = Happy1214 {name1214 = "Happy", age1214 = 1, happy1214 = True} -test1214 :: String -test1214 = name1214 man1214 - -data Happy1215 = Happy1215 {name1215 :: String, age1215 :: Int, happy1215 :: Bool} -man1215 :: Happy1215 -man1215 = Happy1215 {name1215 = "Happy", age1215 = 1, happy1215 = True} -test1215 :: String -test1215 = name1215 man1215 - -data Happy1216 = Happy1216 {name1216 :: String, age1216 :: Int, happy1216 :: Bool} -man1216 :: Happy1216 -man1216 = Happy1216 {name1216 = "Happy", age1216 = 1, happy1216 = True} -test1216 :: String -test1216 = name1216 man1216 - -data Happy1217 = Happy1217 {name1217 :: String, age1217 :: Int, happy1217 :: Bool} -man1217 :: Happy1217 -man1217 = Happy1217 {name1217 = "Happy", age1217 = 1, happy1217 = True} -test1217 :: String -test1217 = name1217 man1217 - -data Happy1218 = Happy1218 {name1218 :: String, age1218 :: Int, happy1218 :: Bool} -man1218 :: Happy1218 -man1218 = Happy1218 {name1218 = "Happy", age1218 = 1, happy1218 = True} -test1218 :: String -test1218 = name1218 man1218 - -data Happy1219 = Happy1219 {name1219 :: String, age1219 :: Int, happy1219 :: Bool} -man1219 :: Happy1219 -man1219 = Happy1219 {name1219 = "Happy", age1219 = 1, happy1219 = True} -test1219 :: String -test1219 = name1219 man1219 - -data Happy1220 = Happy1220 {name1220 :: String, age1220 :: Int, happy1220 :: Bool} -man1220 :: Happy1220 -man1220 = Happy1220 {name1220 = "Happy", age1220 = 1, happy1220 = True} -test1220 :: String -test1220 = name1220 man1220 - -data Happy1221 = Happy1221 {name1221 :: String, age1221 :: Int, happy1221 :: Bool} -man1221 :: Happy1221 -man1221 = Happy1221 {name1221 = "Happy", age1221 = 1, happy1221 = True} -test1221 :: String -test1221 = name1221 man1221 - -data Happy1222 = Happy1222 {name1222 :: String, age1222 :: Int, happy1222 :: Bool} -man1222 :: Happy1222 -man1222 = Happy1222 {name1222 = "Happy", age1222 = 1, happy1222 = True} -test1222 :: String -test1222 = name1222 man1222 - -data Happy1223 = Happy1223 {name1223 :: String, age1223 :: Int, happy1223 :: Bool} -man1223 :: Happy1223 -man1223 = Happy1223 {name1223 = "Happy", age1223 = 1, happy1223 = True} -test1223 :: String -test1223 = name1223 man1223 - -data Happy1224 = Happy1224 {name1224 :: String, age1224 :: Int, happy1224 :: Bool} -man1224 :: Happy1224 -man1224 = Happy1224 {name1224 = "Happy", age1224 = 1, happy1224 = True} -test1224 :: String -test1224 = name1224 man1224 - -data Happy1225 = Happy1225 {name1225 :: String, age1225 :: Int, happy1225 :: Bool} -man1225 :: Happy1225 -man1225 = Happy1225 {name1225 = "Happy", age1225 = 1, happy1225 = True} -test1225 :: String -test1225 = name1225 man1225 - -data Happy1226 = Happy1226 {name1226 :: String, age1226 :: Int, happy1226 :: Bool} -man1226 :: Happy1226 -man1226 = Happy1226 {name1226 = "Happy", age1226 = 1, happy1226 = True} -test1226 :: String -test1226 = name1226 man1226 - -data Happy1227 = Happy1227 {name1227 :: String, age1227 :: Int, happy1227 :: Bool} -man1227 :: Happy1227 -man1227 = Happy1227 {name1227 = "Happy", age1227 = 1, happy1227 = True} -test1227 :: String -test1227 = name1227 man1227 - -data Happy1228 = Happy1228 {name1228 :: String, age1228 :: Int, happy1228 :: Bool} -man1228 :: Happy1228 -man1228 = Happy1228 {name1228 = "Happy", age1228 = 1, happy1228 = True} -test1228 :: String -test1228 = name1228 man1228 - -data Happy1229 = Happy1229 {name1229 :: String, age1229 :: Int, happy1229 :: Bool} -man1229 :: Happy1229 -man1229 = Happy1229 {name1229 = "Happy", age1229 = 1, happy1229 = True} -test1229 :: String -test1229 = name1229 man1229 - -data Happy1230 = Happy1230 {name1230 :: String, age1230 :: Int, happy1230 :: Bool} -man1230 :: Happy1230 -man1230 = Happy1230 {name1230 = "Happy", age1230 = 1, happy1230 = True} -test1230 :: String -test1230 = name1230 man1230 - -data Happy1231 = Happy1231 {name1231 :: String, age1231 :: Int, happy1231 :: Bool} -man1231 :: Happy1231 -man1231 = Happy1231 {name1231 = "Happy", age1231 = 1, happy1231 = True} -test1231 :: String -test1231 = name1231 man1231 - -data Happy1232 = Happy1232 {name1232 :: String, age1232 :: Int, happy1232 :: Bool} -man1232 :: Happy1232 -man1232 = Happy1232 {name1232 = "Happy", age1232 = 1, happy1232 = True} -test1232 :: String -test1232 = name1232 man1232 - -data Happy1233 = Happy1233 {name1233 :: String, age1233 :: Int, happy1233 :: Bool} -man1233 :: Happy1233 -man1233 = Happy1233 {name1233 = "Happy", age1233 = 1, happy1233 = True} -test1233 :: String -test1233 = name1233 man1233 - -data Happy1234 = Happy1234 {name1234 :: String, age1234 :: Int, happy1234 :: Bool} -man1234 :: Happy1234 -man1234 = Happy1234 {name1234 = "Happy", age1234 = 1, happy1234 = True} -test1234 :: String -test1234 = name1234 man1234 - -data Happy1235 = Happy1235 {name1235 :: String, age1235 :: Int, happy1235 :: Bool} -man1235 :: Happy1235 -man1235 = Happy1235 {name1235 = "Happy", age1235 = 1, happy1235 = True} -test1235 :: String -test1235 = name1235 man1235 - -data Happy1236 = Happy1236 {name1236 :: String, age1236 :: Int, happy1236 :: Bool} -man1236 :: Happy1236 -man1236 = Happy1236 {name1236 = "Happy", age1236 = 1, happy1236 = True} -test1236 :: String -test1236 = name1236 man1236 - -data Happy1237 = Happy1237 {name1237 :: String, age1237 :: Int, happy1237 :: Bool} -man1237 :: Happy1237 -man1237 = Happy1237 {name1237 = "Happy", age1237 = 1, happy1237 = True} -test1237 :: String -test1237 = name1237 man1237 - -data Happy1238 = Happy1238 {name1238 :: String, age1238 :: Int, happy1238 :: Bool} -man1238 :: Happy1238 -man1238 = Happy1238 {name1238 = "Happy", age1238 = 1, happy1238 = True} -test1238 :: String -test1238 = name1238 man1238 - -data Happy1239 = Happy1239 {name1239 :: String, age1239 :: Int, happy1239 :: Bool} -man1239 :: Happy1239 -man1239 = Happy1239 {name1239 = "Happy", age1239 = 1, happy1239 = True} -test1239 :: String -test1239 = name1239 man1239 - -data Happy1240 = Happy1240 {name1240 :: String, age1240 :: Int, happy1240 :: Bool} -man1240 :: Happy1240 -man1240 = Happy1240 {name1240 = "Happy", age1240 = 1, happy1240 = True} -test1240 :: String -test1240 = name1240 man1240 - -data Happy1241 = Happy1241 {name1241 :: String, age1241 :: Int, happy1241 :: Bool} -man1241 :: Happy1241 -man1241 = Happy1241 {name1241 = "Happy", age1241 = 1, happy1241 = True} -test1241 :: String -test1241 = name1241 man1241 - -data Happy1242 = Happy1242 {name1242 :: String, age1242 :: Int, happy1242 :: Bool} -man1242 :: Happy1242 -man1242 = Happy1242 {name1242 = "Happy", age1242 = 1, happy1242 = True} -test1242 :: String -test1242 = name1242 man1242 - -data Happy1243 = Happy1243 {name1243 :: String, age1243 :: Int, happy1243 :: Bool} -man1243 :: Happy1243 -man1243 = Happy1243 {name1243 = "Happy", age1243 = 1, happy1243 = True} -test1243 :: String -test1243 = name1243 man1243 - -data Happy1244 = Happy1244 {name1244 :: String, age1244 :: Int, happy1244 :: Bool} -man1244 :: Happy1244 -man1244 = Happy1244 {name1244 = "Happy", age1244 = 1, happy1244 = True} -test1244 :: String -test1244 = name1244 man1244 - -data Happy1245 = Happy1245 {name1245 :: String, age1245 :: Int, happy1245 :: Bool} -man1245 :: Happy1245 -man1245 = Happy1245 {name1245 = "Happy", age1245 = 1, happy1245 = True} -test1245 :: String -test1245 = name1245 man1245 - -data Happy1246 = Happy1246 {name1246 :: String, age1246 :: Int, happy1246 :: Bool} -man1246 :: Happy1246 -man1246 = Happy1246 {name1246 = "Happy", age1246 = 1, happy1246 = True} -test1246 :: String -test1246 = name1246 man1246 - -data Happy1247 = Happy1247 {name1247 :: String, age1247 :: Int, happy1247 :: Bool} -man1247 :: Happy1247 -man1247 = Happy1247 {name1247 = "Happy", age1247 = 1, happy1247 = True} -test1247 :: String -test1247 = name1247 man1247 - -data Happy1248 = Happy1248 {name1248 :: String, age1248 :: Int, happy1248 :: Bool} -man1248 :: Happy1248 -man1248 = Happy1248 {name1248 = "Happy", age1248 = 1, happy1248 = True} -test1248 :: String -test1248 = name1248 man1248 - -data Happy1249 = Happy1249 {name1249 :: String, age1249 :: Int, happy1249 :: Bool} -man1249 :: Happy1249 -man1249 = Happy1249 {name1249 = "Happy", age1249 = 1, happy1249 = True} -test1249 :: String -test1249 = name1249 man1249 - -data Happy1250 = Happy1250 {name1250 :: String, age1250 :: Int, happy1250 :: Bool} -man1250 :: Happy1250 -man1250 = Happy1250 {name1250 = "Happy", age1250 = 1, happy1250 = True} -test1250 :: String -test1250 = name1250 man1250 - -data Happy1251 = Happy1251 {name1251 :: String, age1251 :: Int, happy1251 :: Bool} -man1251 :: Happy1251 -man1251 = Happy1251 {name1251 = "Happy", age1251 = 1, happy1251 = True} -test1251 :: String -test1251 = name1251 man1251 - -data Happy1252 = Happy1252 {name1252 :: String, age1252 :: Int, happy1252 :: Bool} -man1252 :: Happy1252 -man1252 = Happy1252 {name1252 = "Happy", age1252 = 1, happy1252 = True} -test1252 :: String -test1252 = name1252 man1252 - -data Happy1253 = Happy1253 {name1253 :: String, age1253 :: Int, happy1253 :: Bool} -man1253 :: Happy1253 -man1253 = Happy1253 {name1253 = "Happy", age1253 = 1, happy1253 = True} -test1253 :: String -test1253 = name1253 man1253 - -data Happy1254 = Happy1254 {name1254 :: String, age1254 :: Int, happy1254 :: Bool} -man1254 :: Happy1254 -man1254 = Happy1254 {name1254 = "Happy", age1254 = 1, happy1254 = True} -test1254 :: String -test1254 = name1254 man1254 - -data Happy1255 = Happy1255 {name1255 :: String, age1255 :: Int, happy1255 :: Bool} -man1255 :: Happy1255 -man1255 = Happy1255 {name1255 = "Happy", age1255 = 1, happy1255 = True} -test1255 :: String -test1255 = name1255 man1255 - -data Happy1256 = Happy1256 {name1256 :: String, age1256 :: Int, happy1256 :: Bool} -man1256 :: Happy1256 -man1256 = Happy1256 {name1256 = "Happy", age1256 = 1, happy1256 = True} -test1256 :: String -test1256 = name1256 man1256 - -data Happy1257 = Happy1257 {name1257 :: String, age1257 :: Int, happy1257 :: Bool} -man1257 :: Happy1257 -man1257 = Happy1257 {name1257 = "Happy", age1257 = 1, happy1257 = True} -test1257 :: String -test1257 = name1257 man1257 - -data Happy1258 = Happy1258 {name1258 :: String, age1258 :: Int, happy1258 :: Bool} -man1258 :: Happy1258 -man1258 = Happy1258 {name1258 = "Happy", age1258 = 1, happy1258 = True} -test1258 :: String -test1258 = name1258 man1258 - -data Happy1259 = Happy1259 {name1259 :: String, age1259 :: Int, happy1259 :: Bool} -man1259 :: Happy1259 -man1259 = Happy1259 {name1259 = "Happy", age1259 = 1, happy1259 = True} -test1259 :: String -test1259 = name1259 man1259 - -data Happy1260 = Happy1260 {name1260 :: String, age1260 :: Int, happy1260 :: Bool} -man1260 :: Happy1260 -man1260 = Happy1260 {name1260 = "Happy", age1260 = 1, happy1260 = True} -test1260 :: String -test1260 = name1260 man1260 - -data Happy1261 = Happy1261 {name1261 :: String, age1261 :: Int, happy1261 :: Bool} -man1261 :: Happy1261 -man1261 = Happy1261 {name1261 = "Happy", age1261 = 1, happy1261 = True} -test1261 :: String -test1261 = name1261 man1261 - -data Happy1262 = Happy1262 {name1262 :: String, age1262 :: Int, happy1262 :: Bool} -man1262 :: Happy1262 -man1262 = Happy1262 {name1262 = "Happy", age1262 = 1, happy1262 = True} -test1262 :: String -test1262 = name1262 man1262 - -data Happy1263 = Happy1263 {name1263 :: String, age1263 :: Int, happy1263 :: Bool} -man1263 :: Happy1263 -man1263 = Happy1263 {name1263 = "Happy", age1263 = 1, happy1263 = True} -test1263 :: String -test1263 = name1263 man1263 - -data Happy1264 = Happy1264 {name1264 :: String, age1264 :: Int, happy1264 :: Bool} -man1264 :: Happy1264 -man1264 = Happy1264 {name1264 = "Happy", age1264 = 1, happy1264 = True} -test1264 :: String -test1264 = name1264 man1264 - -data Happy1265 = Happy1265 {name1265 :: String, age1265 :: Int, happy1265 :: Bool} -man1265 :: Happy1265 -man1265 = Happy1265 {name1265 = "Happy", age1265 = 1, happy1265 = True} -test1265 :: String -test1265 = name1265 man1265 - -data Happy1266 = Happy1266 {name1266 :: String, age1266 :: Int, happy1266 :: Bool} -man1266 :: Happy1266 -man1266 = Happy1266 {name1266 = "Happy", age1266 = 1, happy1266 = True} -test1266 :: String -test1266 = name1266 man1266 - -data Happy1267 = Happy1267 {name1267 :: String, age1267 :: Int, happy1267 :: Bool} -man1267 :: Happy1267 -man1267 = Happy1267 {name1267 = "Happy", age1267 = 1, happy1267 = True} -test1267 :: String -test1267 = name1267 man1267 - -data Happy1268 = Happy1268 {name1268 :: String, age1268 :: Int, happy1268 :: Bool} -man1268 :: Happy1268 -man1268 = Happy1268 {name1268 = "Happy", age1268 = 1, happy1268 = True} -test1268 :: String -test1268 = name1268 man1268 - -data Happy1269 = Happy1269 {name1269 :: String, age1269 :: Int, happy1269 :: Bool} -man1269 :: Happy1269 -man1269 = Happy1269 {name1269 = "Happy", age1269 = 1, happy1269 = True} -test1269 :: String -test1269 = name1269 man1269 - -data Happy1270 = Happy1270 {name1270 :: String, age1270 :: Int, happy1270 :: Bool} -man1270 :: Happy1270 -man1270 = Happy1270 {name1270 = "Happy", age1270 = 1, happy1270 = True} -test1270 :: String -test1270 = name1270 man1270 - -data Happy1271 = Happy1271 {name1271 :: String, age1271 :: Int, happy1271 :: Bool} -man1271 :: Happy1271 -man1271 = Happy1271 {name1271 = "Happy", age1271 = 1, happy1271 = True} -test1271 :: String -test1271 = name1271 man1271 - -data Happy1272 = Happy1272 {name1272 :: String, age1272 :: Int, happy1272 :: Bool} -man1272 :: Happy1272 -man1272 = Happy1272 {name1272 = "Happy", age1272 = 1, happy1272 = True} -test1272 :: String -test1272 = name1272 man1272 - -data Happy1273 = Happy1273 {name1273 :: String, age1273 :: Int, happy1273 :: Bool} -man1273 :: Happy1273 -man1273 = Happy1273 {name1273 = "Happy", age1273 = 1, happy1273 = True} -test1273 :: String -test1273 = name1273 man1273 - -data Happy1274 = Happy1274 {name1274 :: String, age1274 :: Int, happy1274 :: Bool} -man1274 :: Happy1274 -man1274 = Happy1274 {name1274 = "Happy", age1274 = 1, happy1274 = True} -test1274 :: String -test1274 = name1274 man1274 - -data Happy1275 = Happy1275 {name1275 :: String, age1275 :: Int, happy1275 :: Bool} -man1275 :: Happy1275 -man1275 = Happy1275 {name1275 = "Happy", age1275 = 1, happy1275 = True} -test1275 :: String -test1275 = name1275 man1275 - -data Happy1276 = Happy1276 {name1276 :: String, age1276 :: Int, happy1276 :: Bool} -man1276 :: Happy1276 -man1276 = Happy1276 {name1276 = "Happy", age1276 = 1, happy1276 = True} -test1276 :: String -test1276 = name1276 man1276 - -data Happy1277 = Happy1277 {name1277 :: String, age1277 :: Int, happy1277 :: Bool} -man1277 :: Happy1277 -man1277 = Happy1277 {name1277 = "Happy", age1277 = 1, happy1277 = True} -test1277 :: String -test1277 = name1277 man1277 - -data Happy1278 = Happy1278 {name1278 :: String, age1278 :: Int, happy1278 :: Bool} -man1278 :: Happy1278 -man1278 = Happy1278 {name1278 = "Happy", age1278 = 1, happy1278 = True} -test1278 :: String -test1278 = name1278 man1278 - -data Happy1279 = Happy1279 {name1279 :: String, age1279 :: Int, happy1279 :: Bool} -man1279 :: Happy1279 -man1279 = Happy1279 {name1279 = "Happy", age1279 = 1, happy1279 = True} -test1279 :: String -test1279 = name1279 man1279 - -data Happy1280 = Happy1280 {name1280 :: String, age1280 :: Int, happy1280 :: Bool} -man1280 :: Happy1280 -man1280 = Happy1280 {name1280 = "Happy", age1280 = 1, happy1280 = True} -test1280 :: String -test1280 = name1280 man1280 - -data Happy1281 = Happy1281 {name1281 :: String, age1281 :: Int, happy1281 :: Bool} -man1281 :: Happy1281 -man1281 = Happy1281 {name1281 = "Happy", age1281 = 1, happy1281 = True} -test1281 :: String -test1281 = name1281 man1281 - -data Happy1282 = Happy1282 {name1282 :: String, age1282 :: Int, happy1282 :: Bool} -man1282 :: Happy1282 -man1282 = Happy1282 {name1282 = "Happy", age1282 = 1, happy1282 = True} -test1282 :: String -test1282 = name1282 man1282 - -data Happy1283 = Happy1283 {name1283 :: String, age1283 :: Int, happy1283 :: Bool} -man1283 :: Happy1283 -man1283 = Happy1283 {name1283 = "Happy", age1283 = 1, happy1283 = True} -test1283 :: String -test1283 = name1283 man1283 - -data Happy1284 = Happy1284 {name1284 :: String, age1284 :: Int, happy1284 :: Bool} -man1284 :: Happy1284 -man1284 = Happy1284 {name1284 = "Happy", age1284 = 1, happy1284 = True} -test1284 :: String -test1284 = name1284 man1284 - -data Happy1285 = Happy1285 {name1285 :: String, age1285 :: Int, happy1285 :: Bool} -man1285 :: Happy1285 -man1285 = Happy1285 {name1285 = "Happy", age1285 = 1, happy1285 = True} -test1285 :: String -test1285 = name1285 man1285 - -data Happy1286 = Happy1286 {name1286 :: String, age1286 :: Int, happy1286 :: Bool} -man1286 :: Happy1286 -man1286 = Happy1286 {name1286 = "Happy", age1286 = 1, happy1286 = True} -test1286 :: String -test1286 = name1286 man1286 - -data Happy1287 = Happy1287 {name1287 :: String, age1287 :: Int, happy1287 :: Bool} -man1287 :: Happy1287 -man1287 = Happy1287 {name1287 = "Happy", age1287 = 1, happy1287 = True} -test1287 :: String -test1287 = name1287 man1287 - -data Happy1288 = Happy1288 {name1288 :: String, age1288 :: Int, happy1288 :: Bool} -man1288 :: Happy1288 -man1288 = Happy1288 {name1288 = "Happy", age1288 = 1, happy1288 = True} -test1288 :: String -test1288 = name1288 man1288 - -data Happy1289 = Happy1289 {name1289 :: String, age1289 :: Int, happy1289 :: Bool} -man1289 :: Happy1289 -man1289 = Happy1289 {name1289 = "Happy", age1289 = 1, happy1289 = True} -test1289 :: String -test1289 = name1289 man1289 - -data Happy1290 = Happy1290 {name1290 :: String, age1290 :: Int, happy1290 :: Bool} -man1290 :: Happy1290 -man1290 = Happy1290 {name1290 = "Happy", age1290 = 1, happy1290 = True} -test1290 :: String -test1290 = name1290 man1290 - -data Happy1291 = Happy1291 {name1291 :: String, age1291 :: Int, happy1291 :: Bool} -man1291 :: Happy1291 -man1291 = Happy1291 {name1291 = "Happy", age1291 = 1, happy1291 = True} -test1291 :: String -test1291 = name1291 man1291 - -data Happy1292 = Happy1292 {name1292 :: String, age1292 :: Int, happy1292 :: Bool} -man1292 :: Happy1292 -man1292 = Happy1292 {name1292 = "Happy", age1292 = 1, happy1292 = True} -test1292 :: String -test1292 = name1292 man1292 - -data Happy1293 = Happy1293 {name1293 :: String, age1293 :: Int, happy1293 :: Bool} -man1293 :: Happy1293 -man1293 = Happy1293 {name1293 = "Happy", age1293 = 1, happy1293 = True} -test1293 :: String -test1293 = name1293 man1293 - -data Happy1294 = Happy1294 {name1294 :: String, age1294 :: Int, happy1294 :: Bool} -man1294 :: Happy1294 -man1294 = Happy1294 {name1294 = "Happy", age1294 = 1, happy1294 = True} -test1294 :: String -test1294 = name1294 man1294 - -data Happy1295 = Happy1295 {name1295 :: String, age1295 :: Int, happy1295 :: Bool} -man1295 :: Happy1295 -man1295 = Happy1295 {name1295 = "Happy", age1295 = 1, happy1295 = True} -test1295 :: String -test1295 = name1295 man1295 - -data Happy1296 = Happy1296 {name1296 :: String, age1296 :: Int, happy1296 :: Bool} -man1296 :: Happy1296 -man1296 = Happy1296 {name1296 = "Happy", age1296 = 1, happy1296 = True} -test1296 :: String -test1296 = name1296 man1296 - -data Happy1297 = Happy1297 {name1297 :: String, age1297 :: Int, happy1297 :: Bool} -man1297 :: Happy1297 -man1297 = Happy1297 {name1297 = "Happy", age1297 = 1, happy1297 = True} -test1297 :: String -test1297 = name1297 man1297 - -data Happy1298 = Happy1298 {name1298 :: String, age1298 :: Int, happy1298 :: Bool} -man1298 :: Happy1298 -man1298 = Happy1298 {name1298 = "Happy", age1298 = 1, happy1298 = True} -test1298 :: String -test1298 = name1298 man1298 - -data Happy1299 = Happy1299 {name1299 :: String, age1299 :: Int, happy1299 :: Bool} -man1299 :: Happy1299 -man1299 = Happy1299 {name1299 = "Happy", age1299 = 1, happy1299 = True} -test1299 :: String -test1299 = name1299 man1299