Benchmark.hs

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