From 960ca1b1d22ab7bb573713926f6176beabb07d26 Mon Sep 17 00:00:00 2001 From: Ziyang Liu Date: Fri, 9 Aug 2024 16:23:37 -0700 Subject: [PATCH] Remove uniques from some golden files --- .../Constitution/Validator/GoldenTests.hs | 6 +- .../Validator/GoldenTests/sorted.pir.golden | 9319 ++++++++--------- .../Validator/GoldenTests/sorted.uplc.golden | 833 +- .../Validator/GoldenTests/unsorted.pir.golden | 9230 ++++++++-------- .../GoldenTests/unsorted.uplc.golden | 862 +- .../test/Plugin/Debug/9.6/fib.pir.golden | 156 +- .../test/Plugin/Debug/9.6/letFun.pir.golden | 72 +- plutus-tx-plugin/test/Plugin/Debug/Spec.hs | 2 +- 8 files changed, 9758 insertions(+), 10722 deletions(-) diff --git a/cardano-constitution/test/Cardano/Constitution/Validator/GoldenTests.hs b/cardano-constitution/test/Cardano/Constitution/Validator/GoldenTests.hs index fb660389334..8e7572ec59b 100644 --- a/cardano-constitution/test/Cardano/Constitution/Validator/GoldenTests.hs +++ b/cardano-constitution/test/Cardano/Constitution/Validator/GoldenTests.hs @@ -9,7 +9,7 @@ import Cardano.Constitution.Validator.TestsCommon import Helpers.TestBuilders import PlutusCore.Evaluation.Machine.ExBudget import PlutusCore.Evaluation.Machine.ExBudgetingDefaults -import PlutusCore.Pretty (prettyPlcReadable) +import PlutusCore.Pretty (prettyPlcReadableSimple) import PlutusLedgerApi.V3 as V3 import PlutusLedgerApi.V3.ArbitraryContexts as V3 import PlutusTx.Code as Tx @@ -56,13 +56,13 @@ test_budget_small = testGroup "BudgetSmall" $ M.elems $ test_readable_pir = testGroup "ReadablePir" $ M.elems $ (\vName (_, vCode) -> goldenVsString vName (mkPath vName ["pir"]) $ - pure $ fromString $ show $ prettyPlcReadable $ fromJust $ getPirNoAnn vCode + pure $ fromString $ show $ prettyPlcReadableSimple $ fromJust $ getPirNoAnn vCode )`M.mapWithKey` defaultValidatorsWithCodes test_readable_uplc = testGroup "ReadableUplc" $ M.elems $ (\vName (_, vCode) -> goldenVsString vName (mkPath vName ["uplc"]) $ - pure $ fromString $ show $ prettyPlcReadable $ getPlcNoAnn vCode + pure $ fromString $ show $ prettyPlcReadableSimple $ getPlcNoAnn vCode )`M.mapWithKey` defaultValidatorsWithCodes tests :: TestTreeWithTestState diff --git a/cardano-constitution/test/Cardano/Constitution/Validator/GoldenTests/sorted.pir.golden b/cardano-constitution/test/Cardano/Constitution/Validator/GoldenTests/sorted.pir.golden index 170f0bccec7..f9cb8fd93bc 100644 --- a/cardano-constitution/test/Cardano/Constitution/Validator/GoldenTests/sorted.pir.golden +++ b/cardano-constitution/test/Cardano/Constitution/Validator/GoldenTests/sorted.pir.golden @@ -1,5720 +1,5284 @@ program 1.1.0 (let - data Ordering-73134 | Ordering_match-73138 where - EQ-73135 : Ordering-73134 - GT-73136 : Ordering-73134 - LT-73137 : Ordering-73134 - data Bool-73122 | Bool_match-73125 where - True-73123 : Bool-73122 - False-73124 : Bool-73122 - data (Ord-73139 :: * -> *) a-73142 | Ord_match-73141 where - CConsOrd-73140 : - (\a-73143 -> a-73143 -> a-73143 -> Bool-73122) a-73142 -> - (a-73142 -> a-73142 -> Ordering-73134) -> - (a-73142 -> a-73142 -> Bool-73122) -> - (a-73142 -> a-73142 -> Bool-73122) -> - (a-73142 -> a-73142 -> Bool-73122) -> - (a-73142 -> a-73142 -> Bool-73122) -> - (a-73142 -> a-73142 -> a-73142) -> - (a-73142 -> a-73142 -> a-73142) -> - Ord-73139 a-73142 - data PredKey-73129 | PredKey_match-73133 where - MaxValue-73130 : PredKey-73129 - MinValue-73131 : PredKey-73129 - NotEqual-73132 : PredKey-73129 - data (Tuple2-73107 :: * -> * -> *) a-73110 - b-73111 | Tuple2_match-73109 where - Tuple2-73108 : a-73110 -> b-73111 -> Tuple2-73107 a-73110 b-73111 + data Ordering | Ordering_match where + EQ : Ordering + GT : Ordering + LT : Ordering + data Bool | Bool_match where + True : Bool + False : Bool + data (Ord :: * -> *) a | Ord_match where + CConsOrd : + (\a -> a -> a -> Bool) a -> + (a -> a -> Ordering) -> + (a -> a -> Bool) -> + (a -> a -> Bool) -> + (a -> a -> Bool) -> + (a -> a -> Bool) -> + (a -> a -> a) -> + (a -> a -> a) -> + Ord a + data PredKey | PredKey_match where + MaxValue : PredKey + MinValue : PredKey + NotEqual : PredKey + data (Tuple2 :: * -> * -> *) a b | Tuple2_match where + Tuple2 : a -> b -> Tuple2 a b in letrec - data (List-73102 :: * -> *) a-73106 | List_match-73105 where - Nil-73103 : List-73102 a-73106 - Cons-73104 : a-73106 -> List-73102 a-73106 -> List-73102 a-73106 + data (List :: * -> *) a | List_match where + Nil : List a + Cons : a -> List a -> List a in let - !validatePreds-73272 : - all a-73273. - Ord-73139 a-73273 -> - (\v-73274 -> - List-73102 (Tuple2-73107 PredKey-73129 (List-73102 v-73274))) - a-73273 -> - a-73273 -> - Bool-73122 - = /\a-73205 -> - \(`$dOrd`-73206 : Ord-73139 a-73205) - (ds-73207 : - (\v-73208 -> - List-73102 (Tuple2-73107 PredKey-73129 (List-73102 v-73208))) - a-73205) - (ds-73209 : a-73205) -> + !validatePreds : + all a. Ord a -> (\v -> List (Tuple2 PredKey (List v))) a -> a -> Bool + = /\a -> + \(`$dOrd` : Ord a) + (ds : (\v -> List (Tuple2 PredKey (List v))) a) + (ds : a) -> letrec - !go-73210 : - List-73102 (Tuple2-73107 PredKey-73129 (List-73102 a-73205)) -> - Bool-73122 - = \(ds-73211 : - List-73102 - (Tuple2-73107 PredKey-73129 (List-73102 a-73205))) -> - List_match-73105 - {Tuple2-73107 PredKey-73129 (List-73102 a-73205)} - ds-73211 - {all dead-73212. Bool-73122} - (/\dead-73213 -> True-73123) - (\(x-73214 : - Tuple2-73107 PredKey-73129 (List-73102 a-73205)) - (xs-73215 : - List-73102 - (Tuple2-73107 - PredKey-73129 - (List-73102 a-73205))) -> - /\dead-73216 -> - Tuple2_match-73109 - {PredKey-73129} - {List-73102 a-73205} - x-73214 - {Bool-73122} - (\(predKey-73217 : PredKey-73129) - (expectedPredValues-73218 : - List-73102 a-73205) -> + !go : List (Tuple2 PredKey (List a)) -> Bool + = \(ds : List (Tuple2 PredKey (List a))) -> + List_match + {Tuple2 PredKey (List a)} + ds + {all dead. Bool} + (/\dead -> True) + (\(x : Tuple2 PredKey (List a)) + (xs : List (Tuple2 PredKey (List a))) -> + /\dead -> + Tuple2_match + {PredKey} + {List a} + x + {Bool} + (\(predKey : PredKey) + (expectedPredValues : List a) -> let - !meaning-73258 : - a-73205 -> a-73205 -> Bool-73122 - = PredKey_match-73133 - predKey-73217 - {all dead-73219. - a-73205 -> a-73205 -> Bool-73122} - (/\dead-73220 -> - Ord_match-73141 - {a-73205} - `$dOrd`-73206 - {a-73205 -> a-73205 -> Bool-73122} - (\(v-73221 : - (\a-73222 -> - a-73222 -> - a-73222 -> - Bool-73122) - a-73205) - (v-73223 : - a-73205 -> - a-73205 -> - Ordering-73134) - (v-73224 : - a-73205 -> - a-73205 -> - Bool-73122) - (v-73225 : - a-73205 -> - a-73205 -> - Bool-73122) - (v-73226 : - a-73205 -> - a-73205 -> - Bool-73122) - (v-73227 : - a-73205 -> - a-73205 -> - Bool-73122) - (v-73228 : - a-73205 -> a-73205 -> a-73205) - (v-73229 : - a-73205 -> - a-73205 -> - a-73205) -> - v-73227)) - (/\dead-73230 -> - Ord_match-73141 - {a-73205} - `$dOrd`-73206 - {a-73205 -> a-73205 -> Bool-73122} - (\(v-73231 : - (\a-73232 -> - a-73232 -> - a-73232 -> - Bool-73122) - a-73205) - (v-73233 : - a-73205 -> - a-73205 -> - Ordering-73134) - (v-73234 : - a-73205 -> - a-73205 -> - Bool-73122) - (v-73235 : - a-73205 -> - a-73205 -> - Bool-73122) - (v-73236 : - a-73205 -> - a-73205 -> - Bool-73122) - (v-73237 : - a-73205 -> - a-73205 -> - Bool-73122) - (v-73238 : - a-73205 -> a-73205 -> a-73205) - (v-73239 : - a-73205 -> - a-73205 -> - a-73205) -> - v-73235)) - (/\dead-73240 -> - \(x-73241 : a-73205) - (y-73242 : a-73205) -> - Bool_match-73125 - (Ord_match-73141 - {a-73205} - `$dOrd`-73206 - {(\a-73243 -> - a-73243 -> - a-73243 -> - Bool-73122) - a-73205} - (\(v-73244 : - (\a-73245 -> - a-73245 -> - a-73245 -> - Bool-73122) - a-73205) - (v-73246 : - a-73205 -> - a-73205 -> - Ordering-73134) - (v-73247 : - a-73205 -> - a-73205 -> - Bool-73122) - (v-73248 : - a-73205 -> - a-73205 -> - Bool-73122) - (v-73249 : - a-73205 -> - a-73205 -> - Bool-73122) - (v-73250 : - a-73205 -> - a-73205 -> - Bool-73122) - (v-73251 : - a-73205 -> - a-73205 -> - a-73205) - (v-73252 : - a-73205 -> - a-73205 -> - a-73205) -> - v-73244) - x-73241 - y-73242) - {all dead-73253. Bool-73122} - (/\dead-73254 -> False-73124) - (/\dead-73255 -> True-73123) - {all dead-73256. dead-73256}) - {all dead-73257. dead-73257} + !meaning : a -> a -> Bool + = PredKey_match + predKey + {all dead. a -> a -> Bool} + (/\dead -> + Ord_match + {a} + `$dOrd` + {a -> a -> Bool} + (\(v : (\a -> a -> a -> Bool) a) + (v : a -> a -> Ordering) + (v : a -> a -> Bool) + (v : a -> a -> Bool) + (v : a -> a -> Bool) + (v : a -> a -> Bool) + (v : a -> a -> a) + (v : a -> a -> a) -> + v)) + (/\dead -> + Ord_match + {a} + `$dOrd` + {a -> a -> Bool} + (\(v : (\a -> a -> a -> Bool) a) + (v : a -> a -> Ordering) + (v : a -> a -> Bool) + (v : a -> a -> Bool) + (v : a -> a -> Bool) + (v : a -> a -> Bool) + (v : a -> a -> a) + (v : a -> a -> a) -> + v)) + (/\dead -> + \(x : a) (y : a) -> + Bool_match + (Ord_match + {a} + `$dOrd` + {(\a -> a -> a -> Bool) a} + (\(v : + (\a -> a -> a -> Bool) a) + (v : a -> a -> Ordering) + (v : a -> a -> Bool) + (v : a -> a -> Bool) + (v : a -> a -> Bool) + (v : a -> a -> Bool) + (v : a -> a -> a) + (v : a -> a -> a) -> + v) + x + y) + {all dead. Bool} + (/\dead -> False) + (/\dead -> True) + {all dead. dead}) + {all dead. dead} in letrec - !go-73259 : List-73102 a-73205 -> Bool-73122 - = \(ds-73260 : List-73102 a-73205) -> - List_match-73105 - {a-73205} - ds-73260 - {all dead-73261. Bool-73122} - (/\dead-73262 -> go-73210 xs-73215) - (\(x-73263 : a-73205) - (xs-73264 : List-73102 a-73205) -> - /\dead-73265 -> - Bool_match-73125 - (meaning-73258 - x-73263 - ds-73209) - {all dead-73266. Bool-73122} - (/\dead-73267 -> - go-73259 xs-73264) - (/\dead-73268 -> False-73124) - {all dead-73269. dead-73269}) - {all dead-73270. dead-73270} + !go : List a -> Bool + = \(ds : List a) -> + List_match + {a} + ds + {all dead. Bool} + (/\dead -> go xs) + (\(x : a) (xs : List a) -> + /\dead -> + Bool_match + (meaning x ds) + {all dead. Bool} + (/\dead -> go xs) + (/\dead -> False) + {all dead. dead}) + {all dead. dead} in - go-73259 expectedPredValues-73218)) - {all dead-73271. dead-73271} + go expectedPredValues)) + {all dead. dead} in - go-73210 ds-73207 - !`$fOrdInteger_$ccompare`-73191 : integer -> integer -> Ordering-73134 - = \(eta-73181 : integer) (eta-73182 : integer) -> - Bool_match-73125 - (ifThenElse - {Bool-73122} - (equalsInteger eta-73181 eta-73182) - True-73123 - False-73124) - {all dead-73183. Ordering-73134} - (/\dead-73184 -> EQ-73135) - (/\dead-73185 -> - Bool_match-73125 - (ifThenElse - {Bool-73122} - (lessThanEqualsInteger eta-73181 eta-73182) - True-73123 - False-73124) - {all dead-73186. Ordering-73134} - (/\dead-73187 -> LT-73137) - (/\dead-73188 -> GT-73136) - {all dead-73189. dead-73189}) - {all dead-73190. dead-73190} - data Rational-73144 | Rational_match-73146 where - Rational-73145 : integer -> integer -> Rational-73144 - !`$fOrdRational0_$c<=`-73180 : - Rational-73144 -> Rational-73144 -> Bool-73122 - = \(ds-73174 : Rational-73144) (ds-73175 : Rational-73144) -> - Rational_match-73146 - ds-73174 - {Bool-73122} - (\(n-73176 : integer) (d-73177 : integer) -> - Rational_match-73146 - ds-73175 - {Bool-73122} - (\(n'-73178 : integer) (d'-73179 : integer) -> + go ds + !`$fOrdInteger_$ccompare` : integer -> integer -> Ordering + = \(eta : integer) (eta : integer) -> + Bool_match + (ifThenElse {Bool} (equalsInteger eta eta) True False) + {all dead. Ordering} + (/\dead -> EQ) + (/\dead -> + Bool_match + (ifThenElse {Bool} (lessThanEqualsInteger eta eta) True False) + {all dead. Ordering} + (/\dead -> LT) + (/\dead -> GT) + {all dead. dead}) + {all dead. dead} + data Rational | Rational_match where + Rational : integer -> integer -> Rational + !`$fOrdRational0_$c<=` : Rational -> Rational -> Bool + = \(ds : Rational) (ds : Rational) -> + Rational_match + ds + {Bool} + (\(n : integer) (d : integer) -> + Rational_match + ds + {Bool} + (\(n' : integer) (d' : integer) -> ifThenElse - {Bool-73122} + {Bool} (lessThanEqualsInteger - (multiplyInteger n-73176 d'-73179) - (multiplyInteger n'-73178 d-73177)) - True-73123 - False-73124)) + (multiplyInteger n d') + (multiplyInteger n' d)) + True + False)) in letrec - !euclid-73155 : integer -> integer -> integer - = \(x-73156 : integer) (y-73157 : integer) -> - Bool_match-73125 - (ifThenElse - {Bool-73122} - (equalsInteger 0 y-73157) - True-73123 - False-73124) - {all dead-73158. integer} - (/\dead-73159 -> x-73156) - (/\dead-73160 -> euclid-73155 y-73157 (modInteger x-73156 y-73157)) - {all dead-73161. dead-73161} + !euclid : integer -> integer -> integer + = \(x : integer) (y : integer) -> + Bool_match + (ifThenElse {Bool} (equalsInteger 0 y) True False) + {all dead. integer} + (/\dead -> x) + (/\dead -> euclid y (modInteger x y)) + {all dead. dead} in letrec - !unsafeRatio-73162 : integer -> integer -> Rational-73144 - = \(n-73163 : integer) (d-73164 : integer) -> - Bool_match-73125 - (ifThenElse - {Bool-73122} - (equalsInteger 0 d-73164) - True-73123 - False-73124) - {all dead-73165. Rational-73144} - (/\dead-73166 -> error {Rational-73144}) - (/\dead-73167 -> - Bool_match-73125 - (ifThenElse - {Bool-73122} - (lessThanInteger d-73164 0) - True-73123 - False-73124) - {all dead-73168. Rational-73144} - (/\dead-73169 -> - unsafeRatio-73162 - (subtractInteger 0 n-73163) - (subtractInteger 0 d-73164)) - (/\dead-73170 -> + !unsafeRatio : integer -> integer -> Rational + = \(n : integer) (d : integer) -> + Bool_match + (ifThenElse {Bool} (equalsInteger 0 d) True False) + {all dead. Rational} + (/\dead -> error {Rational}) + (/\dead -> + Bool_match + (ifThenElse {Bool} (lessThanInteger d 0) True False) + {all dead. Rational} + (/\dead -> + unsafeRatio (subtractInteger 0 n) (subtractInteger 0 d)) + (/\dead -> let - !gcd'-73171 : integer = euclid-73155 n-73163 d-73164 + !gcd' : integer = euclid n d in - Rational-73145 - (quotientInteger n-73163 gcd'-73171) - (quotientInteger d-73164 gcd'-73171)) - {all dead-73172. dead-73172}) - {all dead-73173. dead-73173} + Rational (quotientInteger n gcd') (quotientInteger d gcd')) + {all dead. dead}) + {all dead. dead} in letrec - data ParamValue-73147 | ParamValue_match-73152 where - ParamAny-73148 : ParamValue-73147 - ParamInteger-73149 : - (\v-73153 -> - List-73102 (Tuple2-73107 PredKey-73129 (List-73102 v-73153))) - integer -> - ParamValue-73147 - ParamList-73150 : List-73102 ParamValue-73147 -> ParamValue-73147 - ParamRational-73151 : - (\v-73154 -> - List-73102 (Tuple2-73107 PredKey-73129 (List-73102 v-73154))) - Rational-73144 -> - ParamValue-73147 + data ParamValue | ParamValue_match where + ParamAny : ParamValue + ParamInteger : + (\v -> List (Tuple2 PredKey (List v))) integer -> ParamValue + ParamList : List ParamValue -> ParamValue + ParamRational : + (\v -> List (Tuple2 PredKey (List v))) Rational -> ParamValue in let - data Unit-73126 | Unit_match-73128 where - Unit-73127 : Unit-73126 + data Unit | Unit_match where + Unit : Unit in letrec - !validateParamValue-73192 : ParamValue-73147 -> data -> Bool-73122 - = \(eta-73193 : ParamValue-73147) (eta-73194 : data) -> + !validateParamValue : ParamValue -> data -> Bool + = \(eta : ParamValue) (eta : data) -> let - ~bl-73353 : list data = unListData eta-73194 - ~bl'-73354 : list data = tailList {data} bl-73353 + ~bl : list data = unListData eta + ~bl' : list data = tailList {data} bl in - ParamValue_match-73152 - eta-73193 - {all dead-73275. Bool-73122} - (/\dead-73276 -> True-73123) - (\(preds-73277 : - (\v-73278 -> - List-73102 - (Tuple2-73107 PredKey-73129 (List-73102 v-73278))) - integer) -> - /\dead-73279 -> - validatePreds-73272 + ParamValue_match + eta + {all dead. Bool} + (/\dead -> True) + (\(preds : (\v -> List (Tuple2 PredKey (List v))) integer) -> + /\dead -> + validatePreds {integer} - (CConsOrd-73140 + (CConsOrd {integer} - (\(x-73280 : integer) (y-73281 : integer) -> + (\(x : integer) (y : integer) -> + ifThenElse {Bool} (equalsInteger x y) True False) + `$fOrdInteger_$ccompare` + (\(x : integer) (y : integer) -> + ifThenElse {Bool} (lessThanInteger x y) True False) + (\(x : integer) (y : integer) -> ifThenElse - {Bool-73122} - (equalsInteger x-73280 y-73281) - True-73123 - False-73124) - `$fOrdInteger_$ccompare`-73191 - (\(x-73282 : integer) (y-73283 : integer) -> + {Bool} + (lessThanEqualsInteger x y) + True + False) + (\(x : integer) (y : integer) -> ifThenElse - {Bool-73122} - (lessThanInteger x-73282 y-73283) - True-73123 - False-73124) - (\(x-73284 : integer) (y-73285 : integer) -> - ifThenElse - {Bool-73122} - (lessThanEqualsInteger x-73284 y-73285) - True-73123 - False-73124) - (\(x-73286 : integer) (y-73287 : integer) -> - ifThenElse - {Bool-73122} - (lessThanEqualsInteger x-73286 y-73287) - False-73124 - True-73123) - (\(x-73288 : integer) (y-73289 : integer) -> - ifThenElse - {Bool-73122} - (lessThanInteger x-73288 y-73289) - False-73124 - True-73123) - (\(x-73290 : integer) (y-73291 : integer) -> - Bool_match-73125 + {Bool} + (lessThanEqualsInteger x y) + False + True) + (\(x : integer) (y : integer) -> + ifThenElse {Bool} (lessThanInteger x y) False True) + (\(x : integer) (y : integer) -> + Bool_match (ifThenElse - {Bool-73122} - (lessThanEqualsInteger x-73290 y-73291) - True-73123 - False-73124) - {all dead-73292. integer} - (/\dead-73293 -> y-73291) - (/\dead-73294 -> x-73290) - {all dead-73295. dead-73295}) - (\(x-73296 : integer) (y-73297 : integer) -> - Bool_match-73125 + {Bool} + (lessThanEqualsInteger x y) + True + False) + {all dead. integer} + (/\dead -> y) + (/\dead -> x) + {all dead. dead}) + (\(x : integer) (y : integer) -> + Bool_match (ifThenElse - {Bool-73122} - (lessThanEqualsInteger x-73296 y-73297) - True-73123 - False-73124) - {all dead-73298. integer} - (/\dead-73299 -> x-73296) - (/\dead-73300 -> y-73297) - {all dead-73301. dead-73301})) - preds-73277 - (unIData eta-73194)) - (\(paramValues-73302 : List-73102 ParamValue-73147) -> - /\dead-73303 -> - validateParamValues-73195 - paramValues-73302 - (unListData eta-73194)) - (\(preds-73304 : - (\v-73305 -> - List-73102 - (Tuple2-73107 PredKey-73129 (List-73102 v-73305))) - Rational-73144) -> - /\dead-73306 -> - validatePreds-73272 - {Rational-73144} - (CConsOrd-73140 - {Rational-73144} - (\(ds-73307 : Rational-73144) - (ds-73308 : Rational-73144) -> - Rational_match-73146 - ds-73307 - {Bool-73122} - (\(n-73309 : integer) (d-73310 : integer) -> - Rational_match-73146 - ds-73308 - {Bool-73122} - (\(n'-73311 : integer) (d'-73312 : integer) -> - Bool_match-73125 + {Bool} + (lessThanEqualsInteger x y) + True + False) + {all dead. integer} + (/\dead -> x) + (/\dead -> y) + {all dead. dead})) + preds + (unIData eta)) + (\(paramValues : List ParamValue) -> + /\dead -> validateParamValues paramValues (unListData eta)) + (\(preds : (\v -> List (Tuple2 PredKey (List v))) Rational) -> + /\dead -> + validatePreds + {Rational} + (CConsOrd + {Rational} + (\(ds : Rational) (ds : Rational) -> + Rational_match + ds + {Bool} + (\(n : integer) (d : integer) -> + Rational_match + ds + {Bool} + (\(n' : integer) (d' : integer) -> + Bool_match (ifThenElse - {Bool-73122} - (equalsInteger n-73309 n'-73311) - True-73123 - False-73124) - {all dead-73313. Bool-73122} - (/\dead-73314 -> + {Bool} + (equalsInteger n n') + True + False) + {all dead. Bool} + (/\dead -> ifThenElse - {Bool-73122} - (equalsInteger d-73310 d'-73312) - True-73123 - False-73124) - (/\dead-73315 -> False-73124) - {all dead-73316. dead-73316}))) - (\(ds-73317 : Rational-73144) - (ds-73318 : Rational-73144) -> - Rational_match-73146 - ds-73317 - {Ordering-73134} - (\(n-73319 : integer) (d-73320 : integer) -> - Rational_match-73146 - ds-73318 - {Ordering-73134} - (\(n'-73321 : integer) (d'-73322 : integer) -> - `$fOrdInteger_$ccompare`-73191 - (multiplyInteger n-73319 d'-73322) - (multiplyInteger n'-73321 d-73320)))) - (\(ds-73323 : Rational-73144) - (ds-73324 : Rational-73144) -> - Rational_match-73146 - ds-73323 - {Bool-73122} - (\(n-73325 : integer) (d-73326 : integer) -> - Rational_match-73146 - ds-73324 - {Bool-73122} - (\(n'-73327 : integer) (d'-73328 : integer) -> + {Bool} + (equalsInteger d d') + True + False) + (/\dead -> False) + {all dead. dead}))) + (\(ds : Rational) (ds : Rational) -> + Rational_match + ds + {Ordering} + (\(n : integer) (d : integer) -> + Rational_match + ds + {Ordering} + (\(n' : integer) (d' : integer) -> + `$fOrdInteger_$ccompare` + (multiplyInteger n d') + (multiplyInteger n' d)))) + (\(ds : Rational) (ds : Rational) -> + Rational_match + ds + {Bool} + (\(n : integer) (d : integer) -> + Rational_match + ds + {Bool} + (\(n' : integer) (d' : integer) -> ifThenElse - {Bool-73122} + {Bool} (lessThanInteger - (multiplyInteger n-73325 d'-73328) - (multiplyInteger n'-73327 d-73326)) - True-73123 - False-73124))) - `$fOrdRational0_$c<=`-73180 - (\(ds-73329 : Rational-73144) - (ds-73330 : Rational-73144) -> - Rational_match-73146 - ds-73329 - {Bool-73122} - (\(n-73331 : integer) (d-73332 : integer) -> - Rational_match-73146 - ds-73330 - {Bool-73122} - (\(n'-73333 : integer) (d'-73334 : integer) -> + (multiplyInteger n d') + (multiplyInteger n' d)) + True + False))) + `$fOrdRational0_$c<=` + (\(ds : Rational) (ds : Rational) -> + Rational_match + ds + {Bool} + (\(n : integer) (d : integer) -> + Rational_match + ds + {Bool} + (\(n' : integer) (d' : integer) -> ifThenElse - {Bool-73122} + {Bool} (lessThanEqualsInteger - (multiplyInteger n-73331 d'-73334) - (multiplyInteger n'-73333 d-73332)) - False-73124 - True-73123))) - (\(ds-73335 : Rational-73144) - (ds-73336 : Rational-73144) -> - Rational_match-73146 - ds-73335 - {Bool-73122} - (\(n-73337 : integer) (d-73338 : integer) -> - Rational_match-73146 - ds-73336 - {Bool-73122} - (\(n'-73339 : integer) (d'-73340 : integer) -> + (multiplyInteger n d') + (multiplyInteger n' d)) + False + True))) + (\(ds : Rational) (ds : Rational) -> + Rational_match + ds + {Bool} + (\(n : integer) (d : integer) -> + Rational_match + ds + {Bool} + (\(n' : integer) (d' : integer) -> ifThenElse - {Bool-73122} + {Bool} (lessThanInteger - (multiplyInteger n-73337 d'-73340) - (multiplyInteger n'-73339 d-73338)) - False-73124 - True-73123))) - (\(x-73341 : Rational-73144) (y-73342 : Rational-73144) -> - Bool_match-73125 - (`$fOrdRational0_$c<=`-73180 x-73341 y-73342) - {all dead-73343. Rational-73144} - (/\dead-73344 -> y-73342) - (/\dead-73345 -> x-73341) - {all dead-73346. dead-73346}) - (\(x-73347 : Rational-73144) (y-73348 : Rational-73144) -> - Bool_match-73125 - (`$fOrdRational0_$c<=`-73180 x-73347 y-73348) - {all dead-73349. Rational-73144} - (/\dead-73350 -> x-73347) - (/\dead-73351 -> y-73348) - {all dead-73352. dead-73352})) - preds-73304 + (multiplyInteger n d') + (multiplyInteger n' d)) + False + True))) + (\(x : Rational) (y : Rational) -> + Bool_match + (`$fOrdRational0_$c<=` x y) + {all dead. Rational} + (/\dead -> y) + (/\dead -> x) + {all dead. dead}) + (\(x : Rational) (y : Rational) -> + Bool_match + (`$fOrdRational0_$c<=` x y) + {all dead. Rational} + (/\dead -> x) + (/\dead -> y) + {all dead. dead})) + preds (ifThenElse - {Unit-73126 -> Rational-73144} - (nullList {data} (tailList {data} bl'-73354)) - (\(ds-73355 : Unit-73126) -> - unsafeRatio-73162 - (unIData (headList {data} bl-73353)) - (unIData (headList {data} bl'-73354))) - (\(ds-73356 : Unit-73126) -> error {Rational-73144}) - Unit-73127)) - {all dead-73357. dead-73357} - !validateParamValues-73195 : - List-73102 ParamValue-73147 -> list data -> Bool-73122 - = \(ds-73196 : List-73102 ParamValue-73147) -> - List_match-73105 - {ParamValue-73147} - ds-73196 - {list data -> Bool-73122} - (\(eta-73197 : list data) -> - ifThenElse - {Bool-73122} - (nullList {data} eta-73197) - True-73123 - False-73124) - (\(paramValueHd-73198 : ParamValue-73147) - (paramValueTl-73199 : List-73102 ParamValue-73147) - (actualValueData-73200 : list data) -> - Bool_match-73125 - (validateParamValue-73192 - paramValueHd-73198 - (headList {data} actualValueData-73200)) - {all dead-73201. Bool-73122} - (/\dead-73202 -> - validateParamValues-73195 - paramValueTl-73199 - (tailList {data} actualValueData-73200)) - (/\dead-73203 -> False-73124) - {all dead-73204. dead-73204}) + {Unit -> Rational} + (nullList {data} (tailList {data} bl')) + (\(ds : Unit) -> + unsafeRatio + (unIData (headList {data} bl)) + (unIData (headList {data} bl'))) + (\(ds : Unit) -> error {Rational}) + Unit)) + {all dead. dead} + !validateParamValues : List ParamValue -> list data -> Bool + = \(ds : List ParamValue) -> + List_match + {ParamValue} + ds + {list data -> Bool} + (\(eta : list data) -> + ifThenElse {Bool} (nullList {data} eta) True False) + (\(paramValueHd : ParamValue) + (paramValueTl : List ParamValue) + (actualValueData : list data) -> + Bool_match + (validateParamValue + paramValueHd + (headList {data} actualValueData)) + {all dead. Bool} + (/\dead -> + validateParamValues + paramValueTl + (tailList {data} actualValueData)) + (/\dead -> False) + {all dead. dead}) in letrec - !runRules-73358 : - List-73102 (Tuple2-73107 integer ParamValue-73147) -> - List-73102 (Tuple2-73107 data data) -> - Bool-73122 - = \(ds-73359 : List-73102 (Tuple2-73107 integer ParamValue-73147)) - (cparams-73360 : List-73102 (Tuple2-73107 data data)) -> + !runRules : + List (Tuple2 integer ParamValue) -> List (Tuple2 data data) -> Bool + = \(ds : List (Tuple2 integer ParamValue)) + (cparams : List (Tuple2 data data)) -> let - !fail-73370 : unit -> Bool-73122 - = \(ds-73361 : unit) -> + !fail : unit -> Bool + = \(ds : unit) -> (let - a-73362 = Tuple2-73107 data data + a = Tuple2 data data in - \(ds-73363 : List-73102 a-73362) -> - List_match-73105 - {a-73362} - ds-73363 - {all dead-73364. Bool-73122} - (/\dead-73365 -> True-73123) - (\(ipv-73366 : a-73362) - (ipv-73367 : List-73102 a-73362) -> - /\dead-73368 -> False-73124) - {all dead-73369. dead-73369}) - cparams-73360 + \(ds : List a) -> + List_match + {a} + ds + {all dead. Bool} + (/\dead -> True) + (\(ipv : a) (ipv : List a) -> /\dead -> False) + {all dead. dead}) + cparams in - List_match-73105 - {Tuple2-73107 integer ParamValue-73147} - ds-73359 - {all dead-73371. Bool-73122} - (/\dead-73372 -> fail-73370 ()) - (\(ds-73373 : Tuple2-73107 integer ParamValue-73147) - (cfgRest-73374 : - List-73102 (Tuple2-73107 integer ParamValue-73147)) -> - /\dead-73375 -> - Tuple2_match-73109 + List_match + {Tuple2 integer ParamValue} + ds + {all dead. Bool} + (/\dead -> fail ()) + (\(ds : Tuple2 integer ParamValue) + (cfgRest : List (Tuple2 integer ParamValue)) -> + /\dead -> + Tuple2_match {integer} - {ParamValue-73147} - ds-73373 - {Bool-73122} - (\(expectedPid-73376 : integer) - (paramValue-73377 : ParamValue-73147) -> - List_match-73105 - {Tuple2-73107 data data} - cparams-73360 - {all dead-73378. Bool-73122} - (/\dead-73379 -> fail-73370 ()) - (\(ds-73380 : Tuple2-73107 data data) - (cparamsRest-73381 : - List-73102 (Tuple2-73107 data data)) -> - /\dead-73382 -> - Tuple2_match-73109 + {ParamValue} + ds + {Bool} + (\(expectedPid : integer) (paramValue : ParamValue) -> + List_match + {Tuple2 data data} + cparams + {all dead. Bool} + (/\dead -> fail ()) + (\(ds : Tuple2 data data) + (cparamsRest : List (Tuple2 data data)) -> + /\dead -> + Tuple2_match {data} {data} - ds-73380 - {Bool-73122} - (\(ds-73383 : data) - (actualValueData-73384 : data) -> - Ordering_match-73138 - (`$fOrdInteger_$ccompare`-73191 - (unIData ds-73383) - expectedPid-73376) - {all dead-73385. Bool-73122} - (/\dead-73386 -> - Bool_match-73125 - (validateParamValue-73192 - paramValue-73377 - actualValueData-73384) - {all dead-73387. Bool-73122} - (/\dead-73388 -> - runRules-73358 - cfgRest-73374 - cparamsRest-73381) - (/\dead-73389 -> False-73124) - {all dead-73390. dead-73390}) - (/\dead-73391 -> - runRules-73358 - cfgRest-73374 - cparams-73360) - (/\dead-73392 -> False-73124) - {all dead-73393. dead-73393})) - {all dead-73394. dead-73394})) - {all dead-73395. dead-73395} + ds + {Bool} + (\(ds : data) (actualValueData : data) -> + Ordering_match + (`$fOrdInteger_$ccompare` + (unIData ds) + expectedPid) + {all dead. Bool} + (/\dead -> + Bool_match + (validateParamValue + paramValue + actualValueData) + {all dead. Bool} + (/\dead -> + runRules cfgRest cparamsRest) + (/\dead -> False) + {all dead. dead}) + (/\dead -> runRules cfgRest cparams) + (/\dead -> False) + {all dead. dead})) + {all dead. dead})) + {all dead. dead} in let - data (Maybe-73117 :: * -> *) a-73121 | Maybe_match-73120 where - Just-73118 : a-73121 -> Maybe-73117 a-73121 - Nothing-73119 : Maybe-73117 a-73121 + data (Maybe :: * -> *) a | Maybe_match where + Just : a -> Maybe a + Nothing : Maybe a in letrec - !go-73112 : list (pair data data) -> List-73102 (Tuple2-73107 data data) - = \(l-73113 : list (pair data data)) -> + !go : list (pair data data) -> List (Tuple2 data data) + = \(l : list (pair data data)) -> chooseList {pair data data} - {unit -> List-73102 (Tuple2-73107 data data)} - l-73113 - (\(ds-73114 : unit) -> Nil-73103 {Tuple2-73107 data data}) - (\(ds-73115 : unit) -> - Cons-73104 - {Tuple2-73107 data data} + {unit -> List (Tuple2 data data)} + l + (\(ds : unit) -> Nil {Tuple2 data data}) + (\(ds : unit) -> + Cons + {Tuple2 data data} (let - !p-73116 : pair data data = headList {pair data data} l-73113 + !p : pair data data = headList {pair data data} l in - Tuple2-73108 + Tuple2 {data} {data} - (fstPair {data} {data} p-73116) - (sndPair {data} {data} p-73116)) - (go-73112 (tailList {pair data data} l-73113))) + (fstPair {data} {data} p) + (sndPair {data} {data} p)) + (go (tailList {pair data data} l))) () in let - !fun-74249 : List-73102 (Tuple2-73107 data data) -> Bool-73122 - = runRules-73358 + !fun : List (Tuple2 data data) -> Bool + = runRules ((let - a-73396 = Tuple2-73107 integer ParamValue-73147 + a = Tuple2 integer ParamValue in - \(g-73397 : - all b-73398. - (a-73396 -> b-73398 -> b-73398) -> b-73398 -> b-73398) -> - g-73397 - {List-73102 a-73396} - (\(ds-73399 : a-73396) (ds-73400 : List-73102 a-73396) -> - Cons-73104 {a-73396} ds-73399 ds-73400) - (Nil-73103 {a-73396})) - (/\a-73401 -> - \(c-73402 : - Tuple2-73107 integer ParamValue-73147 -> a-73401 -> a-73401) - (n-73403 : a-73401) -> - c-73402 - (Tuple2-73108 + \(g : all b. (a -> b -> b) -> b -> b) -> + g {List a} (\(ds : a) (ds : List a) -> Cons {a} ds ds) (Nil {a})) + (/\a -> + \(c : Tuple2 integer ParamValue -> a -> a) (n : a) -> + c + (Tuple2 {integer} - {ParamValue-73147} + {ParamValue} 0 - (ParamInteger-73149 + (ParamInteger ((let - a-73404 - = Tuple2-73107 - PredKey-73129 - (List-73102 integer) + a = Tuple2 PredKey (List integer) in - \(g-73405 : - all b-73406. - (a-73404 -> b-73406 -> b-73406) -> - b-73406 -> - b-73406) -> - g-73405 - {List-73102 a-73404} - (\(ds-73407 : a-73404) - (ds-73408 : List-73102 a-73404) -> - Cons-73104 {a-73404} ds-73407 ds-73408) - (Nil-73103 {a-73404})) - (/\a-73409 -> - \(c-73410 : - Tuple2-73107 - PredKey-73129 - (List-73102 integer) -> - a-73409 -> - a-73409) - (n-73411 : a-73409) -> - c-73410 - (Tuple2-73108 - {PredKey-73129} - {List-73102 integer} - MinValue-73131 + \(g : all b. (a -> b -> b) -> b -> b) -> + g + {List a} + (\(ds : a) (ds : List a) -> Cons {a} ds ds) + (Nil {a})) + (/\a -> + \(c : Tuple2 PredKey (List integer) -> a -> a) + (n : a) -> + c + (Tuple2 + {PredKey} + {List integer} + MinValue ((let - a-73412 = List-73102 integer + a = List integer in - \(c-73413 : - integer -> a-73412 -> a-73412) - (n-73414 : a-73412) -> - c-73413 30 (c-73413 0 n-73414)) - (\(ds-73415 : integer) - (ds-73416 : List-73102 integer) -> - Cons-73104 - {integer} - ds-73415 - ds-73416) - (Nil-73103 {integer}))) - (c-73410 - (Tuple2-73108 - {PredKey-73129} - {List-73102 integer} - MaxValue-73130 + \(c : integer -> a -> a) (n : a) -> + c 30 (c 0 n)) + (\(ds : integer) + (ds : List integer) -> + Cons {integer} ds ds) + (Nil {integer}))) + (c + (Tuple2 + {PredKey} + {List integer} + MaxValue ((let - a-73417 = List-73102 integer + a = List integer in - \(c-73418 : - integer -> a-73417 -> a-73417) - (n-73419 : a-73417) -> - c-73418 1000 n-73419) - (\(ds-73420 : integer) - (ds-73421 : - List-73102 integer) -> - Cons-73104 - {integer} - ds-73420 - ds-73421) - (Nil-73103 {integer}))) - n-73411))))) - (c-73402 - (Tuple2-73108 + \(c : integer -> a -> a) (n : a) -> + c 1000 n) + (\(ds : integer) + (ds : List integer) -> + Cons {integer} ds ds) + (Nil {integer}))) + n))))) + (c + (Tuple2 {integer} - {ParamValue-73147} + {ParamValue} 1 - (ParamInteger-73149 + (ParamInteger ((let - a-73422 - = Tuple2-73107 - PredKey-73129 - (List-73102 integer) + a = Tuple2 PredKey (List integer) in - \(g-73423 : - all b-73424. - (a-73422 -> b-73424 -> b-73424) -> - b-73424 -> - b-73424) -> - g-73423 - {List-73102 a-73422} - (\(ds-73425 : a-73422) - (ds-73426 : List-73102 a-73422) -> - Cons-73104 {a-73422} ds-73425 ds-73426) - (Nil-73103 {a-73422})) - (/\a-73427 -> - \(c-73428 : - Tuple2-73107 - PredKey-73129 - (List-73102 integer) -> - a-73427 -> - a-73427) - (n-73429 : a-73427) -> - c-73428 - (Tuple2-73108 - {PredKey-73129} - {List-73102 integer} - MinValue-73131 + \(g : all b. (a -> b -> b) -> b -> b) -> + g + {List a} + (\(ds : a) (ds : List a) -> Cons {a} ds ds) + (Nil {a})) + (/\a -> + \(c : + Tuple2 PredKey (List integer) -> a -> a) + (n : a) -> + c + (Tuple2 + {PredKey} + {List integer} + MinValue ((let - a-73430 = List-73102 integer + a = List integer in - \(c-73431 : - integer -> a-73430 -> a-73430) - (n-73432 : a-73430) -> - c-73431 - 100000 - (c-73431 0 n-73432)) - (\(ds-73433 : integer) - (ds-73434 : - List-73102 integer) -> - Cons-73104 - {integer} - ds-73433 - ds-73434) - (Nil-73103 {integer}))) - (c-73428 - (Tuple2-73108 - {PredKey-73129} - {List-73102 integer} - MaxValue-73130 + \(c : integer -> a -> a) (n : a) -> + c 100000 (c 0 n)) + (\(ds : integer) + (ds : List integer) -> + Cons {integer} ds ds) + (Nil {integer}))) + (c + (Tuple2 + {PredKey} + {List integer} + MaxValue ((let - a-73435 = List-73102 integer + a = List integer in - \(c-73436 : - integer -> - a-73435 -> - a-73435) - (n-73437 : a-73435) -> - c-73436 10000000 n-73437) - (\(ds-73438 : integer) - (ds-73439 : - List-73102 integer) -> - Cons-73104 - {integer} - ds-73438 - ds-73439) - (Nil-73103 {integer}))) - n-73429))))) - (c-73402 - (Tuple2-73108 + \(c : integer -> a -> a) + (n : a) -> + c 10000000 n) + (\(ds : integer) + (ds : List integer) -> + Cons {integer} ds ds) + (Nil {integer}))) + n))))) + (c + (Tuple2 {integer} - {ParamValue-73147} + {ParamValue} 2 - (ParamInteger-73149 + (ParamInteger ((let - a-73440 - = Tuple2-73107 - PredKey-73129 - (List-73102 integer) + a = Tuple2 PredKey (List integer) in - \(g-73441 : - all b-73442. - (a-73440 -> b-73442 -> b-73442) -> - b-73442 -> - b-73442) -> - g-73441 - {List-73102 a-73440} - (\(ds-73443 : a-73440) - (ds-73444 : List-73102 a-73440) -> - Cons-73104 - {a-73440} - ds-73443 - ds-73444) - (Nil-73103 {a-73440})) - (/\a-73445 -> - \(c-73446 : - Tuple2-73107 - PredKey-73129 - (List-73102 integer) -> - a-73445 -> - a-73445) - (n-73447 : a-73445) -> - c-73446 - (Tuple2-73108 - {PredKey-73129} - {List-73102 integer} - MinValue-73131 + \(g : all b. (a -> b -> b) -> b -> b) -> + g + {List a} + (\(ds : a) (ds : List a) -> + Cons {a} ds ds) + (Nil {a})) + (/\a -> + \(c : + Tuple2 PredKey (List integer) -> + a -> + a) + (n : a) -> + c + (Tuple2 + {PredKey} + {List integer} + MinValue ((let - a-73448 = List-73102 integer + a = List integer in - \(c-73449 : - integer -> - a-73448 -> - a-73448) - (n-73450 : a-73448) -> - c-73449 24576 n-73450) - (\(ds-73451 : integer) - (ds-73452 : - List-73102 integer) -> - Cons-73104 - {integer} - ds-73451 - ds-73452) - (Nil-73103 {integer}))) - (c-73446 - (Tuple2-73108 - {PredKey-73129} - {List-73102 integer} - MaxValue-73130 + \(c : integer -> a -> a) + (n : a) -> + c 24576 n) + (\(ds : integer) + (ds : List integer) -> + Cons {integer} ds ds) + (Nil {integer}))) + (c + (Tuple2 + {PredKey} + {List integer} + MaxValue ((let - a-73453 - = List-73102 integer + a = List integer in - \(c-73454 : - integer -> - a-73453 -> - a-73453) - (n-73455 : a-73453) -> - c-73454 122880 n-73455) - (\(ds-73456 : integer) - (ds-73457 : - List-73102 integer) -> - Cons-73104 - {integer} - ds-73456 - ds-73457) - (Nil-73103 {integer}))) - n-73447))))) - (c-73402 - (Tuple2-73108 + \(c : integer -> a -> a) + (n : a) -> + c 122880 n) + (\(ds : integer) + (ds : List integer) -> + Cons {integer} ds ds) + (Nil {integer}))) + n))))) + (c + (Tuple2 {integer} - {ParamValue-73147} + {ParamValue} 3 - (ParamInteger-73149 + (ParamInteger ((let - a-73458 - = Tuple2-73107 - PredKey-73129 - (List-73102 integer) + a = Tuple2 PredKey (List integer) in - \(g-73459 : - all b-73460. - (a-73458 -> b-73460 -> b-73460) -> - b-73460 -> - b-73460) -> - g-73459 - {List-73102 a-73458} - (\(ds-73461 : a-73458) - (ds-73462 : List-73102 a-73458) -> - Cons-73104 - {a-73458} - ds-73461 - ds-73462) - (Nil-73103 {a-73458})) - (/\a-73463 -> - \(c-73464 : - Tuple2-73107 - PredKey-73129 - (List-73102 integer) -> - a-73463 -> - a-73463) - (n-73465 : a-73463) -> - c-73464 - (Tuple2-73108 - {PredKey-73129} - {List-73102 integer} - MinValue-73131 + \(g : all b. (a -> b -> b) -> b -> b) -> + g + {List a} + (\(ds : a) (ds : List a) -> + Cons {a} ds ds) + (Nil {a})) + (/\a -> + \(c : + Tuple2 PredKey (List integer) -> + a -> + a) + (n : a) -> + c + (Tuple2 + {PredKey} + {List integer} + MinValue ((let - a-73466 - = List-73102 integer + a = List integer in - \(c-73467 : - integer -> - a-73466 -> - a-73466) - (n-73468 : a-73466) -> - c-73467 0 n-73468) - (\(ds-73469 : integer) - (ds-73470 : - List-73102 integer) -> - Cons-73104 - {integer} - ds-73469 - ds-73470) - (Nil-73103 {integer}))) - (c-73464 - (Tuple2-73108 - {PredKey-73129} - {List-73102 integer} - MaxValue-73130 + \(c : integer -> a -> a) + (n : a) -> + c 0 n) + (\(ds : integer) + (ds : List integer) -> + Cons {integer} ds ds) + (Nil {integer}))) + (c + (Tuple2 + {PredKey} + {List integer} + MaxValue ((let - a-73471 - = List-73102 integer + a = List integer in - \(c-73472 : - integer -> - a-73471 -> - a-73471) - (n-73473 : a-73471) -> - c-73472 32768 n-73473) - (\(ds-73474 : integer) - (ds-73475 : - List-73102 - integer) -> - Cons-73104 - {integer} - ds-73474 - ds-73475) - (Nil-73103 {integer}))) - n-73465))))) - (c-73402 - (Tuple2-73108 + \(c : integer -> a -> a) + (n : a) -> + c 32768 n) + (\(ds : integer) + (ds : List integer) -> + Cons {integer} ds ds) + (Nil {integer}))) + n))))) + (c + (Tuple2 {integer} - {ParamValue-73147} + {ParamValue} 4 - (ParamInteger-73149 + (ParamInteger ((let - a-73476 - = Tuple2-73107 - PredKey-73129 - (List-73102 integer) + a = Tuple2 PredKey (List integer) in - \(g-73477 : - all b-73478. - (a-73476 -> - b-73478 -> - b-73478) -> - b-73478 -> - b-73478) -> - g-73477 - {List-73102 a-73476} - (\(ds-73479 : a-73476) - (ds-73480 : - List-73102 a-73476) -> - Cons-73104 - {a-73476} - ds-73479 - ds-73480) - (Nil-73103 {a-73476})) - (/\a-73481 -> - \(c-73482 : - Tuple2-73107 - PredKey-73129 - (List-73102 integer) -> - a-73481 -> - a-73481) - (n-73483 : a-73481) -> - c-73482 - (Tuple2-73108 - {PredKey-73129} - {List-73102 integer} - MinValue-73131 + \(g : + all b. (a -> b -> b) -> b -> b) -> + g + {List a} + (\(ds : a) (ds : List a) -> + Cons {a} ds ds) + (Nil {a})) + (/\a -> + \(c : + Tuple2 PredKey (List integer) -> + a -> + a) + (n : a) -> + c + (Tuple2 + {PredKey} + {List integer} + MinValue ((let - a-73484 - = List-73102 integer + a = List integer in - \(c-73485 : - integer -> - a-73484 -> - a-73484) - (n-73486 : a-73484) -> - c-73485 0 n-73486) - (\(ds-73487 : integer) - (ds-73488 : - List-73102 - integer) -> - Cons-73104 - {integer} - ds-73487 - ds-73488) - (Nil-73103 {integer}))) - (c-73482 - (Tuple2-73108 - {PredKey-73129} - {List-73102 integer} - MaxValue-73130 + \(c : integer -> a -> a) + (n : a) -> + c 0 n) + (\(ds : integer) + (ds : List integer) -> + Cons {integer} ds ds) + (Nil {integer}))) + (c + (Tuple2 + {PredKey} + {List integer} + MaxValue ((let - a-73489 - = List-73102 - integer + a = List integer in - \(c-73490 : - integer -> - a-73489 -> - a-73489) - (n-73491 : a-73489) -> - c-73490 5000 n-73491) - (\(ds-73492 : integer) - (ds-73493 : - List-73102 - integer) -> - Cons-73104 + \(c : + integer -> a -> a) + (n : a) -> + c 5000 n) + (\(ds : integer) + (ds : + List integer) -> + Cons {integer} - ds-73492 - ds-73493) - (Nil-73103 {integer}))) - n-73483))))) - (c-73402 - (Tuple2-73108 + ds + ds) + (Nil {integer}))) + n))))) + (c + (Tuple2 {integer} - {ParamValue-73147} + {ParamValue} 5 - (ParamInteger-73149 + (ParamInteger ((let - a-73494 - = Tuple2-73107 - PredKey-73129 - (List-73102 integer) + a = Tuple2 PredKey (List integer) in - \(g-73495 : - all b-73496. - (a-73494 -> - b-73496 -> - b-73496) -> - b-73496 -> - b-73496) -> - g-73495 - {List-73102 a-73494} - (\(ds-73497 : a-73494) - (ds-73498 : - List-73102 a-73494) -> - Cons-73104 - {a-73494} - ds-73497 - ds-73498) - (Nil-73103 {a-73494})) - (/\a-73499 -> - \(c-73500 : - Tuple2-73107 - PredKey-73129 - (List-73102 integer) -> - a-73499 -> - a-73499) - (n-73501 : a-73499) -> - c-73500 - (Tuple2-73108 - {PredKey-73129} - {List-73102 integer} - MinValue-73131 + \(g : + all b. + (a -> b -> b) -> b -> b) -> + g + {List a} + (\(ds : a) (ds : List a) -> + Cons {a} ds ds) + (Nil {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List integer) -> + a -> + a) + (n : a) -> + c + (Tuple2 + {PredKey} + {List integer} + MinValue ((let - a-73502 - = List-73102 - integer + a = List integer in - \(c-73503 : - integer -> - a-73502 -> - a-73502) - (n-73504 : a-73502) -> - c-73503 - 1000000 - (c-73503 - 0 - n-73504)) - (\(ds-73505 : integer) - (ds-73506 : - List-73102 - integer) -> - Cons-73104 + \(c : + integer -> a -> a) + (n : a) -> + c 1000000 (c 0 n)) + (\(ds : integer) + (ds : + List integer) -> + Cons {integer} - ds-73505 - ds-73506) - (Nil-73103 {integer}))) - (c-73500 - (Tuple2-73108 - {PredKey-73129} - {List-73102 integer} - MaxValue-73130 + ds + ds) + (Nil {integer}))) + (c + (Tuple2 + {PredKey} + {List integer} + MaxValue ((let - a-73507 - = List-73102 - integer + a = List integer in - \(c-73508 : + \(c : integer -> - a-73507 -> - a-73507) - (n-73509 : - a-73507) -> - c-73508 - 5000000 - n-73509) - (\(ds-73510 : - integer) - (ds-73511 : - List-73102 + a -> + a) + (n : a) -> + c 5000000 n) + (\(ds : integer) + (ds : + List integer) -> - Cons-73104 + Cons {integer} - ds-73510 - ds-73511) - (Nil-73103 - {integer}))) - n-73501))))) - (c-73402 - (Tuple2-73108 + ds + ds) + (Nil {integer}))) + n))))) + (c + (Tuple2 {integer} - {ParamValue-73147} + {ParamValue} 6 - (ParamInteger-73149 + (ParamInteger ((let - a-73512 - = Tuple2-73107 - PredKey-73129 - (List-73102 integer) + a + = Tuple2 + PredKey + (List integer) in - \(g-73513 : - all b-73514. - (a-73512 -> - b-73514 -> - b-73514) -> - b-73514 -> - b-73514) -> - g-73513 - {List-73102 a-73512} - (\(ds-73515 : a-73512) - (ds-73516 : - List-73102 a-73512) -> - Cons-73104 - {a-73512} - ds-73515 - ds-73516) - (Nil-73103 {a-73512})) - (/\a-73517 -> - \(c-73518 : - Tuple2-73107 - PredKey-73129 - (List-73102 integer) -> - a-73517 -> - a-73517) - (n-73519 : a-73517) -> - c-73518 - (Tuple2-73108 - {PredKey-73129} - {List-73102 integer} - MinValue-73131 + \(g : + all b. + (a -> b -> b) -> b -> b) -> + g + {List a} + (\(ds : a) (ds : List a) -> + Cons {a} ds ds) + (Nil {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List integer) -> + a -> + a) + (n : a) -> + c + (Tuple2 + {PredKey} + {List integer} + MinValue ((let - a-73520 - = List-73102 - integer + a = List integer in - \(c-73521 : + \(c : integer -> - a-73520 -> - a-73520) - (n-73522 : - a-73520) -> - c-73521 + a -> + a) + (n : a) -> + c 250000000 - (c-73521 - 0 - n-73522)) - (\(ds-73523 : - integer) - (ds-73524 : - List-73102 + (c 0 n)) + (\(ds : integer) + (ds : + List integer) -> - Cons-73104 + Cons {integer} - ds-73523 - ds-73524) - (Nil-73103 - {integer}))) - (c-73518 - (Tuple2-73108 - {PredKey-73129} - {List-73102 integer} - MaxValue-73130 + ds + ds) + (Nil {integer}))) + (c + (Tuple2 + {PredKey} + {List integer} + MaxValue ((let - a-73525 - = List-73102 + a + = List integer in - \(c-73526 : + \(c : integer -> - a-73525 -> - a-73525) - (n-73527 : - a-73525) -> - c-73526 - 500000000 - n-73527) - (\(ds-73528 : - integer) - (ds-73529 : - List-73102 + a -> + a) + (n : a) -> + c 500000000 n) + (\(ds : integer) + (ds : + List integer) -> - Cons-73104 + Cons {integer} - ds-73528 - ds-73529) - (Nil-73103 - {integer}))) - n-73519))))) - (c-73402 - (Tuple2-73108 + ds + ds) + (Nil {integer}))) + n))))) + (c + (Tuple2 {integer} - {ParamValue-73147} + {ParamValue} 7 - (ParamInteger-73149 + (ParamInteger ((let - a-73530 - = Tuple2-73107 - PredKey-73129 - (List-73102 integer) + a + = Tuple2 + PredKey + (List integer) in - \(g-73531 : - all b-73532. - (a-73530 -> - b-73532 -> - b-73532) -> - b-73532 -> - b-73532) -> - g-73531 - {List-73102 a-73530} - (\(ds-73533 : a-73530) - (ds-73534 : - List-73102 - a-73530) -> - Cons-73104 - {a-73530} - ds-73533 - ds-73534) - (Nil-73103 {a-73530})) - (/\a-73535 -> - \(c-73536 : - Tuple2-73107 - PredKey-73129 - (List-73102 - integer) -> - a-73535 -> - a-73535) - (n-73537 : a-73535) -> - c-73536 - (Tuple2-73108 - {PredKey-73129} - {List-73102 integer} - MinValue-73131 + \(g : + all b. + (a -> b -> b) -> + b -> + b) -> + g + {List a} + (\(ds : a) + (ds : List a) -> + Cons {a} ds ds) + (Nil {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List integer) -> + a -> + a) + (n : a) -> + c + (Tuple2 + {PredKey} + {List integer} + MinValue ((let - a-73538 - = List-73102 + a + = List integer in - \(c-73539 : + \(c : integer -> - a-73538 -> - a-73538) - (n-73540 : - a-73538) -> - c-73539 - 0 - n-73540) - (\(ds-73541 : - integer) - (ds-73542 : - List-73102 + a -> + a) + (n : a) -> + c 0 n) + (\(ds : integer) + (ds : + List integer) -> - Cons-73104 + Cons {integer} - ds-73541 - ds-73542) - (Nil-73103 - {integer}))) - n-73537)))) - (c-73402 - (Tuple2-73108 + ds + ds) + (Nil {integer}))) + n)))) + (c + (Tuple2 {integer} - {ParamValue-73147} + {ParamValue} 8 - (ParamInteger-73149 + (ParamInteger ((let - a-73543 - = Tuple2-73107 - PredKey-73129 - (List-73102 - integer) + a + = Tuple2 + PredKey + (List integer) in - \(g-73544 : - all b-73545. - (a-73543 -> - b-73545 -> - b-73545) -> - b-73545 -> - b-73545) -> - g-73544 - {List-73102 a-73543} - (\(ds-73546 : a-73543) - (ds-73547 : - List-73102 - a-73543) -> - Cons-73104 - {a-73543} - ds-73546 - ds-73547) - (Nil-73103 {a-73543})) - (/\a-73548 -> - \(c-73549 : - Tuple2-73107 - PredKey-73129 - (List-73102 - integer) -> - a-73548 -> - a-73548) - (n-73550 : a-73548) -> - c-73549 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - integer} - MinValue-73131 + \(g : + all b. + (a -> b -> b) -> + b -> + b) -> + g + {List a} + (\(ds : a) + (ds : List a) -> + Cons {a} ds ds) + (Nil {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List integer) -> + a -> + a) + (n : a) -> + c + (Tuple2 + {PredKey} + {List integer} + MinValue ((let - a-73551 - = List-73102 + a + = List integer in - \(c-73552 : + \(c : integer -> - a-73551 -> - a-73551) - (n-73553 : - a-73551) -> - c-73552 + a -> + a) + (n : a) -> + c 250 - (c-73552 - 0 - n-73553)) - (\(ds-73554 : + (c 0 n)) + (\(ds : integer) - (ds-73555 : - List-73102 + (ds : + List integer) -> - Cons-73104 + Cons {integer} - ds-73554 - ds-73555) - (Nil-73103 + ds + ds) + (Nil {integer}))) - (c-73549 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - integer} - MaxValue-73130 + (c + (Tuple2 + {PredKey} + {List integer} + MaxValue ((let - a-73556 - = List-73102 + a + = List integer in - \(c-73557 : + \(c : integer -> - a-73556 -> - a-73556) - (n-73558 : - a-73556) -> - c-73557 - 2000 - n-73558) - (\(ds-73559 : + a -> + a) + (n : a) -> + c 2000 n) + (\(ds : integer) - (ds-73560 : - List-73102 + (ds : + List integer) -> - Cons-73104 + Cons {integer} - ds-73559 - ds-73560) - (Nil-73103 + ds + ds) + (Nil {integer}))) - (c-73549 - (Tuple2-73108 - {PredKey-73129} - {List-73102 + (c + (Tuple2 + {PredKey} + {List integer} - NotEqual-73132 + NotEqual ((let - a-73561 - = List-73102 + a + = List integer in - \(c-73562 : + \(c : integer -> - a-73561 -> - a-73561) - (n-73563 : - a-73561) -> - c-73562 - 0 - n-73563) - (\(ds-73564 : + a -> + a) + (n : + a) -> + c 0 n) + (\(ds : integer) - (ds-73565 : - List-73102 + (ds : + List integer) -> - Cons-73104 + Cons {integer} - ds-73564 - ds-73565) - (Nil-73103 + ds + ds) + (Nil {integer}))) - n-73550)))))) - (c-73402 - (Tuple2-73108 + n)))))) + (c + (Tuple2 {integer} - {ParamValue-73147} + {ParamValue} 9 - (ParamRational-73151 + (ParamRational ((let - a-73566 - = Tuple2-73107 - PredKey-73129 - (List-73102 - Rational-73144) + a + = Tuple2 + PredKey + (List Rational) in - \(g-73567 : - all b-73568. - (a-73566 -> - b-73568 -> - b-73568) -> - b-73568 -> - b-73568) -> - g-73567 - {List-73102 a-73566} - (\(ds-73569 : - a-73566) - (ds-73570 : - List-73102 - a-73566) -> - Cons-73104 - {a-73566} - ds-73569 - ds-73570) - (Nil-73103 - {a-73566})) - (/\a-73571 -> - \(c-73572 : - Tuple2-73107 - PredKey-73129 - (List-73102 - Rational-73144) -> - a-73571 -> - a-73571) - (n-73573 : - a-73571) -> - c-73572 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - Rational-73144} - MinValue-73131 + \(g : + all b. + (a -> b -> b) -> + b -> + b) -> + g + {List a} + (\(ds : a) + (ds : List a) -> + Cons {a} ds ds) + (Nil {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List + Rational) -> + a -> + a) + (n : a) -> + c + (Tuple2 + {PredKey} + {List + Rational} + MinValue ((let - a-73574 - = List-73102 - Rational-73144 + a + = List + Rational in - \(c-73575 : - Rational-73144 -> - a-73574 -> - a-73574) - (n-73576 : - a-73574) -> - c-73575 - (unsafeRatio-73162 + \(c : + Rational -> + a -> + a) + (n : a) -> + c + (unsafeRatio 1 10) - (c-73575 - (unsafeRatio-73162 + (c + (unsafeRatio 0 1) - n-73576)) - (\(ds-73577 : - Rational-73144) - (ds-73578 : - List-73102 - Rational-73144) -> - Cons-73104 - {Rational-73144} - ds-73577 - ds-73578) - (Nil-73103 - {Rational-73144}))) - (c-73572 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - Rational-73144} - MaxValue-73130 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + (c + (Tuple2 + {PredKey} + {List + Rational} + MaxValue ((let - a-73579 - = List-73102 - Rational-73144 + a + = List + Rational in - \(c-73580 : - Rational-73144 -> - a-73579 -> - a-73579) - (n-73581 : - a-73579) -> - c-73580 - (unsafeRatio-73162 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 1) - n-73581) - (\(ds-73582 : - Rational-73144) - (ds-73583 : - List-73102 - Rational-73144) -> - Cons-73104 - {Rational-73144} - ds-73582 - ds-73583) - (Nil-73103 - {Rational-73144}))) - n-73573))))) - (c-73402 - (Tuple2-73108 + n) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + n))))) + (c + (Tuple2 {integer} - {ParamValue-73147} + {ParamValue} 10 - (ParamRational-73151 + (ParamRational ((let - a-73584 - = Tuple2-73107 - PredKey-73129 - (List-73102 - Rational-73144) + a + = Tuple2 + PredKey + (List + Rational) in - \(g-73585 : - all b-73586. - (a-73584 -> - b-73586 -> - b-73586) -> - b-73586 -> - b-73586) -> - g-73585 - {List-73102 - a-73584} - (\(ds-73587 : - a-73584) - (ds-73588 : - List-73102 - a-73584) -> - Cons-73104 - {a-73584} - ds-73587 - ds-73588) - (Nil-73103 - {a-73584})) - (/\a-73589 -> - \(c-73590 : - Tuple2-73107 - PredKey-73129 - (List-73102 - Rational-73144) -> - a-73589 -> - a-73589) - (n-73591 : - a-73589) -> - c-73590 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - Rational-73144} - MinValue-73131 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List a} + (\(ds : a) + (ds : + List a) -> + Cons + {a} + ds + ds) + (Nil {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List + Rational) -> + a -> + a) + (n : a) -> + c + (Tuple2 + {PredKey} + {List + Rational} + MinValue ((let - a-73592 - = List-73102 - Rational-73144 + a + = List + Rational in - \(c-73593 : - Rational-73144 -> - a-73592 -> - a-73592) - (n-73594 : - a-73592) -> - c-73593 - (unsafeRatio-73162 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 1000) - (c-73593 - (unsafeRatio-73162 + (c + (unsafeRatio 0 1) - n-73594)) - (\(ds-73595 : - Rational-73144) - (ds-73596 : - List-73102 - Rational-73144) -> - Cons-73104 - {Rational-73144} - ds-73595 - ds-73596) - (Nil-73103 - {Rational-73144}))) - (c-73590 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - Rational-73144} - MaxValue-73130 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + (c + (Tuple2 + {PredKey} + {List + Rational} + MaxValue ((let - a-73597 - = List-73102 - Rational-73144 + a + = List + Rational in - \(c-73598 : - Rational-73144 -> - a-73597 -> - a-73597) - (n-73599 : - a-73597) -> - c-73598 - (unsafeRatio-73162 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 200) - n-73599) - (\(ds-73600 : - Rational-73144) - (ds-73601 : - List-73102 - Rational-73144) -> - Cons-73104 - {Rational-73144} - ds-73600 - ds-73601) - (Nil-73103 - {Rational-73144}))) - n-73591))))) - (c-73402 - (Tuple2-73108 + n) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + n))))) + (c + (Tuple2 {integer} - {ParamValue-73147} + {ParamValue} 11 - (ParamRational-73151 + (ParamRational ((let - a-73602 - = Tuple2-73107 - PredKey-73129 - (List-73102 - Rational-73144) + a + = Tuple2 + PredKey + (List + Rational) in - \(g-73603 : - all b-73604. - (a-73602 -> - b-73604 -> - b-73604) -> - b-73604 -> - b-73604) -> - g-73603 - {List-73102 - a-73602} - (\(ds-73605 : - a-73602) - (ds-73606 : - List-73102 - a-73602) -> - Cons-73104 - {a-73602} - ds-73605 - ds-73606) - (Nil-73103 - {a-73602})) - (/\a-73607 -> - \(c-73608 : - Tuple2-73107 - PredKey-73129 - (List-73102 - Rational-73144) -> - a-73607 -> - a-73607) - (n-73609 : - a-73607) -> - c-73608 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - Rational-73144} - MinValue-73131 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List a} + (\(ds : a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List + Rational) -> + a -> + a) + (n : a) -> + c + (Tuple2 + {PredKey} + {List + Rational} + MinValue ((let - a-73610 - = List-73102 - Rational-73144 + a + = List + Rational in - \(c-73611 : - Rational-73144 -> - a-73610 -> - a-73610) - (n-73612 : - a-73610) -> - c-73611 - (unsafeRatio-73162 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 10) - (c-73611 - (unsafeRatio-73162 + (c + (unsafeRatio 0 1) - n-73612)) - (\(ds-73613 : - Rational-73144) - (ds-73614 : - List-73102 - Rational-73144) -> - Cons-73104 - {Rational-73144} - ds-73613 - ds-73614) - (Nil-73103 - {Rational-73144}))) - (c-73608 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - Rational-73144} - MaxValue-73130 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + (c + (Tuple2 + {PredKey} + {List + Rational} + MaxValue ((let - a-73615 - = List-73102 - Rational-73144 + a + = List + Rational in - \(c-73616 : - Rational-73144 -> - a-73615 -> - a-73615) - (n-73617 : - a-73615) -> - c-73616 - (unsafeRatio-73162 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 3 10) - (c-73616 - (unsafeRatio-73162 + (c + (unsafeRatio 1 1) - n-73617)) - (\(ds-73618 : - Rational-73144) - (ds-73619 : - List-73102 - Rational-73144) -> - Cons-73104 - {Rational-73144} - ds-73618 - ds-73619) - (Nil-73103 - {Rational-73144}))) - n-73609))))) - (c-73402 - (Tuple2-73108 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + n))))) + (c + (Tuple2 {integer} - {ParamValue-73147} + {ParamValue} 16 - (ParamInteger-73149 + (ParamInteger ((let - a-73620 - = Tuple2-73107 - PredKey-73129 - (List-73102 + a + = Tuple2 + PredKey + (List integer) in - \(g-73621 : - all b-73622. - (a-73620 -> - b-73622 -> - b-73622) -> - b-73622 -> - b-73622) -> - g-73621 - {List-73102 - a-73620} - (\(ds-73623 : - a-73620) - (ds-73624 : - List-73102 - a-73620) -> - Cons-73104 - {a-73620} - ds-73623 - ds-73624) - (Nil-73103 - {a-73620})) - (/\a-73625 -> - \(c-73626 : - Tuple2-73107 - PredKey-73129 - (List-73102 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List a} + (\(ds : a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List integer) -> - a-73625 -> - a-73625) - (n-73627 : - a-73625) -> - c-73626 - (Tuple2-73108 - {PredKey-73129} - {List-73102 + a -> + a) + (n : a) -> + c + (Tuple2 + {PredKey} + {List integer} - MinValue-73131 + MinValue ((let - a-73628 - = List-73102 + a + = List integer in - \(c-73629 : + \(c : integer -> - a-73628 -> - a-73628) - (n-73630 : - a-73628) -> - c-73629 + a -> + a) + (n : + a) -> + c 0 - n-73630) - (\(ds-73631 : + n) + (\(ds : integer) - (ds-73632 : - List-73102 + (ds : + List integer) -> - Cons-73104 + Cons {integer} - ds-73631 - ds-73632) - (Nil-73103 + ds + ds) + (Nil {integer}))) - (c-73626 - (Tuple2-73108 - {PredKey-73129} - {List-73102 + (c + (Tuple2 + {PredKey} + {List integer} - MaxValue-73130 + MaxValue ((let - a-73633 - = List-73102 + a + = List integer in - \(c-73634 : + \(c : integer -> - a-73633 -> - a-73633) - (n-73635 : - a-73633) -> - c-73634 + a -> + a) + (n : + a) -> + c 500000000 - n-73635) - (\(ds-73636 : + n) + (\(ds : integer) - (ds-73637 : - List-73102 + (ds : + List integer) -> - Cons-73104 + Cons {integer} - ds-73636 - ds-73637) - (Nil-73103 + ds + ds) + (Nil {integer}))) - n-73627))))) - (c-73402 - (Tuple2-73108 + n))))) + (c + (Tuple2 {integer} - {ParamValue-73147} + {ParamValue} 17 - (ParamInteger-73149 + (ParamInteger ((let - a-73638 - = Tuple2-73107 - PredKey-73129 - (List-73102 + a + = Tuple2 + PredKey + (List integer) in - \(g-73639 : - all b-73640. - (a-73638 -> - b-73640 -> - b-73640) -> - b-73640 -> - b-73640) -> - g-73639 - {List-73102 - a-73638} - (\(ds-73641 : - a-73638) - (ds-73642 : - List-73102 - a-73638) -> - Cons-73104 - {a-73638} - ds-73641 - ds-73642) - (Nil-73103 - {a-73638})) - (/\a-73643 -> - \(c-73644 : - Tuple2-73107 - PredKey-73129 - (List-73102 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List integer) -> - a-73643 -> - a-73643) - (n-73645 : - a-73643) -> - c-73644 - (Tuple2-73108 - {PredKey-73129} - {List-73102 + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List integer} - MinValue-73131 + MinValue ((let - a-73646 - = List-73102 + a + = List integer in - \(c-73647 : + \(c : integer -> - a-73646 -> - a-73646) - (n-73648 : - a-73646) -> - c-73647 + a -> + a) + (n : + a) -> + c 3000 - (c-73647 + (c 0 - n-73648)) - (\(ds-73649 : + n)) + (\(ds : integer) - (ds-73650 : - List-73102 + (ds : + List integer) -> - Cons-73104 + Cons {integer} - ds-73649 - ds-73650) - (Nil-73103 + ds + ds) + (Nil {integer}))) - (c-73644 - (Tuple2-73108 - {PredKey-73129} - {List-73102 + (c + (Tuple2 + {PredKey} + {List integer} - MaxValue-73130 + MaxValue ((let - a-73651 - = List-73102 + a + = List integer in - \(c-73652 : + \(c : integer -> - a-73651 -> - a-73651) - (n-73653 : - a-73651) -> - c-73652 + a -> + a) + (n : + a) -> + c 6500 - n-73653) - (\(ds-73654 : + n) + (\(ds : integer) - (ds-73655 : - List-73102 + (ds : + List integer) -> - Cons-73104 + Cons {integer} - ds-73654 - ds-73655) - (Nil-73103 + ds + ds) + (Nil {integer}))) - (c-73644 - (Tuple2-73108 - {PredKey-73129} - {List-73102 + (c + (Tuple2 + {PredKey} + {List integer} - NotEqual-73132 + NotEqual ((let - a-73656 - = List-73102 + a + = List integer in - \(c-73657 : + \(c : integer -> - a-73656 -> - a-73656) - (n-73658 : - a-73656) -> - c-73657 + a -> + a) + (n : + a) -> + c 0 - n-73658) - (\(ds-73659 : + n) + (\(ds : integer) - (ds-73660 : - List-73102 + (ds : + List integer) -> - Cons-73104 + Cons {integer} - ds-73659 - ds-73660) - (Nil-73103 + ds + ds) + (Nil {integer}))) - n-73645)))))) - (c-73402 - (Tuple2-73108 + n)))))) + (c + (Tuple2 {integer} - {ParamValue-73147} + {ParamValue} 18 - ParamAny-73148) - (c-73402 - (Tuple2-73108 + ParamAny) + (c + (Tuple2 {integer} - {ParamValue-73147} + {ParamValue} 19 - (ParamList-73150 + (ParamList ((let - a-73661 - = List-73102 - ParamValue-73147 + a + = List + ParamValue in - \(c-73662 : - ParamValue-73147 -> - a-73661 -> - a-73661) - (n-73663 : - a-73661) -> - c-73662 - (ParamRational-73151 + \(c : + ParamValue -> + a -> + a) + (n : + a) -> + c + (ParamRational ((let - a-73664 - = Tuple2-73107 - PredKey-73129 - (List-73102 - Rational-73144) + a + = Tuple2 + PredKey + (List + Rational) in - \(g-73665 : - all b-73666. - (a-73664 -> - b-73666 -> - b-73666) -> - b-73666 -> - b-73666) -> - g-73665 - {List-73102 - a-73664} - (\(ds-73667 : - a-73664) - (ds-73668 : - List-73102 - a-73664) -> - Cons-73104 - {a-73664} - ds-73667 - ds-73668) - (Nil-73103 - {a-73664})) - (/\a-73669 -> - \(c-73670 : - Tuple2-73107 - PredKey-73129 - (List-73102 - Rational-73144) -> - a-73669 -> - a-73669) - (n-73671 : - a-73669) -> - c-73670 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - Rational-73144} - MinValue-73131 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List + Rational) -> + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List + Rational} + MinValue ((let - a-73672 - = List-73102 - Rational-73144 + a + = List + Rational in - \(c-73673 : - Rational-73144 -> - a-73672 -> - a-73672) - (n-73674 : - a-73672) -> - c-73673 - (unsafeRatio-73162 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 25) - n-73674) - (\(ds-73675 : - Rational-73144) - (ds-73676 : - List-73102 - Rational-73144) -> - Cons-73104 - {Rational-73144} - ds-73675 - ds-73676) - (Nil-73103 - {Rational-73144}))) - (c-73670 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - Rational-73144} - MaxValue-73130 + n) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + (c + (Tuple2 + {PredKey} + {List + Rational} + MaxValue ((let - a-73677 - = List-73102 - Rational-73144 + a + = List + Rational in - \(c-73678 : - Rational-73144 -> - a-73677 -> - a-73677) - (n-73679 : - a-73677) -> - c-73678 - (unsafeRatio-73162 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 5) - n-73679) - (\(ds-73680 : - Rational-73144) - (ds-73681 : - List-73102 - Rational-73144) -> - Cons-73104 - {Rational-73144} - ds-73680 - ds-73681) - (Nil-73103 - {Rational-73144}))) - n-73671)))) - (c-73662 - (ParamRational-73151 + n) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + n)))) + (c + (ParamRational ((let - a-73682 - = Tuple2-73107 - PredKey-73129 - (List-73102 - Rational-73144) + a + = Tuple2 + PredKey + (List + Rational) in - \(g-73683 : - all b-73684. - (a-73682 -> - b-73684 -> - b-73684) -> - b-73684 -> - b-73684) -> - g-73683 - {List-73102 - a-73682} - (\(ds-73685 : - a-73682) - (ds-73686 : - List-73102 - a-73682) -> - Cons-73104 - {a-73682} - ds-73685 - ds-73686) - (Nil-73103 - {a-73682})) - (/\a-73687 -> - \(c-73688 : - Tuple2-73107 - PredKey-73129 - (List-73102 - Rational-73144) -> - a-73687 -> - a-73687) - (n-73689 : - a-73687) -> - c-73688 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - Rational-73144} - MinValue-73131 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List + Rational) -> + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List + Rational} + MinValue ((let - a-73690 - = List-73102 - Rational-73144 + a + = List + Rational in - \(c-73691 : - Rational-73144 -> - a-73690 -> - a-73690) - (n-73692 : - a-73690) -> - c-73691 - (unsafeRatio-73162 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 20000) - n-73692) - (\(ds-73693 : - Rational-73144) - (ds-73694 : - List-73102 - Rational-73144) -> - Cons-73104 - {Rational-73144} - ds-73693 - ds-73694) - (Nil-73103 - {Rational-73144}))) - (c-73688 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - Rational-73144} - MaxValue-73130 + n) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + (c + (Tuple2 + {PredKey} + {List + Rational} + MaxValue ((let - a-73695 - = List-73102 - Rational-73144 + a + = List + Rational in - \(c-73696 : - Rational-73144 -> - a-73695 -> - a-73695) - (n-73697 : - a-73695) -> - c-73696 - (unsafeRatio-73162 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 5000) - n-73697) - (\(ds-73698 : - Rational-73144) - (ds-73699 : - List-73102 - Rational-73144) -> - Cons-73104 - {Rational-73144} - ds-73698 - ds-73699) - (Nil-73103 - {Rational-73144}))) - n-73689)))) - n-73663)) - (\(ds-73700 : - ParamValue-73147) - (ds-73701 : - List-73102 - ParamValue-73147) -> - Cons-73104 - {ParamValue-73147} - ds-73700 - ds-73701) - (Nil-73103 - {ParamValue-73147})))) - (c-73402 - (Tuple2-73108 + n) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + n)))) + n)) + (\(ds : + ParamValue) + (ds : + List + ParamValue) -> + Cons + {ParamValue} + ds + ds) + (Nil + {ParamValue})))) + (c + (Tuple2 {integer} - {ParamValue-73147} + {ParamValue} 20 - (ParamList-73150 + (ParamList ((let - a-73702 - = List-73102 - ParamValue-73147 + a + = List + ParamValue in - \(c-73703 : - ParamValue-73147 -> - a-73702 -> - a-73702) - (n-73704 : - a-73702) -> - c-73703 - (ParamInteger-73149 + \(c : + ParamValue -> + a -> + a) + (n : + a) -> + c + (ParamInteger ((let - a-73705 - = Tuple2-73107 - PredKey-73129 - (List-73102 + a + = Tuple2 + PredKey + (List integer) in - \(g-73706 : - all b-73707. - (a-73705 -> - b-73707 -> - b-73707) -> - b-73707 -> - b-73707) -> - g-73706 - {List-73102 - a-73705} - (\(ds-73708 : - a-73705) - (ds-73709 : - List-73102 - a-73705) -> - Cons-73104 - {a-73705} - ds-73708 - ds-73709) - (Nil-73103 - {a-73705})) - (/\a-73710 -> - \(c-73711 : - Tuple2-73107 - PredKey-73129 - (List-73102 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List integer) -> - a-73710 -> - a-73710) - (n-73712 : - a-73710) -> - c-73711 - (Tuple2-73108 - {PredKey-73129} - {List-73102 + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List integer} - MinValue-73131 + MinValue ((let - a-73713 - = List-73102 + a + = List integer in - \(c-73714 : + \(c : integer -> - a-73713 -> - a-73713) - (n-73715 : - a-73713) -> - c-73714 + a -> + a) + (n : + a) -> + c 0 - n-73715) - (\(ds-73716 : + n) + (\(ds : integer) - (ds-73717 : - List-73102 + (ds : + List integer) -> - Cons-73104 + Cons {integer} - ds-73716 - ds-73717) - (Nil-73103 + ds + ds) + (Nil {integer}))) - (c-73711 - (Tuple2-73108 - {PredKey-73129} - {List-73102 + (c + (Tuple2 + {PredKey} + {List integer} - MaxValue-73130 + MaxValue ((let - a-73718 - = List-73102 + a + = List integer in - \(c-73719 : + \(c : integer -> - a-73718 -> - a-73718) - (n-73720 : - a-73718) -> - c-73719 + a -> + a) + (n : + a) -> + c 40000000 - n-73720) - (\(ds-73721 : + n) + (\(ds : integer) - (ds-73722 : - List-73102 + (ds : + List integer) -> - Cons-73104 + Cons {integer} - ds-73721 - ds-73722) - (Nil-73103 + ds + ds) + (Nil {integer}))) - n-73712)))) - (c-73703 - (ParamInteger-73149 + n)))) + (c + (ParamInteger ((let - a-73723 - = Tuple2-73107 - PredKey-73129 - (List-73102 + a + = Tuple2 + PredKey + (List integer) in - \(g-73724 : - all b-73725. - (a-73723 -> - b-73725 -> - b-73725) -> - b-73725 -> - b-73725) -> - g-73724 - {List-73102 - a-73723} - (\(ds-73726 : - a-73723) - (ds-73727 : - List-73102 - a-73723) -> - Cons-73104 - {a-73723} - ds-73726 - ds-73727) - (Nil-73103 - {a-73723})) - (/\a-73728 -> - \(c-73729 : - Tuple2-73107 - PredKey-73129 - (List-73102 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List integer) -> - a-73728 -> - a-73728) - (n-73730 : - a-73728) -> - c-73729 - (Tuple2-73108 - {PredKey-73129} - {List-73102 + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List integer} - MinValue-73131 + MinValue ((let - a-73731 - = List-73102 + a + = List integer in - \(c-73732 : + \(c : integer -> - a-73731 -> - a-73731) - (n-73733 : - a-73731) -> - c-73732 + a -> + a) + (n : + a) -> + c 0 - n-73733) - (\(ds-73734 : + n) + (\(ds : integer) - (ds-73735 : - List-73102 + (ds : + List integer) -> - Cons-73104 + Cons {integer} - ds-73734 - ds-73735) - (Nil-73103 + ds + ds) + (Nil {integer}))) - (c-73729 - (Tuple2-73108 - {PredKey-73129} - {List-73102 + (c + (Tuple2 + {PredKey} + {List integer} - MaxValue-73130 + MaxValue ((let - a-73736 - = List-73102 + a + = List integer in - \(c-73737 : + \(c : integer -> - a-73736 -> - a-73736) - (n-73738 : - a-73736) -> - c-73737 + a -> + a) + (n : + a) -> + c 15000000000 - n-73738) - (\(ds-73739 : + n) + (\(ds : integer) - (ds-73740 : - List-73102 + (ds : + List integer) -> - Cons-73104 + Cons {integer} - ds-73739 - ds-73740) - (Nil-73103 + ds + ds) + (Nil {integer}))) - n-73730)))) - n-73704)) - (\(ds-73741 : - ParamValue-73147) - (ds-73742 : - List-73102 - ParamValue-73147) -> - Cons-73104 - {ParamValue-73147} - ds-73741 - ds-73742) - (Nil-73103 - {ParamValue-73147})))) - (c-73402 - (Tuple2-73108 + n)))) + n)) + (\(ds : + ParamValue) + (ds : + List + ParamValue) -> + Cons + {ParamValue} + ds + ds) + (Nil + {ParamValue})))) + (c + (Tuple2 {integer} - {ParamValue-73147} + {ParamValue} 21 - (ParamList-73150 + (ParamList ((let - a-73743 - = List-73102 - ParamValue-73147 + a + = List + ParamValue in - \(c-73744 : - ParamValue-73147 -> - a-73743 -> - a-73743) - (n-73745 : - a-73743) -> - c-73744 - (ParamInteger-73149 + \(c : + ParamValue -> + a -> + a) + (n : + a) -> + c + (ParamInteger ((let - a-73746 - = Tuple2-73107 - PredKey-73129 - (List-73102 + a + = Tuple2 + PredKey + (List integer) in - \(g-73747 : - all b-73748. - (a-73746 -> - b-73748 -> - b-73748) -> - b-73748 -> - b-73748) -> - g-73747 - {List-73102 - a-73746} - (\(ds-73749 : - a-73746) - (ds-73750 : - List-73102 - a-73746) -> - Cons-73104 - {a-73746} - ds-73749 - ds-73750) - (Nil-73103 - {a-73746})) - (/\a-73751 -> - \(c-73752 : - Tuple2-73107 - PredKey-73129 - (List-73102 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List integer) -> - a-73751 -> - a-73751) - (n-73753 : - a-73751) -> - c-73752 - (Tuple2-73108 - {PredKey-73129} - {List-73102 + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List integer} - MinValue-73131 + MinValue ((let - a-73754 - = List-73102 + a + = List integer in - \(c-73755 : + \(c : integer -> - a-73754 -> - a-73754) - (n-73756 : - a-73754) -> - c-73755 + a -> + a) + (n : + a) -> + c 0 - n-73756) - (\(ds-73757 : + n) + (\(ds : integer) - (ds-73758 : - List-73102 + (ds : + List integer) -> - Cons-73104 + Cons {integer} - ds-73757 - ds-73758) - (Nil-73103 + ds + ds) + (Nil {integer}))) - (c-73752 - (Tuple2-73108 - {PredKey-73129} - {List-73102 + (c + (Tuple2 + {PredKey} + {List integer} - MaxValue-73130 + MaxValue ((let - a-73759 - = List-73102 + a + = List integer in - \(c-73760 : + \(c : integer -> - a-73759 -> - a-73759) - (n-73761 : - a-73759) -> - c-73760 + a -> + a) + (n : + a) -> + c 120000000 - n-73761) - (\(ds-73762 : + n) + (\(ds : integer) - (ds-73763 : - List-73102 + (ds : + List integer) -> - Cons-73104 + Cons {integer} - ds-73762 - ds-73763) - (Nil-73103 + ds + ds) + (Nil {integer}))) - n-73753)))) - (c-73744 - (ParamInteger-73149 + n)))) + (c + (ParamInteger ((let - a-73764 - = Tuple2-73107 - PredKey-73129 - (List-73102 + a + = Tuple2 + PredKey + (List integer) in - \(g-73765 : - all b-73766. - (a-73764 -> - b-73766 -> - b-73766) -> - b-73766 -> - b-73766) -> - g-73765 - {List-73102 - a-73764} - (\(ds-73767 : - a-73764) - (ds-73768 : - List-73102 - a-73764) -> - Cons-73104 - {a-73764} - ds-73767 - ds-73768) - (Nil-73103 - {a-73764})) - (/\a-73769 -> - \(c-73770 : - Tuple2-73107 - PredKey-73129 - (List-73102 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List integer) -> - a-73769 -> - a-73769) - (n-73771 : - a-73769) -> - c-73770 - (Tuple2-73108 - {PredKey-73129} - {List-73102 + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List integer} - MinValue-73131 + MinValue ((let - a-73772 - = List-73102 + a + = List integer in - \(c-73773 : + \(c : integer -> - a-73772 -> - a-73772) - (n-73774 : - a-73772) -> - c-73773 + a -> + a) + (n : + a) -> + c 0 - n-73774) - (\(ds-73775 : + n) + (\(ds : integer) - (ds-73776 : - List-73102 + (ds : + List integer) -> - Cons-73104 + Cons {integer} - ds-73775 - ds-73776) - (Nil-73103 + ds + ds) + (Nil {integer}))) - (c-73770 - (Tuple2-73108 - {PredKey-73129} - {List-73102 + (c + (Tuple2 + {PredKey} + {List integer} - MaxValue-73130 + MaxValue ((let - a-73777 - = List-73102 + a + = List integer in - \(c-73778 : + \(c : integer -> - a-73777 -> - a-73777) - (n-73779 : - a-73777) -> - c-73778 + a -> + a) + (n : + a) -> + c 40000000000 - n-73779) - (\(ds-73780 : + n) + (\(ds : integer) - (ds-73781 : - List-73102 + (ds : + List integer) -> - Cons-73104 + Cons {integer} - ds-73780 - ds-73781) - (Nil-73103 + ds + ds) + (Nil {integer}))) - n-73771)))) - n-73745)) - (\(ds-73782 : - ParamValue-73147) - (ds-73783 : - List-73102 - ParamValue-73147) -> - Cons-73104 - {ParamValue-73147} - ds-73782 - ds-73783) - (Nil-73103 - {ParamValue-73147})))) - (c-73402 - (Tuple2-73108 + n)))) + n)) + (\(ds : + ParamValue) + (ds : + List + ParamValue) -> + Cons + {ParamValue} + ds + ds) + (Nil + {ParamValue})))) + (c + (Tuple2 {integer} - {ParamValue-73147} + {ParamValue} 22 - (ParamInteger-73149 + (ParamInteger ((let - a-73784 - = Tuple2-73107 - PredKey-73129 - (List-73102 + a + = Tuple2 + PredKey + (List integer) in - \(g-73785 : - all b-73786. - (a-73784 -> - b-73786 -> - b-73786) -> - b-73786 -> - b-73786) -> - g-73785 - {List-73102 - a-73784} - (\(ds-73787 : - a-73784) - (ds-73788 : - List-73102 - a-73784) -> - Cons-73104 - {a-73784} - ds-73787 - ds-73788) - (Nil-73103 - {a-73784})) - (/\a-73789 -> - \(c-73790 : - Tuple2-73107 - PredKey-73129 - (List-73102 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List integer) -> - a-73789 -> - a-73789) - (n-73791 : - a-73789) -> - c-73790 - (Tuple2-73108 - {PredKey-73129} - {List-73102 + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List integer} - MinValue-73131 + MinValue ((let - a-73792 - = List-73102 + a + = List integer in - \(c-73793 : + \(c : integer -> - a-73792 -> - a-73792) - (n-73794 : - a-73792) -> - c-73793 + a -> + a) + (n : + a) -> + c 0 - n-73794) - (\(ds-73795 : + n) + (\(ds : integer) - (ds-73796 : - List-73102 + (ds : + List integer) -> - Cons-73104 + Cons {integer} - ds-73795 - ds-73796) - (Nil-73103 + ds + ds) + (Nil {integer}))) - (c-73790 - (Tuple2-73108 - {PredKey-73129} - {List-73102 + (c + (Tuple2 + {PredKey} + {List integer} - MaxValue-73130 + MaxValue ((let - a-73797 - = List-73102 + a + = List integer in - \(c-73798 : + \(c : integer -> - a-73797 -> - a-73797) - (n-73799 : - a-73797) -> - c-73798 + a -> + a) + (n : + a) -> + c 12288 - n-73799) - (\(ds-73800 : + n) + (\(ds : integer) - (ds-73801 : - List-73102 + (ds : + List integer) -> - Cons-73104 + Cons {integer} - ds-73800 - ds-73801) - (Nil-73103 + ds + ds) + (Nil {integer}))) - n-73791))))) - (c-73402 - (Tuple2-73108 + n))))) + (c + (Tuple2 {integer} - {ParamValue-73147} + {ParamValue} 23 - (ParamInteger-73149 + (ParamInteger ((let - a-73802 - = Tuple2-73107 - PredKey-73129 - (List-73102 + a + = Tuple2 + PredKey + (List integer) in - \(g-73803 : - all b-73804. - (a-73802 -> - b-73804 -> - b-73804) -> - b-73804 -> - b-73804) -> - g-73803 - {List-73102 - a-73802} - (\(ds-73805 : - a-73802) - (ds-73806 : - List-73102 - a-73802) -> - Cons-73104 - {a-73802} - ds-73805 - ds-73806) - (Nil-73103 - {a-73802})) - (/\a-73807 -> - \(c-73808 : - Tuple2-73107 - PredKey-73129 - (List-73102 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List integer) -> - a-73807 -> - a-73807) - (n-73809 : - a-73807) -> - c-73808 - (Tuple2-73108 - {PredKey-73129} - {List-73102 + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List integer} - MinValue-73131 + MinValue ((let - a-73810 - = List-73102 + a + = List integer in - \(c-73811 : + \(c : integer -> - a-73810 -> - a-73810) - (n-73812 : - a-73810) -> - c-73811 + a -> + a) + (n : + a) -> + c 100 - (c-73811 + (c 0 - n-73812)) - (\(ds-73813 : + n)) + (\(ds : integer) - (ds-73814 : - List-73102 + (ds : + List integer) -> - Cons-73104 + Cons {integer} - ds-73813 - ds-73814) - (Nil-73103 + ds + ds) + (Nil {integer}))) - (c-73808 - (Tuple2-73108 - {PredKey-73129} - {List-73102 + (c + (Tuple2 + {PredKey} + {List integer} - MaxValue-73130 + MaxValue ((let - a-73815 - = List-73102 + a + = List integer in - \(c-73816 : + \(c : integer -> - a-73815 -> - a-73815) - (n-73817 : - a-73815) -> - c-73816 + a -> + a) + (n : + a) -> + c 200 - n-73817) - (\(ds-73818 : + n) + (\(ds : integer) - (ds-73819 : - List-73102 + (ds : + List integer) -> - Cons-73104 + Cons {integer} - ds-73818 - ds-73819) - (Nil-73103 + ds + ds) + (Nil {integer}))) - (c-73808 - (Tuple2-73108 - {PredKey-73129} - {List-73102 + (c + (Tuple2 + {PredKey} + {List integer} - NotEqual-73132 + NotEqual ((let - a-73820 - = List-73102 + a + = List integer in - \(c-73821 : + \(c : integer -> - a-73820 -> - a-73820) - (n-73822 : - a-73820) -> - c-73821 + a -> + a) + (n : + a) -> + c 0 - n-73822) - (\(ds-73823 : + n) + (\(ds : integer) - (ds-73824 : - List-73102 + (ds : + List integer) -> - Cons-73104 + Cons {integer} - ds-73823 - ds-73824) - (Nil-73103 + ds + ds) + (Nil {integer}))) - n-73809)))))) - (c-73402 - (Tuple2-73108 + n)))))) + (c + (Tuple2 {integer} - {ParamValue-73147} + {ParamValue} 24 - (ParamInteger-73149 + (ParamInteger ((let - a-73825 - = Tuple2-73107 - PredKey-73129 - (List-73102 + a + = Tuple2 + PredKey + (List integer) in - \(g-73826 : - all b-73827. - (a-73825 -> - b-73827 -> - b-73827) -> - b-73827 -> - b-73827) -> - g-73826 - {List-73102 - a-73825} - (\(ds-73828 : - a-73825) - (ds-73829 : - List-73102 - a-73825) -> - Cons-73104 - {a-73825} - ds-73828 - ds-73829) - (Nil-73103 - {a-73825})) - (/\a-73830 -> - \(c-73831 : - Tuple2-73107 - PredKey-73129 - (List-73102 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List integer) -> - a-73830 -> - a-73830) - (n-73832 : - a-73830) -> - c-73831 - (Tuple2-73108 - {PredKey-73129} - {List-73102 + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List integer} - MinValue-73131 + MinValue ((let - a-73833 - = List-73102 + a + = List integer in - \(c-73834 : + \(c : integer -> - a-73833 -> - a-73833) - (n-73835 : - a-73833) -> - c-73834 + a -> + a) + (n : + a) -> + c 1 - n-73835) - (\(ds-73836 : + n) + (\(ds : integer) - (ds-73837 : - List-73102 + (ds : + List integer) -> - Cons-73104 + Cons {integer} - ds-73836 - ds-73837) - (Nil-73103 + ds + ds) + (Nil {integer}))) - n-73832)))) - (c-73402 - (Tuple2-73108 + n)))) + (c + (Tuple2 {integer} - {ParamValue-73147} + {ParamValue} 25 - (ParamList-73150 + (ParamList ((let - a-73838 - = List-73102 - ParamValue-73147 + a + = List + ParamValue in - \(c-73839 : - ParamValue-73147 -> - a-73838 -> - a-73838) - (n-73840 : - a-73838) -> - c-73839 - (ParamRational-73151 + \(c : + ParamValue -> + a -> + a) + (n : + a) -> + c + (ParamRational ((let - a-73841 - = Tuple2-73107 - PredKey-73129 - (List-73102 - Rational-73144) + a + = Tuple2 + PredKey + (List + Rational) in - \(g-73842 : - all b-73843. - (a-73841 -> - b-73843 -> - b-73843) -> - b-73843 -> - b-73843) -> - g-73842 - {List-73102 - a-73841} - (\(ds-73844 : - a-73841) - (ds-73845 : - List-73102 - a-73841) -> - Cons-73104 - {a-73841} - ds-73844 - ds-73845) - (Nil-73103 - {a-73841})) - (/\a-73846 -> - \(c-73847 : - Tuple2-73107 - PredKey-73129 - (List-73102 - Rational-73144) -> - a-73846 -> - a-73846) - (n-73848 : - a-73846) -> - c-73847 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - Rational-73144} - MinValue-73131 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List + Rational) -> + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List + Rational} + MinValue ((let - a-73849 - = List-73102 - Rational-73144 + a + = List + Rational in - \(c-73850 : - Rational-73144 -> - a-73849 -> - a-73849) - (n-73851 : - a-73849) -> - c-73850 - (unsafeRatio-73162 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 2) - (c-73850 - (unsafeRatio-73162 + (c + (unsafeRatio 51 100) - n-73851)) - (\(ds-73852 : - Rational-73144) - (ds-73853 : - List-73102 - Rational-73144) -> - Cons-73104 - {Rational-73144} - ds-73852 - ds-73853) - (Nil-73103 - {Rational-73144}))) - (c-73847 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - Rational-73144} - MaxValue-73130 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + (c + (Tuple2 + {PredKey} + {List + Rational} + MaxValue ((let - a-73854 - = List-73102 - Rational-73144 + a + = List + Rational in - \(c-73855 : - Rational-73144 -> - a-73854 -> - a-73854) - (n-73856 : - a-73854) -> - c-73855 - (unsafeRatio-73162 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 1) - (c-73855 - (unsafeRatio-73162 + (c + (unsafeRatio 3 4) - n-73856)) - (\(ds-73857 : - Rational-73144) - (ds-73858 : - List-73102 - Rational-73144) -> - Cons-73104 - {Rational-73144} - ds-73857 - ds-73858) - (Nil-73103 - {Rational-73144}))) - n-73848)))) - (c-73839 - (ParamRational-73151 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + n)))) + (c + (ParamRational ((let - a-73859 - = Tuple2-73107 - PredKey-73129 - (List-73102 - Rational-73144) + a + = Tuple2 + PredKey + (List + Rational) in - \(g-73860 : - all b-73861. - (a-73859 -> - b-73861 -> - b-73861) -> - b-73861 -> - b-73861) -> - g-73860 - {List-73102 - a-73859} - (\(ds-73862 : - a-73859) - (ds-73863 : - List-73102 - a-73859) -> - Cons-73104 - {a-73859} - ds-73862 - ds-73863) - (Nil-73103 - {a-73859})) - (/\a-73864 -> - \(c-73865 : - Tuple2-73107 - PredKey-73129 - (List-73102 - Rational-73144) -> - a-73864 -> - a-73864) - (n-73866 : - a-73864) -> - c-73865 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - Rational-73144} - MinValue-73131 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List + Rational) -> + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List + Rational} + MinValue ((let - a-73867 - = List-73102 - Rational-73144 + a + = List + Rational in - \(c-73868 : - Rational-73144 -> - a-73867 -> - a-73867) - (n-73869 : - a-73867) -> - c-73868 - (unsafeRatio-73162 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 2) - (c-73868 - (unsafeRatio-73162 + (c + (unsafeRatio 51 100) - n-73869)) - (\(ds-73870 : - Rational-73144) - (ds-73871 : - List-73102 - Rational-73144) -> - Cons-73104 - {Rational-73144} - ds-73870 - ds-73871) - (Nil-73103 - {Rational-73144}))) - (c-73865 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - Rational-73144} - MaxValue-73130 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + (c + (Tuple2 + {PredKey} + {List + Rational} + MaxValue ((let - a-73872 - = List-73102 - Rational-73144 + a + = List + Rational in - \(c-73873 : - Rational-73144 -> - a-73872 -> - a-73872) - (n-73874 : - a-73872) -> - c-73873 - (unsafeRatio-73162 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 1) - (c-73873 - (unsafeRatio-73162 + (c + (unsafeRatio 9 10) - n-73874)) - (\(ds-73875 : - Rational-73144) - (ds-73876 : - List-73102 - Rational-73144) -> - Cons-73104 - {Rational-73144} - ds-73875 - ds-73876) - (Nil-73103 - {Rational-73144}))) - n-73866)))) - (c-73839 - (ParamRational-73151 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + n)))) + (c + (ParamRational ((let - a-73877 - = Tuple2-73107 - PredKey-73129 - (List-73102 - Rational-73144) + a + = Tuple2 + PredKey + (List + Rational) in - \(g-73878 : - all b-73879. - (a-73877 -> - b-73879 -> - b-73879) -> - b-73879 -> - b-73879) -> - g-73878 - {List-73102 - a-73877} - (\(ds-73880 : - a-73877) - (ds-73881 : - List-73102 - a-73877) -> - Cons-73104 - {a-73877} - ds-73880 - ds-73881) - (Nil-73103 - {a-73877})) - (/\a-73882 -> - \(c-73883 : - Tuple2-73107 - PredKey-73129 - (List-73102 - Rational-73144) -> - a-73882 -> - a-73882) - (n-73884 : - a-73882) -> - c-73883 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - Rational-73144} - MinValue-73131 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List + Rational) -> + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List + Rational} + MinValue ((let - a-73885 - = List-73102 - Rational-73144 + a + = List + Rational in - \(c-73886 : - Rational-73144 -> - a-73885 -> - a-73885) - (n-73887 : - a-73885) -> - c-73886 - (unsafeRatio-73162 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 2) - (c-73886 - (unsafeRatio-73162 + (c + (unsafeRatio 51 100) - n-73887)) - (\(ds-73888 : - Rational-73144) - (ds-73889 : - List-73102 - Rational-73144) -> - Cons-73104 - {Rational-73144} - ds-73888 - ds-73889) - (Nil-73103 - {Rational-73144}))) - (c-73883 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - Rational-73144} - MaxValue-73130 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + (c + (Tuple2 + {PredKey} + {List + Rational} + MaxValue ((let - a-73890 - = List-73102 - Rational-73144 + a + = List + Rational in - \(c-73891 : - Rational-73144 -> - a-73890 -> - a-73890) - (n-73892 : - a-73890) -> - c-73891 - (unsafeRatio-73162 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 1) - (c-73891 - (unsafeRatio-73162 + (c + (unsafeRatio 9 10) - n-73892)) - (\(ds-73893 : - Rational-73144) - (ds-73894 : - List-73102 - Rational-73144) -> - Cons-73104 - {Rational-73144} - ds-73893 - ds-73894) - (Nil-73103 - {Rational-73144}))) - n-73884)))) - (c-73839 - (ParamRational-73151 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + n)))) + (c + (ParamRational ((let - a-73895 - = Tuple2-73107 - PredKey-73129 - (List-73102 - Rational-73144) + a + = Tuple2 + PredKey + (List + Rational) in - \(g-73896 : - all b-73897. - (a-73895 -> - b-73897 -> - b-73897) -> - b-73897 -> - b-73897) -> - g-73896 - {List-73102 - a-73895} - (\(ds-73898 : - a-73895) - (ds-73899 : - List-73102 - a-73895) -> - Cons-73104 - {a-73895} - ds-73898 - ds-73899) - (Nil-73103 - {a-73895})) - (/\a-73900 -> - \(c-73901 : - Tuple2-73107 - PredKey-73129 - (List-73102 - Rational-73144) -> - a-73900 -> - a-73900) - (n-73902 : - a-73900) -> - c-73901 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - Rational-73144} - MinValue-73131 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List + Rational) -> + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List + Rational} + MinValue ((let - a-73903 - = List-73102 - Rational-73144 + a + = List + Rational in - \(c-73904 : - Rational-73144 -> - a-73903 -> - a-73903) - (n-73905 : - a-73903) -> - c-73904 - (unsafeRatio-73162 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 2) - (c-73904 - (unsafeRatio-73162 + (c + (unsafeRatio 51 100) - n-73905)) - (\(ds-73906 : - Rational-73144) - (ds-73907 : - List-73102 - Rational-73144) -> - Cons-73104 - {Rational-73144} - ds-73906 - ds-73907) - (Nil-73103 - {Rational-73144}))) - (c-73901 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - Rational-73144} - MaxValue-73130 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + (c + (Tuple2 + {PredKey} + {List + Rational} + MaxValue ((let - a-73908 - = List-73102 - Rational-73144 + a + = List + Rational in - \(c-73909 : - Rational-73144 -> - a-73908 -> - a-73908) - (n-73910 : - a-73908) -> - c-73909 - (unsafeRatio-73162 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 1) - (c-73909 - (unsafeRatio-73162 + (c + (unsafeRatio 4 5) - n-73910)) - (\(ds-73911 : - Rational-73144) - (ds-73912 : - List-73102 - Rational-73144) -> - Cons-73104 - {Rational-73144} - ds-73911 - ds-73912) - (Nil-73103 - {Rational-73144}))) - n-73902)))) - (c-73839 - (ParamRational-73151 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + n)))) + (c + (ParamRational ((let - a-73913 - = Tuple2-73107 - PredKey-73129 - (List-73102 - Rational-73144) + a + = Tuple2 + PredKey + (List + Rational) in - \(g-73914 : - all b-73915. - (a-73913 -> - b-73915 -> - b-73915) -> - b-73915 -> - b-73915) -> - g-73914 - {List-73102 - a-73913} - (\(ds-73916 : - a-73913) - (ds-73917 : - List-73102 - a-73913) -> - Cons-73104 - {a-73913} - ds-73916 - ds-73917) - (Nil-73103 - {a-73913})) - (/\a-73918 -> - \(c-73919 : - Tuple2-73107 - PredKey-73129 - (List-73102 - Rational-73144) -> - a-73918 -> - a-73918) - (n-73920 : - a-73918) -> - c-73919 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - Rational-73144} - MinValue-73131 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List + Rational) -> + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List + Rational} + MinValue ((let - a-73921 - = List-73102 - Rational-73144 + a + = List + Rational in - \(c-73922 : - Rational-73144 -> - a-73921 -> - a-73921) - (n-73923 : - a-73921) -> - c-73922 - (unsafeRatio-73162 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 2) - n-73923) - (\(ds-73924 : - Rational-73144) - (ds-73925 : - List-73102 - Rational-73144) -> - Cons-73104 - {Rational-73144} - ds-73924 - ds-73925) - (Nil-73103 - {Rational-73144}))) - (c-73919 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - Rational-73144} - MaxValue-73130 + n) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + (c + (Tuple2 + {PredKey} + {List + Rational} + MaxValue ((let - a-73926 - = List-73102 - Rational-73144 + a + = List + Rational in - \(c-73927 : - Rational-73144 -> - a-73926 -> - a-73926) - (n-73928 : - a-73926) -> - c-73927 - (unsafeRatio-73162 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 1) - n-73928) - (\(ds-73929 : - Rational-73144) - (ds-73930 : - List-73102 - Rational-73144) -> - Cons-73104 - {Rational-73144} - ds-73929 - ds-73930) - (Nil-73103 - {Rational-73144}))) - n-73920)))) - n-73840))))) - (\(ds-73931 : - ParamValue-73147) - (ds-73932 : - List-73102 - ParamValue-73147) -> - Cons-73104 - {ParamValue-73147} - ds-73931 - ds-73932) - (Nil-73103 - {ParamValue-73147})))) - (c-73402 - (Tuple2-73108 + n) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + n)))) + n))))) + (\(ds : + ParamValue) + (ds : + List + ParamValue) -> + Cons + {ParamValue} + ds + ds) + (Nil + {ParamValue})))) + (c + (Tuple2 {integer} - {ParamValue-73147} + {ParamValue} 26 - (ParamList-73150 + (ParamList ((let - a-73933 - = List-73102 - ParamValue-73147 + a + = List + ParamValue in - \(c-73934 : - ParamValue-73147 -> - a-73933 -> - a-73933) - (n-73935 : - a-73933) -> - c-73934 - (ParamRational-73151 + \(c : + ParamValue -> + a -> + a) + (n : + a) -> + c + (ParamRational ((let - a-73936 - = Tuple2-73107 - PredKey-73129 - (List-73102 - Rational-73144) + a + = Tuple2 + PredKey + (List + Rational) in - \(g-73937 : - all b-73938. - (a-73936 -> - b-73938 -> - b-73938) -> - b-73938 -> - b-73938) -> - g-73937 - {List-73102 - a-73936} - (\(ds-73939 : - a-73936) - (ds-73940 : - List-73102 - a-73936) -> - Cons-73104 - {a-73936} - ds-73939 - ds-73940) - (Nil-73103 - {a-73936})) - (/\a-73941 -> - \(c-73942 : - Tuple2-73107 - PredKey-73129 - (List-73102 - Rational-73144) -> - a-73941 -> - a-73941) - (n-73943 : - a-73941) -> - c-73942 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - Rational-73144} - MinValue-73131 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List + Rational) -> + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List + Rational} + MinValue ((let - a-73944 - = List-73102 - Rational-73144 + a + = List + Rational in - \(c-73945 : - Rational-73144 -> - a-73944 -> - a-73944) - (n-73946 : - a-73944) -> - c-73945 - (unsafeRatio-73162 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 2) - (c-73945 - (unsafeRatio-73162 + (c + (unsafeRatio 51 100) - n-73946)) - (\(ds-73947 : - Rational-73144) - (ds-73948 : - List-73102 - Rational-73144) -> - Cons-73104 - {Rational-73144} - ds-73947 - ds-73948) - (Nil-73103 - {Rational-73144}))) - (c-73942 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - Rational-73144} - MaxValue-73130 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + (c + (Tuple2 + {PredKey} + {List + Rational} + MaxValue ((let - a-73949 - = List-73102 - Rational-73144 + a + = List + Rational in - \(c-73950 : - Rational-73144 -> - a-73949 -> - a-73949) - (n-73951 : - a-73949) -> - c-73950 - (unsafeRatio-73162 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 1) - (c-73950 - (unsafeRatio-73162 + (c + (unsafeRatio 3 4) - n-73951)) - (\(ds-73952 : - Rational-73144) - (ds-73953 : - List-73102 - Rational-73144) -> - Cons-73104 - {Rational-73144} - ds-73952 - ds-73953) - (Nil-73103 - {Rational-73144}))) - n-73943)))) - (c-73934 - (ParamRational-73151 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + n)))) + (c + (ParamRational ((let - a-73954 - = Tuple2-73107 - PredKey-73129 - (List-73102 - Rational-73144) + a + = Tuple2 + PredKey + (List + Rational) in - \(g-73955 : - all b-73956. - (a-73954 -> - b-73956 -> - b-73956) -> - b-73956 -> - b-73956) -> - g-73955 - {List-73102 - a-73954} - (\(ds-73957 : - a-73954) - (ds-73958 : - List-73102 - a-73954) -> - Cons-73104 - {a-73954} - ds-73957 - ds-73958) - (Nil-73103 - {a-73954})) - (/\a-73959 -> - \(c-73960 : - Tuple2-73107 - PredKey-73129 - (List-73102 - Rational-73144) -> - a-73959 -> - a-73959) - (n-73961 : - a-73959) -> - c-73960 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - Rational-73144} - MinValue-73131 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List + Rational) -> + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List + Rational} + MinValue ((let - a-73962 - = List-73102 - Rational-73144 + a + = List + Rational in - \(c-73963 : - Rational-73144 -> - a-73962 -> - a-73962) - (n-73964 : - a-73962) -> - c-73963 - (unsafeRatio-73162 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 2) - (c-73963 - (unsafeRatio-73162 + (c + (unsafeRatio 51 100) - n-73964)) - (\(ds-73965 : - Rational-73144) - (ds-73966 : - List-73102 - Rational-73144) -> - Cons-73104 - {Rational-73144} - ds-73965 - ds-73966) - (Nil-73103 - {Rational-73144}))) - (c-73960 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - Rational-73144} - MaxValue-73130 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + (c + (Tuple2 + {PredKey} + {List + Rational} + MaxValue ((let - a-73967 - = List-73102 - Rational-73144 + a + = List + Rational in - \(c-73968 : - Rational-73144 -> - a-73967 -> - a-73967) - (n-73969 : - a-73967) -> - c-73968 - (unsafeRatio-73162 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 1) - (c-73968 - (unsafeRatio-73162 + (c + (unsafeRatio 9 10) - n-73969)) - (\(ds-73970 : - Rational-73144) - (ds-73971 : - List-73102 - Rational-73144) -> - Cons-73104 - {Rational-73144} - ds-73970 - ds-73971) - (Nil-73103 - {Rational-73144}))) - n-73961)))) - (c-73934 - (ParamRational-73151 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + n)))) + (c + (ParamRational ((let - a-73972 - = Tuple2-73107 - PredKey-73129 - (List-73102 - Rational-73144) + a + = Tuple2 + PredKey + (List + Rational) in - \(g-73973 : - all b-73974. - (a-73972 -> - b-73974 -> - b-73974) -> - b-73974 -> - b-73974) -> - g-73973 - {List-73102 - a-73972} - (\(ds-73975 : - a-73972) - (ds-73976 : - List-73102 - a-73972) -> - Cons-73104 - {a-73972} - ds-73975 - ds-73976) - (Nil-73103 - {a-73972})) - (/\a-73977 -> - \(c-73978 : - Tuple2-73107 - PredKey-73129 - (List-73102 - Rational-73144) -> - a-73977 -> - a-73977) - (n-73979 : - a-73977) -> - c-73978 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - Rational-73144} - MinValue-73131 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List + Rational) -> + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List + Rational} + MinValue ((let - a-73980 - = List-73102 - Rational-73144 + a + = List + Rational in - \(c-73981 : - Rational-73144 -> - a-73980 -> - a-73980) - (n-73982 : - a-73980) -> - c-73981 - (unsafeRatio-73162 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 2) - (c-73981 - (unsafeRatio-73162 + (c + (unsafeRatio 51 100) - n-73982)) - (\(ds-73983 : - Rational-73144) - (ds-73984 : - List-73102 - Rational-73144) -> - Cons-73104 - {Rational-73144} - ds-73983 - ds-73984) - (Nil-73103 - {Rational-73144}))) - (c-73978 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - Rational-73144} - MaxValue-73130 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + (c + (Tuple2 + {PredKey} + {List + Rational} + MaxValue ((let - a-73985 - = List-73102 - Rational-73144 + a + = List + Rational in - \(c-73986 : - Rational-73144 -> - a-73985 -> - a-73985) - (n-73987 : - a-73985) -> - c-73986 - (unsafeRatio-73162 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 1) - (c-73986 - (unsafeRatio-73162 + (c + (unsafeRatio 9 10) - n-73987)) - (\(ds-73988 : - Rational-73144) - (ds-73989 : - List-73102 - Rational-73144) -> - Cons-73104 - {Rational-73144} - ds-73988 - ds-73989) - (Nil-73103 - {Rational-73144}))) - n-73979)))) - (c-73934 - (ParamRational-73151 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + n)))) + (c + (ParamRational ((let - a-73990 - = Tuple2-73107 - PredKey-73129 - (List-73102 - Rational-73144) + a + = Tuple2 + PredKey + (List + Rational) in - \(g-73991 : - all b-73992. - (a-73990 -> - b-73992 -> - b-73992) -> - b-73992 -> - b-73992) -> - g-73991 - {List-73102 - a-73990} - (\(ds-73993 : - a-73990) - (ds-73994 : - List-73102 - a-73990) -> - Cons-73104 - {a-73990} - ds-73993 - ds-73994) - (Nil-73103 - {a-73990})) - (/\a-73995 -> - \(c-73996 : - Tuple2-73107 - PredKey-73129 - (List-73102 - Rational-73144) -> - a-73995 -> - a-73995) - (n-73997 : - a-73995) -> - c-73996 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - Rational-73144} - MinValue-73131 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List + Rational) -> + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List + Rational} + MinValue ((let - a-73998 - = List-73102 - Rational-73144 + a + = List + Rational in - \(c-73999 : - Rational-73144 -> - a-73998 -> - a-73998) - (n-74000 : - a-73998) -> - c-73999 - (unsafeRatio-73162 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 2) - (c-73999 - (unsafeRatio-73162 + (c + (unsafeRatio 13 20) - n-74000)) - (\(ds-74001 : - Rational-73144) - (ds-74002 : - List-73102 - Rational-73144) -> - Cons-73104 - {Rational-73144} - ds-74001 - ds-74002) - (Nil-73103 - {Rational-73144}))) - (c-73996 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - Rational-73144} - MaxValue-73130 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + (c + (Tuple2 + {PredKey} + {List + Rational} + MaxValue ((let - a-74003 - = List-73102 - Rational-73144 + a + = List + Rational in - \(c-74004 : - Rational-73144 -> - a-74003 -> - a-74003) - (n-74005 : - a-74003) -> - c-74004 - (unsafeRatio-73162 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 1) - (c-74004 - (unsafeRatio-73162 + (c + (unsafeRatio 9 10) - n-74005)) - (\(ds-74006 : - Rational-73144) - (ds-74007 : - List-73102 - Rational-73144) -> - Cons-73104 - {Rational-73144} - ds-74006 - ds-74007) - (Nil-73103 - {Rational-73144}))) - n-73997)))) - (c-73934 - (ParamRational-73151 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + n)))) + (c + (ParamRational ((let - a-74008 - = Tuple2-73107 - PredKey-73129 - (List-73102 - Rational-73144) + a + = Tuple2 + PredKey + (List + Rational) in - \(g-74009 : - all b-74010. - (a-74008 -> - b-74010 -> - b-74010) -> - b-74010 -> - b-74010) -> - g-74009 - {List-73102 - a-74008} - (\(ds-74011 : - a-74008) - (ds-74012 : - List-73102 - a-74008) -> - Cons-73104 - {a-74008} - ds-74011 - ds-74012) - (Nil-73103 - {a-74008})) - (/\a-74013 -> - \(c-74014 : - Tuple2-73107 - PredKey-73129 - (List-73102 - Rational-73144) -> - a-74013 -> - a-74013) - (n-74015 : - a-74013) -> - c-74014 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - Rational-73144} - MinValue-73131 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List + Rational) -> + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List + Rational} + MinValue ((let - a-74016 - = List-73102 - Rational-73144 + a + = List + Rational in - \(c-74017 : - Rational-73144 -> - a-74016 -> - a-74016) - (n-74018 : - a-74016) -> - c-74017 - (unsafeRatio-73162 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 2) - (c-74017 - (unsafeRatio-73162 + (c + (unsafeRatio 51 100) - n-74018)) - (\(ds-74019 : - Rational-73144) - (ds-74020 : - List-73102 - Rational-73144) -> - Cons-73104 - {Rational-73144} - ds-74019 - ds-74020) - (Nil-73103 - {Rational-73144}))) - (c-74014 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - Rational-73144} - MaxValue-73130 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + (c + (Tuple2 + {PredKey} + {List + Rational} + MaxValue ((let - a-74021 - = List-73102 - Rational-73144 + a + = List + Rational in - \(c-74022 : - Rational-73144 -> - a-74021 -> - a-74021) - (n-74023 : - a-74021) -> - c-74022 - (unsafeRatio-73162 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 1) - (c-74022 - (unsafeRatio-73162 + (c + (unsafeRatio 4 5) - n-74023)) - (\(ds-74024 : - Rational-73144) - (ds-74025 : - List-73102 - Rational-73144) -> - Cons-73104 - {Rational-73144} - ds-74024 - ds-74025) - (Nil-73103 - {Rational-73144}))) - n-74015)))) - (c-73934 - (ParamRational-73151 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + n)))) + (c + (ParamRational ((let - a-74026 - = Tuple2-73107 - PredKey-73129 - (List-73102 - Rational-73144) + a + = Tuple2 + PredKey + (List + Rational) in - \(g-74027 : - all b-74028. - (a-74026 -> - b-74028 -> - b-74028) -> - b-74028 -> - b-74028) -> - g-74027 - {List-73102 - a-74026} - (\(ds-74029 : - a-74026) - (ds-74030 : - List-73102 - a-74026) -> - Cons-73104 - {a-74026} - ds-74029 - ds-74030) - (Nil-73103 - {a-74026})) - (/\a-74031 -> - \(c-74032 : - Tuple2-73107 - PredKey-73129 - (List-73102 - Rational-73144) -> - a-74031 -> - a-74031) - (n-74033 : - a-74031) -> - c-74032 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - Rational-73144} - MinValue-73131 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List + Rational) -> + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List + Rational} + MinValue ((let - a-74034 - = List-73102 - Rational-73144 + a + = List + Rational in - \(c-74035 : - Rational-73144 -> - a-74034 -> - a-74034) - (n-74036 : - a-74034) -> - c-74035 - (unsafeRatio-73162 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 2) - (c-74035 - (unsafeRatio-73162 + (c + (unsafeRatio 51 100) - n-74036)) - (\(ds-74037 : - Rational-73144) - (ds-74038 : - List-73102 - Rational-73144) -> - Cons-73104 - {Rational-73144} - ds-74037 - ds-74038) - (Nil-73103 - {Rational-73144}))) - (c-74032 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - Rational-73144} - MaxValue-73130 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + (c + (Tuple2 + {PredKey} + {List + Rational} + MaxValue ((let - a-74039 - = List-73102 - Rational-73144 + a + = List + Rational in - \(c-74040 : - Rational-73144 -> - a-74039 -> - a-74039) - (n-74041 : - a-74039) -> - c-74040 - (unsafeRatio-73162 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 1) - (c-74040 - (unsafeRatio-73162 + (c + (unsafeRatio 3 4) - n-74041)) - (\(ds-74042 : - Rational-73144) - (ds-74043 : - List-73102 - Rational-73144) -> - Cons-73104 - {Rational-73144} - ds-74042 - ds-74043) - (Nil-73103 - {Rational-73144}))) - n-74033)))) - (c-73934 - (ParamRational-73151 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + n)))) + (c + (ParamRational ((let - a-74044 - = Tuple2-73107 - PredKey-73129 - (List-73102 - Rational-73144) + a + = Tuple2 + PredKey + (List + Rational) in - \(g-74045 : - all b-74046. - (a-74044 -> - b-74046 -> - b-74046) -> - b-74046 -> - b-74046) -> - g-74045 - {List-73102 - a-74044} - (\(ds-74047 : - a-74044) - (ds-74048 : - List-73102 - a-74044) -> - Cons-73104 - {a-74044} - ds-74047 - ds-74048) - (Nil-73103 - {a-74044})) - (/\a-74049 -> - \(c-74050 : - Tuple2-73107 - PredKey-73129 - (List-73102 - Rational-73144) -> - a-74049 -> - a-74049) - (n-74051 : - a-74049) -> - c-74050 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - Rational-73144} - MinValue-73131 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List + Rational) -> + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List + Rational} + MinValue ((let - a-74052 - = List-73102 - Rational-73144 + a + = List + Rational in - \(c-74053 : - Rational-73144 -> - a-74052 -> - a-74052) - (n-74054 : - a-74052) -> - c-74053 - (unsafeRatio-73162 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 2) - (c-74053 - (unsafeRatio-73162 + (c + (unsafeRatio 51 100) - n-74054)) - (\(ds-74055 : - Rational-73144) - (ds-74056 : - List-73102 - Rational-73144) -> - Cons-73104 - {Rational-73144} - ds-74055 - ds-74056) - (Nil-73103 - {Rational-73144}))) - (c-74050 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - Rational-73144} - MaxValue-73130 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + (c + (Tuple2 + {PredKey} + {List + Rational} + MaxValue ((let - a-74057 - = List-73102 - Rational-73144 + a + = List + Rational in - \(c-74058 : - Rational-73144 -> - a-74057 -> - a-74057) - (n-74059 : - a-74057) -> - c-74058 - (unsafeRatio-73162 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 1) - (c-74058 - (unsafeRatio-73162 + (c + (unsafeRatio 3 4) - n-74059)) - (\(ds-74060 : - Rational-73144) - (ds-74061 : - List-73102 - Rational-73144) -> - Cons-73104 - {Rational-73144} - ds-74060 - ds-74061) - (Nil-73103 - {Rational-73144}))) - n-74051)))) - (c-73934 - (ParamRational-73151 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + n)))) + (c + (ParamRational ((let - a-74062 - = Tuple2-73107 - PredKey-73129 - (List-73102 - Rational-73144) + a + = Tuple2 + PredKey + (List + Rational) in - \(g-74063 : - all b-74064. - (a-74062 -> - b-74064 -> - b-74064) -> - b-74064 -> - b-74064) -> - g-74063 - {List-73102 - a-74062} - (\(ds-74065 : - a-74062) - (ds-74066 : - List-73102 - a-74062) -> - Cons-73104 - {a-74062} - ds-74065 - ds-74066) - (Nil-73103 - {a-74062})) - (/\a-74067 -> - \(c-74068 : - Tuple2-73107 - PredKey-73129 - (List-73102 - Rational-73144) -> - a-74067 -> - a-74067) - (n-74069 : - a-74067) -> - c-74068 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - Rational-73144} - MinValue-73131 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List + Rational) -> + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List + Rational} + MinValue ((let - a-74070 - = List-73102 - Rational-73144 + a + = List + Rational in - \(c-74071 : - Rational-73144 -> - a-74070 -> - a-74070) - (n-74072 : - a-74070) -> - c-74071 - (unsafeRatio-73162 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 2) - (c-74071 - (unsafeRatio-73162 + (c + (unsafeRatio 51 100) - n-74072)) - (\(ds-74073 : - Rational-73144) - (ds-74074 : - List-73102 - Rational-73144) -> - Cons-73104 - {Rational-73144} - ds-74073 - ds-74074) - (Nil-73103 - {Rational-73144}))) - (c-74068 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - Rational-73144} - MaxValue-73130 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + (c + (Tuple2 + {PredKey} + {List + Rational} + MaxValue ((let - a-74075 - = List-73102 - Rational-73144 + a + = List + Rational in - \(c-74076 : - Rational-73144 -> - a-74075 -> - a-74075) - (n-74077 : - a-74075) -> - c-74076 - (unsafeRatio-73162 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 1) - (c-74076 - (unsafeRatio-73162 + (c + (unsafeRatio 3 4) - n-74077)) - (\(ds-74078 : - Rational-73144) - (ds-74079 : - List-73102 - Rational-73144) -> - Cons-73104 - {Rational-73144} - ds-74078 - ds-74079) - (Nil-73103 - {Rational-73144}))) - n-74069)))) - (c-73934 - (ParamRational-73151 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + n)))) + (c + (ParamRational ((let - a-74080 - = Tuple2-73107 - PredKey-73129 - (List-73102 - Rational-73144) + a + = Tuple2 + PredKey + (List + Rational) in - \(g-74081 : - all b-74082. - (a-74080 -> - b-74082 -> - b-74082) -> - b-74082 -> - b-74082) -> - g-74081 - {List-73102 - a-74080} - (\(ds-74083 : - a-74080) - (ds-74084 : - List-73102 - a-74080) -> - Cons-73104 - {a-74080} - ds-74083 - ds-74084) - (Nil-73103 - {a-74080})) - (/\a-74085 -> - \(c-74086 : - Tuple2-73107 - PredKey-73129 - (List-73102 - Rational-73144) -> - a-74085 -> - a-74085) - (n-74087 : - a-74085) -> - c-74086 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - Rational-73144} - MinValue-73131 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List + Rational) -> + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List + Rational} + MinValue ((let - a-74088 - = List-73102 - Rational-73144 + a + = List + Rational in - \(c-74089 : - Rational-73144 -> - a-74088 -> - a-74088) - (n-74090 : - a-74088) -> - c-74089 - (unsafeRatio-73162 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 2) - (c-74089 - (unsafeRatio-73162 + (c + (unsafeRatio 3 4) - n-74090)) - (\(ds-74091 : - Rational-73144) - (ds-74092 : - List-73102 - Rational-73144) -> - Cons-73104 - {Rational-73144} - ds-74091 - ds-74092) - (Nil-73103 - {Rational-73144}))) - (c-74086 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - Rational-73144} - MaxValue-73130 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + (c + (Tuple2 + {PredKey} + {List + Rational} + MaxValue ((let - a-74093 - = List-73102 - Rational-73144 + a + = List + Rational in - \(c-74094 : - Rational-73144 -> - a-74093 -> - a-74093) - (n-74095 : - a-74093) -> - c-74094 - (unsafeRatio-73162 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 1) - (c-74094 - (unsafeRatio-73162 + (c + (unsafeRatio 9 10) - n-74095)) - (\(ds-74096 : - Rational-73144) - (ds-74097 : - List-73102 - Rational-73144) -> - Cons-73104 - {Rational-73144} - ds-74096 - ds-74097) - (Nil-73103 - {Rational-73144}))) - n-74087)))) - (c-73934 - (ParamRational-73151 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + n)))) + (c + (ParamRational ((let - a-74098 - = Tuple2-73107 - PredKey-73129 - (List-73102 - Rational-73144) + a + = Tuple2 + PredKey + (List + Rational) in - \(g-74099 : - all b-74100. - (a-74098 -> - b-74100 -> - b-74100) -> - b-74100 -> - b-74100) -> - g-74099 - {List-73102 - a-74098} - (\(ds-74101 : - a-74098) - (ds-74102 : - List-73102 - a-74098) -> - Cons-73104 - {a-74098} - ds-74101 - ds-74102) - (Nil-73103 - {a-74098})) - (/\a-74103 -> - \(c-74104 : - Tuple2-73107 - PredKey-73129 - (List-73102 - Rational-73144) -> - a-74103 -> - a-74103) - (n-74105 : - a-74103) -> - c-74104 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - Rational-73144} - MinValue-73131 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List + Rational) -> + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List + Rational} + MinValue ((let - a-74106 - = List-73102 - Rational-73144 + a + = List + Rational in - \(c-74107 : - Rational-73144 -> - a-74106 -> - a-74106) - (n-74108 : - a-74106) -> - c-74107 - (unsafeRatio-73162 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 2) - n-74108) - (\(ds-74109 : - Rational-73144) - (ds-74110 : - List-73102 - Rational-73144) -> - Cons-73104 - {Rational-73144} - ds-74109 - ds-74110) - (Nil-73103 - {Rational-73144}))) - (c-74104 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - Rational-73144} - MaxValue-73130 + n) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + (c + (Tuple2 + {PredKey} + {List + Rational} + MaxValue ((let - a-74111 - = List-73102 - Rational-73144 + a + = List + Rational in - \(c-74112 : - Rational-73144 -> - a-74111 -> - a-74111) - (n-74113 : - a-74111) -> - c-74112 - (unsafeRatio-73162 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 1) - n-74113) - (\(ds-74114 : - Rational-73144) - (ds-74115 : - List-73102 - Rational-73144) -> - Cons-73104 - {Rational-73144} - ds-74114 - ds-74115) - (Nil-73103 - {Rational-73144}))) - n-74105)))) - n-73935)))))))))) - (\(ds-74116 : - ParamValue-73147) - (ds-74117 : - List-73102 - ParamValue-73147) -> - Cons-73104 - {ParamValue-73147} - ds-74116 - ds-74117) - (Nil-73103 - {ParamValue-73147})))) - (c-73402 - (Tuple2-73108 + n) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + n)))) + n)))))))))) + (\(ds : + ParamValue) + (ds : + List + ParamValue) -> + Cons + {ParamValue} + ds + ds) + (Nil + {ParamValue})))) + (c + (Tuple2 {integer} - {ParamValue-73147} + {ParamValue} 27 - (ParamInteger-73149 + (ParamInteger ((let - a-74118 - = Tuple2-73107 - PredKey-73129 - (List-73102 + a + = Tuple2 + PredKey + (List integer) in - \(g-74119 : - all b-74120. - (a-74118 -> - b-74120 -> - b-74120) -> - b-74120 -> - b-74120) -> - g-74119 - {List-73102 - a-74118} - (\(ds-74121 : - a-74118) - (ds-74122 : - List-73102 - a-74118) -> - Cons-73104 - {a-74118} - ds-74121 - ds-74122) - (Nil-73103 - {a-74118})) - (/\a-74123 -> - \(c-74124 : - Tuple2-73107 - PredKey-73129 - (List-73102 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List integer) -> - a-74123 -> - a-74123) - (n-74125 : - a-74123) -> - c-74124 - (Tuple2-73108 - {PredKey-73129} - {List-73102 + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List integer} - MinValue-73131 + MinValue ((let - a-74126 - = List-73102 + a + = List integer in - \(c-74127 : + \(c : integer -> - a-74126 -> - a-74126) - (n-74128 : - a-74126) -> - c-74127 + a -> + a) + (n : + a) -> + c 0 - (c-74127 + (c 3 - n-74128)) - (\(ds-74129 : + n)) + (\(ds : integer) - (ds-74130 : - List-73102 + (ds : + List integer) -> - Cons-73104 + Cons {integer} - ds-74129 - ds-74130) - (Nil-73103 + ds + ds) + (Nil {integer}))) - (c-74124 - (Tuple2-73108 - {PredKey-73129} - {List-73102 + (c + (Tuple2 + {PredKey} + {List integer} - MaxValue-73130 + MaxValue ((let - a-74131 - = List-73102 + a + = List integer in - \(c-74132 : + \(c : integer -> - a-74131 -> - a-74131) - (n-74133 : - a-74131) -> - c-74132 + a -> + a) + (n : + a) -> + c 10 - n-74133) - (\(ds-74134 : + n) + (\(ds : integer) - (ds-74135 : - List-73102 + (ds : + List integer) -> - Cons-73104 + Cons {integer} - ds-74134 - ds-74135) - (Nil-73103 + ds + ds) + (Nil {integer}))) - n-74125))))) - (c-73402 - (Tuple2-73108 + n))))) + (c + (Tuple2 {integer} - {ParamValue-73147} + {ParamValue} 28 - (ParamInteger-73149 + (ParamInteger ((let - a-74136 - = Tuple2-73107 - PredKey-73129 - (List-73102 + a + = Tuple2 + PredKey + (List integer) in - \(g-74137 : - all b-74138. - (a-74136 -> - b-74138 -> - b-74138) -> - b-74138 -> - b-74138) -> - g-74137 - {List-73102 - a-74136} - (\(ds-74139 : - a-74136) - (ds-74140 : - List-73102 - a-74136) -> - Cons-73104 - {a-74136} - ds-74139 - ds-74140) - (Nil-73103 - {a-74136})) - (/\a-74141 -> - \(c-74142 : - Tuple2-73107 - PredKey-73129 - (List-73102 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List integer) -> - a-74141 -> - a-74141) - (n-74143 : - a-74141) -> - c-74142 - (Tuple2-73108 - {PredKey-73129} - {List-73102 + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List integer} - MinValue-73131 + MinValue ((let - a-74144 - = List-73102 + a + = List integer in - \(c-74145 : + \(c : integer -> - a-74144 -> - a-74144) - (n-74146 : - a-74144) -> - c-74145 + a -> + a) + (n : + a) -> + c 0 - (c-74145 + (c 18 - n-74146)) - (\(ds-74147 : + n)) + (\(ds : integer) - (ds-74148 : - List-73102 + (ds : + List integer) -> - Cons-73104 + Cons {integer} - ds-74147 - ds-74148) - (Nil-73103 + ds + ds) + (Nil {integer}))) - (c-74142 - (Tuple2-73108 - {PredKey-73129} - {List-73102 + (c + (Tuple2 + {PredKey} + {List integer} - MaxValue-73130 + MaxValue ((let - a-74149 - = List-73102 + a + = List integer in - \(c-74150 : + \(c : integer -> - a-74149 -> - a-74149) - (n-74151 : - a-74149) -> - c-74150 + a -> + a) + (n : + a) -> + c 293 - n-74151) - (\(ds-74152 : + n) + (\(ds : integer) - (ds-74153 : - List-73102 + (ds : + List integer) -> - Cons-73104 + Cons {integer} - ds-74152 - ds-74153) - (Nil-73103 + ds + ds) + (Nil {integer}))) - (c-74142 - (Tuple2-73108 - {PredKey-73129} - {List-73102 + (c + (Tuple2 + {PredKey} + {List integer} - NotEqual-73132 + NotEqual ((let - a-74154 - = List-73102 + a + = List integer in - \(c-74155 : + \(c : integer -> - a-74154 -> - a-74154) - (n-74156 : - a-74154) -> - c-74155 + a -> + a) + (n : + a) -> + c 0 - n-74156) - (\(ds-74157 : + n) + (\(ds : integer) - (ds-74158 : - List-73102 + (ds : + List integer) -> - Cons-73104 + Cons {integer} - ds-74157 - ds-74158) - (Nil-73103 + ds + ds) + (Nil {integer}))) - n-74143)))))) - (c-73402 - (Tuple2-73108 + n)))))) + (c + (Tuple2 {integer} - {ParamValue-73147} + {ParamValue} 29 - (ParamInteger-73149 + (ParamInteger ((let - a-74159 - = Tuple2-73107 - PredKey-73129 - (List-73102 + a + = Tuple2 + PredKey + (List integer) in - \(g-74160 : - all b-74161. - (a-74159 -> - b-74161 -> - b-74161) -> - b-74161 -> - b-74161) -> - g-74160 - {List-73102 - a-74159} - (\(ds-74162 : - a-74159) - (ds-74163 : - List-73102 - a-74159) -> - Cons-73104 - {a-74159} - ds-74162 - ds-74163) - (Nil-73103 - {a-74159})) - (/\a-74164 -> - \(c-74165 : - Tuple2-73107 - PredKey-73129 - (List-73102 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List integer) -> - a-74164 -> - a-74164) - (n-74166 : - a-74164) -> - c-74165 - (Tuple2-73108 - {PredKey-73129} - {List-73102 + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List integer} - MinValue-73131 + MinValue ((let - a-74167 - = List-73102 + a + = List integer in - \(c-74168 : + \(c : integer -> - a-74167 -> - a-74167) - (n-74169 : - a-74167) -> - c-74168 + a -> + a) + (n : + a) -> + c 1 - n-74169) - (\(ds-74170 : + n) + (\(ds : integer) - (ds-74171 : - List-73102 + (ds : + List integer) -> - Cons-73104 + Cons {integer} - ds-74170 - ds-74171) - (Nil-73103 + ds + ds) + (Nil {integer}))) - (c-74165 - (Tuple2-73108 - {PredKey-73129} - {List-73102 + (c + (Tuple2 + {PredKey} + {List integer} - MaxValue-73130 + MaxValue ((let - a-74172 - = List-73102 + a + = List integer in - \(c-74173 : + \(c : integer -> - a-74172 -> - a-74172) - (n-74174 : - a-74172) -> - c-74173 + a -> + a) + (n : + a) -> + c 15 - n-74174) - (\(ds-74175 : + n) + (\(ds : integer) - (ds-74176 : - List-73102 + (ds : + List integer) -> - Cons-73104 + Cons {integer} - ds-74175 - ds-74176) - (Nil-73103 + ds + ds) + (Nil {integer}))) - n-74166))))) - (c-73402 - (Tuple2-73108 + n))))) + (c + (Tuple2 {integer} - {ParamValue-73147} + {ParamValue} 30 - (ParamInteger-73149 + (ParamInteger ((let - a-74177 - = Tuple2-73107 - PredKey-73129 - (List-73102 + a + = Tuple2 + PredKey + (List integer) in - \(g-74178 : - all b-74179. - (a-74177 -> - b-74179 -> - b-74179) -> - b-74179 -> - b-74179) -> - g-74178 - {List-73102 - a-74177} - (\(ds-74180 : - a-74177) - (ds-74181 : - List-73102 - a-74177) -> - Cons-73104 - {a-74177} - ds-74180 - ds-74181) - (Nil-73103 - {a-74177})) - (/\a-74182 -> - \(c-74183 : - Tuple2-73107 - PredKey-73129 - (List-73102 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List integer) -> - a-74182 -> - a-74182) - (n-74184 : - a-74182) -> - c-74183 - (Tuple2-73108 - {PredKey-73129} - {List-73102 + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List integer} - MinValue-73131 + MinValue ((let - a-74185 - = List-73102 + a + = List integer in - \(c-74186 : + \(c : integer -> - a-74185 -> - a-74185) - (n-74187 : - a-74185) -> - c-74186 + a -> + a) + (n : + a) -> + c 0 - (c-74186 + (c 1000000 - n-74187)) - (\(ds-74188 : + n)) + (\(ds : integer) - (ds-74189 : - List-73102 + (ds : + List integer) -> - Cons-73104 + Cons {integer} - ds-74188 - ds-74189) - (Nil-73103 + ds + ds) + (Nil {integer}))) - (c-74183 - (Tuple2-73108 - {PredKey-73129} - {List-73102 + (c + (Tuple2 + {PredKey} + {List integer} - MaxValue-73130 + MaxValue ((let - a-74190 - = List-73102 + a + = List integer in - \(c-74191 : + \(c : integer -> - a-74190 -> - a-74190) - (n-74192 : - a-74190) -> - c-74191 + a -> + a) + (n : + a) -> + c 10000000000000 - n-74192) - (\(ds-74193 : + n) + (\(ds : integer) - (ds-74194 : - List-73102 + (ds : + List integer) -> - Cons-73104 + Cons {integer} - ds-74193 - ds-74194) - (Nil-73103 + ds + ds) + (Nil {integer}))) - n-74184))))) - (c-73402 - (Tuple2-73108 + n))))) + (c + (Tuple2 {integer} - {ParamValue-73147} + {ParamValue} 31 - (ParamInteger-73149 + (ParamInteger ((let - a-74195 - = Tuple2-73107 - PredKey-73129 - (List-73102 + a + = Tuple2 + PredKey + (List integer) in - \(g-74196 : - all b-74197. - (a-74195 -> - b-74197 -> - b-74197) -> - b-74197 -> - b-74197) -> - g-74196 - {List-73102 - a-74195} - (\(ds-74198 : - a-74195) - (ds-74199 : - List-73102 - a-74195) -> - Cons-73104 - {a-74195} - ds-74198 - ds-74199) - (Nil-73103 - {a-74195})) - (/\a-74200 -> - \(c-74201 : - Tuple2-73107 - PredKey-73129 - (List-73102 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List integer) -> - a-74200 -> - a-74200) - (n-74202 : - a-74200) -> - c-74201 - (Tuple2-73108 - {PredKey-73129} - {List-73102 + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List integer} - MinValue-73131 + MinValue ((let - a-74203 - = List-73102 + a + = List integer in - \(c-74204 : + \(c : integer -> - a-74203 -> - a-74203) - (n-74205 : - a-74203) -> - c-74204 + a -> + a) + (n : + a) -> + c 0 - (c-74204 + (c 1000000 - n-74205)) - (\(ds-74206 : + n)) + (\(ds : integer) - (ds-74207 : - List-73102 + (ds : + List integer) -> - Cons-73104 + Cons {integer} - ds-74206 - ds-74207) - (Nil-73103 + ds + ds) + (Nil {integer}))) - (c-74201 - (Tuple2-73108 - {PredKey-73129} - {List-73102 + (c + (Tuple2 + {PredKey} + {List integer} - MaxValue-73130 + MaxValue ((let - a-74208 - = List-73102 + a + = List integer in - \(c-74209 : + \(c : integer -> - a-74208 -> - a-74208) - (n-74210 : - a-74208) -> - c-74209 + a -> + a) + (n : + a) -> + c 100000000000 - n-74210) - (\(ds-74211 : + n) + (\(ds : integer) - (ds-74212 : - List-73102 + (ds : + List integer) -> - Cons-73104 + Cons {integer} - ds-74211 - ds-74212) - (Nil-73103 + ds + ds) + (Nil {integer}))) - n-74202))))) - (c-73402 - (Tuple2-73108 + n))))) + (c + (Tuple2 {integer} - {ParamValue-73147} + {ParamValue} 32 - (ParamInteger-73149 + (ParamInteger ((let - a-74213 - = Tuple2-73107 - PredKey-73129 - (List-73102 + a + = Tuple2 + PredKey + (List integer) in - \(g-74214 : - all b-74215. - (a-74213 -> - b-74215 -> - b-74215) -> - b-74215 -> - b-74215) -> - g-74214 - {List-73102 - a-74213} - (\(ds-74216 : - a-74213) - (ds-74217 : - List-73102 - a-74213) -> - Cons-73104 - {a-74213} - ds-74216 - ds-74217) - (Nil-73103 - {a-74213})) - (/\a-74218 -> - \(c-74219 : - Tuple2-73107 - PredKey-73129 - (List-73102 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List integer) -> - a-74218 -> - a-74218) - (n-74220 : - a-74218) -> - c-74219 - (Tuple2-73108 - {PredKey-73129} - {List-73102 + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List integer} - MinValue-73131 + MinValue ((let - a-74221 - = List-73102 + a + = List integer in - \(c-74222 : + \(c : integer -> - a-74221 -> - a-74221) - (n-74223 : - a-74221) -> - c-74222 + a -> + a) + (n : + a) -> + c 13 - (c-74222 + (c 0 - n-74223)) - (\(ds-74224 : + n)) + (\(ds : integer) - (ds-74225 : - List-73102 + (ds : + List integer) -> - Cons-73104 + Cons {integer} - ds-74224 - ds-74225) - (Nil-73103 + ds + ds) + (Nil {integer}))) - (c-74219 - (Tuple2-73108 - {PredKey-73129} - {List-73102 + (c + (Tuple2 + {PredKey} + {List integer} - MaxValue-73130 + MaxValue ((let - a-74226 - = List-73102 + a + = List integer in - \(c-74227 : + \(c : integer -> - a-74226 -> - a-74226) - (n-74228 : - a-74226) -> - c-74227 + a -> + a) + (n : + a) -> + c 37 - n-74228) - (\(ds-74229 : + n) + (\(ds : integer) - (ds-74230 : - List-73102 + (ds : + List integer) -> - Cons-73104 + Cons {integer} - ds-74229 - ds-74230) - (Nil-73103 + ds + ds) + (Nil {integer}))) - n-74220))))) - (c-73402 - (Tuple2-73108 + n))))) + (c + (Tuple2 {integer} - {ParamValue-73147} + {ParamValue} 33 - (ParamRational-73151 + (ParamRational ((let - a-74231 - = Tuple2-73107 - PredKey-73129 - (List-73102 - Rational-73144) + a + = Tuple2 + PredKey + (List + Rational) in - \(g-74232 : - all b-74233. - (a-74231 -> - b-74233 -> - b-74233) -> - b-74233 -> - b-74233) -> - g-74232 - {List-73102 - a-74231} - (\(ds-74234 : - a-74231) - (ds-74235 : - List-73102 - a-74231) -> - Cons-73104 - {a-74231} - ds-74234 - ds-74235) - (Nil-73103 - {a-74231})) - (/\a-74236 -> - \(c-74237 : - Tuple2-73107 - PredKey-73129 - (List-73102 - Rational-73144) -> - a-74236 -> - a-74236) - (n-74238 : - a-74236) -> - c-74237 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - Rational-73144} - MinValue-73131 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List + Rational) -> + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List + Rational} + MinValue ((let - a-74239 - = List-73102 - Rational-73144 + a + = List + Rational in - \(c-74240 : - Rational-73144 -> - a-74239 -> - a-74239) - (n-74241 : - a-74239) -> - c-74240 - (unsafeRatio-73162 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 0 1) - n-74241) - (\(ds-74242 : - Rational-73144) - (ds-74243 : - List-73102 - Rational-73144) -> - Cons-73104 - {Rational-73144} - ds-74242 - ds-74243) - (Nil-73103 - {Rational-73144}))) - (c-74237 - (Tuple2-73108 - {PredKey-73129} - {List-73102 - Rational-73144} - MaxValue-73130 + n) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + (c + (Tuple2 + {PredKey} + {List + Rational} + MaxValue ((let - a-74244 - = List-73102 - Rational-73144 + a + = List + Rational in - \(c-74245 : - Rational-73144 -> - a-74244 -> - a-74244) - (n-74246 : - a-74244) -> - c-74245 - (unsafeRatio-73162 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1000 1) - n-74246) - (\(ds-74247 : - Rational-73144) - (ds-74248 : - List-73102 - Rational-73144) -> - Cons-73104 - {Rational-73144} - ds-74247 - ds-74248) - (Nil-73103 - {Rational-73144}))) - n-74238))))) - n-73403))))))))))))))))))))))))))))))) + n) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + n))))) + n))))))))))))))))))))))))))))))) in - \(ds-74250 : data) -> - Maybe_match-73120 - {List-73102 (Tuple2-73107 data data)} + \(ds : data) -> + Maybe_match + {List (Tuple2 data data)} (let - !ds-74257 : data + !ds : data = headList {data} (tailList @@ -5726,7 +5290,7 @@ program {list data} (unConstrData (let - !ds-74251 : data + !ds : data = headList {data} (tailList @@ -5736,69 +5300,56 @@ program (sndPair {integer} {list data} - (unConstrData ds-74250)))) - ~si-74252 : pair integer (list data) - = unConstrData ds-74251 + (unConstrData ds)))) + ~si : pair integer (list data) = unConstrData ds in - Bool_match-73125 + Bool_match (ifThenElse - {Bool-73122} + {Bool} (equalsInteger 5 - (fstPair {integer} {list data} si-74252)) - True-73123 - False-73124) - {all dead-74253. data} - (/\dead-74254 -> + (fstPair {integer} {list data} si)) + True + False) + {all dead. data} + (/\dead -> headList {data} (tailList {data} - (sndPair {integer} {list data} si-74252))) - (/\dead-74255 -> error {data}) - {all dead-74256. dead-74256}))))) - ~ds-74258 : pair integer (list data) = unConstrData ds-74257 - !x-74259 : integer = fstPair {integer} {list data} ds-74258 + (sndPair {integer} {list data} si))) + (/\dead -> error {data}) + {all dead. dead}))))) + ~ds : pair integer (list data) = unConstrData ds + !x : integer = fstPair {integer} {list data} ds in - Bool_match-73125 - (ifThenElse - {Bool-73122} - (equalsInteger 0 x-74259) - True-73123 - False-73124) - {all dead-74260. Maybe-73117 (List-73102 (Tuple2-73107 data data))} - (/\dead-74261 -> - Just-73118 - {List-73102 (Tuple2-73107 data data)} - (go-73112 + Bool_match + (ifThenElse {Bool} (equalsInteger 0 x) True False) + {all dead. Maybe (List (Tuple2 data data))} + (/\dead -> + Just + {List (Tuple2 data data)} + (go (unMapData (headList {data} - (tailList - {data} - (sndPair {integer} {list data} ds-74258)))))) - (/\dead-74262 -> - Bool_match-73125 - (ifThenElse - {Bool-73122} - (equalsInteger 2 x-74259) - True-73123 - False-73124) - {all dead-74263. Maybe-73117 (List-73102 (Tuple2-73107 data data))} - (/\dead-74264 -> - Nothing-73119 {List-73102 (Tuple2-73107 data data)}) - (/\dead-74265 -> - error {Maybe-73117 (List-73102 (Tuple2-73107 data data))}) - {all dead-74266. dead-74266}) - {all dead-74267. dead-74267}) - {all dead-74268. unit} - (\(cparams-74269 : List-73102 (Tuple2-73107 data data)) -> - /\dead-74270 -> - Bool_match-73125 - (fun-74249 cparams-74269) - {all dead-74271. unit} - (/\dead-74272 -> ()) - (/\dead-74273 -> error {unit}) - {all dead-74274. dead-74274}) - (/\dead-74275 -> ()) - {all dead-74276. dead-74276}) \ No newline at end of file + (tailList {data} (sndPair {integer} {list data} ds)))))) + (/\dead -> + Bool_match + (ifThenElse {Bool} (equalsInteger 2 x) True False) + {all dead. Maybe (List (Tuple2 data data))} + (/\dead -> Nothing {List (Tuple2 data data)}) + (/\dead -> error {Maybe (List (Tuple2 data data))}) + {all dead. dead}) + {all dead. dead}) + {all dead. unit} + (\(cparams : List (Tuple2 data data)) -> + /\dead -> + Bool_match + (fun cparams) + {all dead. unit} + (/\dead -> ()) + (/\dead -> error {unit}) + {all dead. dead}) + (/\dead -> ()) + {all dead. dead}) \ No newline at end of file diff --git a/cardano-constitution/test/Cardano/Constitution/Validator/GoldenTests/sorted.uplc.golden b/cardano-constitution/test/Cardano/Constitution/Validator/GoldenTests/sorted.uplc.golden index 9fe422fc91c..74be06e7ece 100644 --- a/cardano-constitution/test/Cardano/Constitution/Validator/GoldenTests/sorted.uplc.golden +++ b/cardano-constitution/test/Cardano/Constitution/Validator/GoldenTests/sorted.uplc.golden @@ -1,62 +1,62 @@ program 1.1.0 - ((\fix1!0 -> - (\`$fOrdRational0_$c<=`!0 -> - (\`$fOrdInteger_$ccompare`!0 -> - (\validatePreds!0 -> - (\euclid!0 -> - (\unsafeRatio!0 -> - (\cse!0 -> - (\validateParamValue!0 -> - (\validateParamValues!0 -> - (\runRules!0 -> - (\go!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\fun!0 - ds!0 -> + ((\fix1 -> + (\`$fOrdRational0_$c<=` -> + (\`$fOrdInteger_$ccompare` -> + (\validatePreds -> + (\euclid -> + (\unsafeRatio -> + (\cse -> + (\validateParamValue -> + (\validateParamValues -> + (\runRules -> + (\go -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\fun + ds -> force (case - ((\cse!0 -> - (\x!0 -> + ((\cse -> + (\x -> force (force (force ifThenElse (equalsInteger 0 - x!1) + x) (delay (delay (constr 0 - [ (go!34 + [ (go (unMapData (force headList @@ -65,7 +65,7 @@ program (force (force sndPair) - cse!2))))) ]))) + cse))))) ]))) (delay (delay (force @@ -74,7 +74,7 @@ program ifThenElse (equalsInteger 2 - x!1) + x) (delay (delay (constr 1 @@ -85,7 +85,7 @@ program (force (force fstPair) - cse!1)) + cse)) (unConstrData (force headList @@ -97,7 +97,7 @@ program (force sndPair) (unConstrData - ((\cse!0 -> + ((\cse -> force (force (force @@ -107,7 +107,7 @@ program (force (force fstPair) - cse!1)) + cse)) (delay (delay (force @@ -117,7 +117,7 @@ program (force (force sndPair) - cse!1))))) + cse))))) (delay (delay error))))) @@ -132,20 +132,20 @@ program (force sndPair) (unConstrData - ds!1)))))))))))))) - [ (\cparams!0 -> + ds)))))))))))))) + [ (\cparams -> delay (force (case - (fun!3 - cparams!1) + (fun + cparams) [ (delay ()) , (delay error) ]))) , (delay ()) ])) - (runRules!31 + (runRules (constr 1 [ (constr 0 [ 0 @@ -156,7 +156,7 @@ program [ ]) , (constr 1 [ 30 - , cse!28 ]) ]) + , cse ]) ]) , (constr 1 [ (constr 0 [ (constr 0 @@ -177,7 +177,7 @@ program [ ]) , (constr 1 [ 100000 - , cse!28 ]) ]) + , cse ]) ]) , (constr 1 [ (constr 0 [ (constr 0 @@ -215,7 +215,7 @@ program [ 3 , (constr 1 [ (constr 1 - [ cse!18 + [ cse , (constr 1 [ (constr 0 [ (constr 0 @@ -231,7 +231,7 @@ program [ 4 , (constr 1 [ (constr 1 - [ cse!18 + [ cse , (constr 1 [ (constr 0 [ (constr 0 @@ -252,7 +252,7 @@ program [ ]) , (constr 1 [ 1000000 - , cse!28 ]) ]) + , cse ]) ]) , (constr 1 [ (constr 0 [ (constr 0 @@ -273,14 +273,14 @@ program [ ]) , (constr 1 [ 250000000 - , cse!28 ]) ]) - , cse!12 ]) ]) ]) + , cse ]) ]) + , cse ]) ]) ]) , (constr 1 [ (constr 0 [ 7 , (constr 1 [ (constr 1 - [ cse!18 + [ cse , (constr 0 [ ]) ]) ]) ]) , (constr 1 @@ -293,7 +293,7 @@ program [ ]) , (constr 1 [ 250 - , cse!28 ]) ]) + , cse ]) ]) , (constr 1 [ (constr 0 [ (constr 0 @@ -302,14 +302,14 @@ program [ 2000 , (constr 0 [ ]) ]) ]) - , cse!10 ]) ]) ]) ]) + , cse ]) ]) ]) ]) , (constr 1 [ (constr 0 [ 9 , (constr 3 [ (constr 1 - [ cse!7 - , cse!8 ]) ]) ]) + [ cse + , cse ]) ]) ]) , (constr 1 [ (constr 0 [ 10 @@ -319,15 +319,15 @@ program [ (constr 1 [ ]) , (constr 1 - [ (cse!26 + [ (cse 1000) - , cse!13 ]) ]) + , cse ]) ]) , (constr 1 [ (constr 0 [ (constr 0 [ ]) , (constr 1 - [ (cse!26 + [ (cse 200) , (constr 0 [ ]) ]) ]) @@ -338,15 +338,15 @@ program [ 11 , (constr 3 [ (constr 1 - [ cse!7 + [ cse , (constr 1 [ (constr 0 [ (constr 0 [ ]) , (constr 1 - [ (cse!24 + [ (cse 10) - , cse!14 ]) ]) + , cse ]) ]) , (constr 0 [ ]) ]) ]) ]) ]) , (constr 1 @@ -354,8 +354,8 @@ program [ 16 , (constr 1 [ (constr 1 - [ cse!18 - , cse!12 ]) ]) ]) + [ cse + , cse ]) ]) ]) , (constr 1 [ (constr 0 [ 17 @@ -366,7 +366,7 @@ program [ ]) , (constr 1 [ 3000 - , cse!28 ]) ]) + , cse ]) ]) , (constr 1 [ (constr 0 [ (constr 0 @@ -375,7 +375,7 @@ program [ 6500 , (constr 0 [ ]) ]) ]) - , cse!10 ]) ]) ]) ]) + , cse ]) ]) ]) ]) , (constr 1 [ (constr 0 [ 18 @@ -392,7 +392,7 @@ program [ (constr 1 [ ]) , (constr 1 - [ (cse!26 + [ (cse 25) , (constr 0 [ ]) ]) ]) @@ -401,7 +401,7 @@ program [ (constr 0 [ ]) , (constr 1 - [ (cse!26 + [ (cse 5) , (constr 0 [ ]) ]) ]) @@ -414,7 +414,7 @@ program [ (constr 1 [ ]) , (constr 1 - [ (cse!26 + [ (cse 20000) , (constr 0 [ ]) ]) ]) @@ -423,7 +423,7 @@ program [ (constr 0 [ ]) , (constr 1 - [ (cse!26 + [ (cse 5000) , (constr 0 [ ]) ]) ]) @@ -438,7 +438,7 @@ program [ (constr 1 [ (constr 1 [ (constr 1 - [ cse!18 + [ cse , (constr 1 [ (constr 0 [ (constr 0 @@ -452,7 +452,7 @@ program , (constr 1 [ (constr 1 [ (constr 1 - [ cse!18 + [ cse , (constr 1 [ (constr 0 [ (constr 0 @@ -472,7 +472,7 @@ program [ (constr 1 [ (constr 1 [ (constr 1 - [ cse!18 + [ cse , (constr 1 [ (constr 0 [ (constr 0 @@ -486,7 +486,7 @@ program , (constr 1 [ (constr 1 [ (constr 1 - [ cse!18 + [ cse , (constr 1 [ (constr 0 [ (constr 0 @@ -504,7 +504,7 @@ program [ 22 , (constr 1 [ (constr 1 - [ cse!18 + [ cse , (constr 1 [ (constr 0 [ (constr 0 @@ -525,7 +525,7 @@ program [ ]) , (constr 1 [ 100 - , cse!28 ]) ]) + , cse ]) ]) , (constr 1 [ (constr 0 [ (constr 0 @@ -534,13 +534,13 @@ program [ 200 , (constr 0 [ ]) ]) ]) - , cse!10 ]) ]) ]) ]) + , cse ]) ]) ]) ]) , (constr 1 [ (constr 0 [ 24 , (constr 1 [ (constr 1 - [ cse!19 + [ cse , (constr 0 [ ]) ]) ]) ]) , (constr 1 @@ -548,24 +548,24 @@ program [ 25 , (constr 2 [ (constr 1 - [ cse!3 + [ cse , (constr 1 - [ cse!1 + [ cse , (constr 1 - [ cse!1 + [ cse , (constr 1 - [ cse!2 - , cse!4 ]) ]) ]) ]) ]) ]) + [ cse + , cse ]) ]) ]) ]) ]) ]) , (constr 1 [ (constr 0 [ 26 , (constr 2 [ (constr 1 - [ cse!3 + [ cse , (constr 1 - [ cse!1 + [ cse , (constr 1 - [ cse!1 + [ cse , (constr 1 [ (constr 3 [ (constr 1 @@ -573,22 +573,22 @@ program [ (constr 1 [ ]) , (constr 1 - [ cse!20 + [ cse , (constr 1 - [ (unsafeRatio!35 + [ (unsafeRatio 13 20) , (constr 0 [ ]) ]) ]) ]) - , cse!5 ]) ]) + , cse ]) ]) , (constr 1 - [ cse!2 + [ cse , (constr 1 - [ cse!3 + [ cse , (constr 1 - [ cse!3 + [ cse , (constr 1 - [ cse!3 + [ cse , (constr 1 [ (constr 3 [ (constr 1 @@ -596,10 +596,10 @@ program [ (constr 1 [ ]) , (constr 1 - [ cse!20 - , cse!11 ]) ]) - , cse!5 ]) ]) - , cse!4 ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) + [ cse + , cse ]) ]) + , cse ]) ]) + , cse ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) , (constr 1 [ (constr 0 [ 27 @@ -646,13 +646,13 @@ program [ 293 , (constr 0 [ ]) ]) ]) - , cse!10 ]) ]) ]) ]) + , cse ]) ]) ]) ]) , (constr 1 [ (constr 0 [ 29 , (constr 1 [ (constr 1 - [ cse!19 + [ cse , (constr 1 [ (constr 0 [ (constr 0 @@ -668,7 +668,7 @@ program [ 30 , (constr 1 [ (constr 1 - [ cse!9 + [ cse , (constr 1 [ (constr 0 [ (constr 0 @@ -684,7 +684,7 @@ program [ 31 , (constr 1 [ (constr 1 - [ cse!9 + [ cse , (constr 1 [ (constr 0 [ (constr 0 @@ -705,7 +705,7 @@ program [ ]) , (constr 1 [ 13 - , cse!28 ]) ]) + , cse ]) ]) , (constr 1 [ (constr 0 [ (constr 0 @@ -724,13 +724,13 @@ program [ (constr 0 [ (constr 1 [ ]) - , cse!13 ]) + , cse ]) , (constr 1 [ (constr 0 [ (constr 0 [ ]) , (constr 1 - [ (unsafeRatio!35 + [ (unsafeRatio 1000 1) , (constr 0 @@ -741,33 +741,33 @@ program [ ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]))) (constr 3 [ (constr 1 - [ cse!5 - , cse!4 ]) ])) + [ cse + , cse ]) ])) (constr 3 [ (constr 1 - [ cse!4 + [ cse , (constr 1 [ (constr 0 [ (constr 0 [ ]) , (constr 1 - [ cse!15 + [ cse , (constr 1 - [ cse!20 + [ cse , (constr 0 [ ]) ]) ]) ]) , (constr 0 [ ]) ]) ]) ])) (constr 3 [ (constr 1 - [ cse!3 + [ cse , (constr 1 [ (constr 0 [ (constr 0 [ ]) , (constr 1 - [ cse!14 - , cse!8 ]) ]) + [ cse + , cse ]) ]) , (constr 0 [ ]) ]) ]) ])) (constr 1 @@ -777,10 +777,10 @@ program [ (constr 1 [ ]) , (constr 1 - [ cse!16 + [ cse , (constr 0 [ ]) ]) ]) - , cse!4 ]) ]) + , cse ]) ]) , (constr 0 [ ]) ])) (constr 1 @@ -788,9 +788,9 @@ program [ (constr 0 [ ]) , (constr 1 - [ cse!12 + [ cse , (constr 1 - [ cse!11 + [ cse , (constr 0 [ ]) ]) ]) ]) , (constr 0 @@ -799,23 +799,23 @@ program [ (constr 1 [ ]) , (constr 1 - [ cse!14 + [ cse , (constr 1 - [ cse!9 + [ cse , (constr 0 [ ]) ]) ]) ])) (constr 0 [ (constr 1 [ ]) , (constr 1 - [ (cse!19 + [ (cse 10) - , cse!6 ]) ])) + , cse ]) ])) (constr 1 [ (constr 0 [ (constr 0 [ ]) - , cse!6 ]) + , cse ]) , (constr 0 [ ]) ])) (constr 0 @@ -831,11 +831,11 @@ program [ (constr 0 [ (constr 2 [ ]) - , cse!18 ]) + , cse ]) , (constr 0 [ ]) ])) (constr 1 - [ (cse!13 + [ (cse 4) , (constr 0 [ ]) ])) @@ -850,23 +850,23 @@ program , (constr 0 [ ]) ])) (constr 1 - [ cse!8 + [ cse , (constr 0 [ ]) ])) (constr 1 - [ cse!3 + [ cse , (constr 0 [ ]) ])) - (cse!12 + (cse 100)) - (cse!9 + (cse 10)) - (cse!9 + (cse 1)) (constr 0 [ (constr 1 [ ]) - , cse!10 ])) + , cse ])) (constr 0 [ (constr 1 []) @@ -874,221 +874,216 @@ program [ 1 , (constr 0 [ ]) ]) ])) - (cse!6 2)) - (cse!2 1)) - (cse!7 5)) - (unsafeRatio!12 0)) - (unsafeRatio!11 3)) - (unsafeRatio!10 9)) - (unsafeRatio!9 1)) - (unsafeRatio!8 51)) + (cse 2)) + (cse 1)) + (cse 5)) + (unsafeRatio 0)) + (unsafeRatio 3)) + (unsafeRatio 9)) + (unsafeRatio 1)) + (unsafeRatio 51)) (constr 1 [0, (constr 0 [])])) - (unsafeRatio!6 4)) - (fix1!10 - (\go!0 l!0 -> + (unsafeRatio 4)) + (fix1 + (\go l -> force (force chooseList) - l!1 - (\ds!0 -> constr 0 []) - (\ds!0 -> + l + (\ds -> constr 0 []) + (\ds -> constr 1 - [ ((\p!0 -> + [ ((\p -> constr 0 [ (force (force fstPair) - p!1) + p) , (force (force sndPair) - p!1) ]) - (force headList l!2)) - , (go!3 (force tailList l!2)) ]) + p) ]) + (force headList l)) + , (go (force tailList l)) ]) ()))) - (fix1!9 - (\runRules!0 ds!0 cparams!0 -> + (fix1 + (\runRules ds cparams -> force - ((\fail!0 -> + ((\fail -> case - ds!3 - [ (delay (fail!1 ())) - , (\ds!0 cfgRest!0 -> + ds + [ (delay (fail ())) + , (\ds cfgRest -> delay (case - ds!2 - [ (\expectedPid!0 - paramValue!0 -> + ds + [ (\expectedPid + paramValue -> force (case - cparams!6 + cparams [ (delay - (fail!5 + (fail ())) - , (\ds!0 - cparamsRest!0 -> + , (\ds + cparamsRest -> delay (case - ds!2 - [ (\ds!0 - actualValueData!0 -> + ds + [ (\ds + actualValueData -> force (case - (`$fOrdInteger_$ccompare`!19 + (`$fOrdInteger_$ccompare` (unIData - ds!2) - expectedPid!6) + ds) + expectedPid) [ (delay (force (case - (validateParamValue!14 - paramValue!5 - actualValueData!1) + (validateParamValue + paramValue + actualValueData) [ (delay - (runRules!12 - cfgRest!7 - cparamsRest!3)) + (runRules + cfgRest + cparamsRest)) , (delay (constr 1 [ ])) ]))) , (delay - (runRules!12 - cfgRest!7 - cparams!10)) + (runRules + cfgRest + cparams)) , (delay (constr 1 [ ])) ])) ])) ])) ])) ]) - (\ds!0 -> + (\ds -> force (case - cparams!2 + cparams [ (delay (constr 0 [])) - , (\ipv!0 ipv!0 -> + , (\ipv ipv -> delay (constr 1 [])) ])))))) - (cse!2 (\arg_0!0 arg_1!0 -> arg_1!1))) - (cse!1 (\arg_0!0 arg_1!0 -> arg_0!2))) + (cse (\arg_0 arg_1 -> arg_1))) + (cse (\arg_0 arg_1 -> arg_0))) (force - ((\s!0 -> s!1 s!1) - (\s!0 h!0 -> + ((\s -> s s) + (\s h -> delay - (\fr!0 -> - (\k!0 -> - fr!2 - (\x!0 -> - k!2 (\f_0!0 f_1!0 -> f_0!2 x!3)) - (\x!0 -> - k!2 (\f_0!0 f_1!0 -> f_1!1 x!3))) - (\fq!0 -> - force (s!4 s!4 h!3) - (force h!3 fq!1)))) + (\fr -> + (\k -> + fr + (\x -> k (\f_0 f_1 -> f_0 x)) + (\x -> k (\f_0 f_1 -> f_1 x))) + (\fq -> force (s s h) (force h fq)))) (delay - (\choose!0 - validateParamValue!0 - validateParamValues!0 -> - choose!3 - (\eta!0 eta!0 -> + (\choose + validateParamValue + validateParamValues -> + choose + (\eta eta -> force (case - eta!2 + eta [ (delay (constr 0 [])) - , (\preds!0 -> + , (\preds -> delay - (validatePreds!9 + (validatePreds (constr 0 - [ (\x!0 y!0 -> + [ (\x y -> force ifThenElse (equalsInteger - x!2 - y!1) + x + y) (constr 0 []) (constr 1 [])) - , `$fOrdInteger_$ccompare`!10 - , (\x!0 y!0 -> + , `$fOrdInteger_$ccompare` + , (\x y -> force ifThenElse (lessThanInteger - x!2 - y!1) + x + y) (constr 0 []) (constr 1 [])) - , (\x!0 y!0 -> + , (\x y -> force ifThenElse (lessThanEqualsInteger - x!2 - y!1) + x + y) (constr 0 []) (constr 1 [])) - , (\x!0 y!0 -> + , (\x y -> force ifThenElse (lessThanEqualsInteger - x!2 - y!1) + x + y) (constr 1 []) (constr 0 [])) - , (\x!0 y!0 -> + , (\x y -> force ifThenElse (lessThanInteger - x!2 - y!1) + x + y) (constr 1 []) (constr 0 [])) - , (\x!0 y!0 -> + , (\x y -> force (force (force ifThenElse (lessThanEqualsInteger - x!2 - y!1) + x + y) (delay (delay - y!1)) + y)) (delay (delay - x!2))))) - , (\x!0 y!0 -> + x))))) + , (\x y -> force (force (force ifThenElse (lessThanEqualsInteger - x!2 - y!1) + x + y) (delay (delay - x!2)) + x)) (delay (delay - y!1))))) ]) - preds!1 - (unIData eta!2))) - , (\paramValues!0 -> + y))))) ]) + preds + (unIData eta))) + , (\paramValues -> delay - (validateParamValues!4 - paramValues!1 - (unListData eta!2))) - , (\preds!0 -> + (validateParamValues + paramValues + (unListData eta))) + , (\preds -> delay - ((\cse!0 -> - validatePreds!10 + ((\cse -> + validatePreds (constr 0 - [ (\ds!0 ds!0 -> + [ (\ds ds -> case - ds!2 - [ (\n!0 - d!0 -> + ds + [ (\n d -> case - ds!3 - [ (\n'!0 - d'!0 -> + ds + [ (\n' + d' -> force (force (force ifThenElse (equalsInteger - n!4 - n'!2) + n + n') (delay (delay (force ifThenElse (equalsInteger - d!3 - d'!1) + d + d') (constr 0 [ ]) (constr 1 @@ -1097,310 +1092,288 @@ program (delay (constr 1 [ ])))))) ]) ]) - , (\ds!0 ds!0 -> + , (\ds ds -> case - ds!2 - [ (\n!0 - d!0 -> + ds + [ (\n d -> case - ds!3 - [ (\n'!0 - d'!0 -> - `$fOrdInteger_$ccompare`!17 + ds + [ (\n' + d' -> + `$fOrdInteger_$ccompare` (multiplyInteger - n!4 - d'!1) + n + d') (multiplyInteger - n'!2 - d!3)) ]) ]) - , (\ds!0 ds!0 -> + n' + d)) ]) ]) + , (\ds ds -> case - ds!2 - [ (\n!0 - d!0 -> + ds + [ (\n d -> case - ds!3 - [ (\n'!0 - d'!0 -> + ds + [ (\n' + d' -> force ifThenElse (lessThanInteger (multiplyInteger - n!4 - d'!1) + n + d') (multiplyInteger - n'!2 - d!3)) + n' + d)) (constr 0 [ ]) (constr 1 [ ])) ]) ]) - , `$fOrdRational0_$c<=`!12 - , (\ds!0 ds!0 -> + , `$fOrdRational0_$c<=` + , (\ds ds -> case - ds!2 - [ (\n!0 - d!0 -> + ds + [ (\n d -> case - ds!3 - [ (\n'!0 - d'!0 -> + ds + [ (\n' + d' -> force ifThenElse (lessThanEqualsInteger (multiplyInteger - n!4 - d'!1) + n + d') (multiplyInteger - n'!2 - d!3)) + n' + d)) (constr 1 [ ]) (constr 0 [ ])) ]) ]) - , (\ds!0 ds!0 -> + , (\ds ds -> case - ds!2 - [ (\n!0 - d!0 -> + ds + [ (\n d -> case - ds!3 - [ (\n'!0 - d'!0 -> + ds + [ (\n' + d' -> force ifThenElse (lessThanInteger (multiplyInteger - n!4 - d'!1) + n + d') (multiplyInteger - n'!2 - d!3)) + n' + d)) (constr 1 [ ]) (constr 0 [ ])) ]) ]) - , (\x!0 y!0 -> + , (\x y -> force (case - (`$fOrdRational0_$c<=`!14 - x!2 - y!1) + (`$fOrdRational0_$c<=` + x + y) [ (delay - y!1) + y) , (delay - x!2) ])) - , (\x!0 y!0 -> + x) ])) + , (\x y -> force (case - (`$fOrdRational0_$c<=`!14 - x!2 - y!1) + (`$fOrdRational0_$c<=` + x + y) [ (delay - x!2) + x) , (delay - y!1) ])) ]) - preds!2 - ((\cse!0 -> + y) ])) ]) + preds + ((\cse -> force ifThenElse (force nullList (force tailList - cse!1)) - (\ds!0 -> - unsafeRatio!10 + cse)) + (\ds -> + unsafeRatio (unIData (force headList - cse!3)) + cse)) (unIData (force headList - cse!2)))) + cse)))) (force tailList - cse!1) - (\ds!0 -> error) + cse) + (\ds -> error) (constr 0 []))) - (unListData eta!2))) ])) - (\ds!0 -> + (unListData eta))) ])) + (\ds -> case - ds!1 - [ (\eta!0 -> + ds + [ (\eta -> force ifThenElse - (force nullList eta!1) + (force nullList eta) (constr 0 []) (constr 1 [])) - , (\paramValueHd!0 - paramValueTl!0 - actualValueData!0 -> + , (\paramValueHd + paramValueTl + actualValueData -> force (case - (validateParamValue!6 - paramValueHd!3 + (validateParamValue + paramValueHd (force headList - actualValueData!1)) + actualValueData)) [ (delay - (validateParamValues!5 - paramValueTl!2 + (validateParamValues + paramValueTl (force tailList - actualValueData!1))) + actualValueData))) , (delay (constr 1 [])) ])) ])))))) - (fix1!5 - (\unsafeRatio!0 n!0 d!0 -> + (fix1 + (\unsafeRatio n d -> force (force (force ifThenElse - (equalsInteger 0 d!1) + (equalsInteger 0 d) (delay (delay error)) (delay (delay (force (force (force ifThenElse - (lessThanInteger d!1 0) + (lessThanInteger d 0) (delay (delay - (unsafeRatio!3 + (unsafeRatio + (subtractInteger 0 n) (subtractInteger 0 - n!2) - (subtractInteger - 0 - d!1)))) + d)))) (delay (delay - ((\gcd'!0 -> + ((\gcd' -> constr 0 [ (quotientInteger - n!3 - gcd'!1) + n + gcd') , (quotientInteger - d!2 - gcd'!1) ]) - (euclid!4 - n!2 - d!1)))))))))))))) - (fix1!4 - (\euclid!0 x!0 y!0 -> + d + gcd') ]) + (euclid + n + d)))))))))))))) + (fix1 + (\euclid x y -> force (force (force ifThenElse - (equalsInteger 0 y!1) - (delay (delay x!2)) - (delay - (delay - (euclid!3 y!1 (modInteger x!2 y!1))))))))) - (\`$dOrd`!0 ds!0 ds!0 -> - fix1!6 - (\go!0 ds!0 -> + (equalsInteger 0 y) + (delay (delay x)) + (delay (delay (euclid y (modInteger x y))))))))) + (\`$dOrd` ds ds -> + fix1 + (\go ds -> force (case - ds!1 + ds [ (delay (constr 0 [])) - , (\x!0 xs!0 -> + , (\x xs -> delay (case - x!2 - [ (\predKey!0 expectedPredValues!0 -> - (\meaning!0 -> - fix1!13 - (\go!0 ds!0 -> + x + [ (\predKey expectedPredValues -> + (\meaning -> + fix1 + (\go ds -> force (case - ds!1 - [ (delay (go!9 xs!6)) - , (\x!0 xs!0 -> + ds + [ (delay (go xs)) + , (\x xs -> delay (force (case - (meaning!5 - x!2 - ds!12) + (meaning + x + ds) [ (delay - (go!4 - xs!1)) + (go + xs)) , (delay (constr 1 [ ])) ]))) ])) - expectedPredValues!2) + expectedPredValues) (force (case - predKey!2 + predKey [ (delay (case - `$dOrd`!9 - [ (\v!0 - v!0 - v!0 - v!0 - v!0 - v!0 - v!0 - v!0 -> - v!3) ])) + `$dOrd` + [ (\v v v v v v v v -> + v) ])) , (delay (case - `$dOrd`!9 - [ (\v!0 - v!0 - v!0 - v!0 - v!0 - v!0 - v!0 - v!0 -> - v!5) ])) + `$dOrd` + [ (\v v v v v v v v -> + v) ])) , (delay - (\x!0 y!0 -> + (\x y -> force (case (case - `$dOrd`!11 - [ (\v!0 - v!0 - v!0 - v!0 - v!0 - v!0 - v!0 - v!0 -> - v!8) ] - x!2 - y!1) + `$dOrd` + [ (\v + v + v + v + v + v + v + v -> + v) ] + x + y) [ (delay (constr 1 [])) , (delay (constr 0 [ ])) ]))) ]))) ])) ])) - ds!2)) - (\eta!0 eta!0 -> + ds)) + (\eta eta -> force (force (force ifThenElse - (equalsInteger eta!2 eta!1) + (equalsInteger eta eta) (delay (delay (constr 0 []))) (delay (delay (force (force (force ifThenElse - (lessThanEqualsInteger eta!2 eta!1) + (lessThanEqualsInteger eta eta) (delay (delay (constr 2 []))) (delay (delay (constr 1 [])))))))))))) - (\ds!0 ds!0 -> + (\ds ds -> case - ds!2 - [ (\n!0 d!0 -> + ds + [ (\n d -> case - ds!3 - [ (\n'!0 d'!0 -> + ds + [ (\n' d' -> force ifThenElse (lessThanEqualsInteger - (multiplyInteger n!4 d'!1) - (multiplyInteger n'!2 d!3)) + (multiplyInteger n d') + (multiplyInteger n' d)) (constr 0 []) (constr 1 [])) ]) ])) - (\f!0 -> (\s!0 -> s!1 s!1) (\s!0 -> f!2 (\x!0 -> s!2 s!2 x!1)))) \ No newline at end of file + (\f -> (\s -> s s) (\s -> f (\x -> s s x)))) \ No newline at end of file diff --git a/cardano-constitution/test/Cardano/Constitution/Validator/GoldenTests/unsorted.pir.golden b/cardano-constitution/test/Cardano/Constitution/Validator/GoldenTests/unsorted.pir.golden index 2bab44e60b5..d3676b47593 100644 --- a/cardano-constitution/test/Cardano/Constitution/Validator/GoldenTests/unsorted.pir.golden +++ b/cardano-constitution/test/Cardano/Constitution/Validator/GoldenTests/unsorted.pir.golden @@ -1,5675 +1,5218 @@ program 1.1.0 (let - data Ordering-71640 | Ordering_match-71644 where - EQ-71641 : Ordering-71640 - GT-71642 : Ordering-71640 - LT-71643 : Ordering-71640 - data Bool-71628 | Bool_match-71631 where - True-71629 : Bool-71628 - False-71630 : Bool-71628 - data (Ord-71645 :: * -> *) a-71648 | Ord_match-71647 where - CConsOrd-71646 : - (\a-71649 -> a-71649 -> a-71649 -> Bool-71628) a-71648 -> - (a-71648 -> a-71648 -> Ordering-71640) -> - (a-71648 -> a-71648 -> Bool-71628) -> - (a-71648 -> a-71648 -> Bool-71628) -> - (a-71648 -> a-71648 -> Bool-71628) -> - (a-71648 -> a-71648 -> Bool-71628) -> - (a-71648 -> a-71648 -> a-71648) -> - (a-71648 -> a-71648 -> a-71648) -> - Ord-71645 a-71648 - data PredKey-71635 | PredKey_match-71639 where - MaxValue-71636 : PredKey-71635 - MinValue-71637 : PredKey-71635 - NotEqual-71638 : PredKey-71635 - data (Tuple2-71613 :: * -> * -> *) a-71616 - b-71617 | Tuple2_match-71615 where - Tuple2-71614 : a-71616 -> b-71617 -> Tuple2-71613 a-71616 b-71617 + data Ordering | Ordering_match where + EQ : Ordering + GT : Ordering + LT : Ordering + data Bool | Bool_match where + True : Bool + False : Bool + data (Ord :: * -> *) a | Ord_match where + CConsOrd : + (\a -> a -> a -> Bool) a -> + (a -> a -> Ordering) -> + (a -> a -> Bool) -> + (a -> a -> Bool) -> + (a -> a -> Bool) -> + (a -> a -> Bool) -> + (a -> a -> a) -> + (a -> a -> a) -> + Ord a + data PredKey | PredKey_match where + MaxValue : PredKey + MinValue : PredKey + NotEqual : PredKey + data (Tuple2 :: * -> * -> *) a b | Tuple2_match where + Tuple2 : a -> b -> Tuple2 a b in letrec - data (List-71608 :: * -> *) a-71612 | List_match-71611 where - Nil-71609 : List-71608 a-71612 - Cons-71610 : a-71612 -> List-71608 a-71612 -> List-71608 a-71612 + data (List :: * -> *) a | List_match where + Nil : List a + Cons : a -> List a -> List a in let - !validatePreds-71781 : - all a-71782. - Ord-71645 a-71782 -> - (\v-71783 -> - List-71608 (Tuple2-71613 PredKey-71635 (List-71608 v-71783))) - a-71782 -> - a-71782 -> - Bool-71628 - = /\a-71714 -> - \(`$dOrd`-71715 : Ord-71645 a-71714) - (ds-71716 : - (\v-71717 -> - List-71608 (Tuple2-71613 PredKey-71635 (List-71608 v-71717))) - a-71714) - (ds-71718 : a-71714) -> + !validatePreds : + all a. Ord a -> (\v -> List (Tuple2 PredKey (List v))) a -> a -> Bool + = /\a -> + \(`$dOrd` : Ord a) + (ds : (\v -> List (Tuple2 PredKey (List v))) a) + (ds : a) -> letrec - !go-71719 : - List-71608 (Tuple2-71613 PredKey-71635 (List-71608 a-71714)) -> - Bool-71628 - = \(ds-71720 : - List-71608 - (Tuple2-71613 PredKey-71635 (List-71608 a-71714))) -> - List_match-71611 - {Tuple2-71613 PredKey-71635 (List-71608 a-71714)} - ds-71720 - {all dead-71721. Bool-71628} - (/\dead-71722 -> True-71629) - (\(x-71723 : - Tuple2-71613 PredKey-71635 (List-71608 a-71714)) - (xs-71724 : - List-71608 - (Tuple2-71613 - PredKey-71635 - (List-71608 a-71714))) -> - /\dead-71725 -> - Tuple2_match-71615 - {PredKey-71635} - {List-71608 a-71714} - x-71723 - {Bool-71628} - (\(predKey-71726 : PredKey-71635) - (expectedPredValues-71727 : - List-71608 a-71714) -> + !go : List (Tuple2 PredKey (List a)) -> Bool + = \(ds : List (Tuple2 PredKey (List a))) -> + List_match + {Tuple2 PredKey (List a)} + ds + {all dead. Bool} + (/\dead -> True) + (\(x : Tuple2 PredKey (List a)) + (xs : List (Tuple2 PredKey (List a))) -> + /\dead -> + Tuple2_match + {PredKey} + {List a} + x + {Bool} + (\(predKey : PredKey) + (expectedPredValues : List a) -> let - !meaning-71767 : - a-71714 -> a-71714 -> Bool-71628 - = PredKey_match-71639 - predKey-71726 - {all dead-71728. - a-71714 -> a-71714 -> Bool-71628} - (/\dead-71729 -> - Ord_match-71647 - {a-71714} - `$dOrd`-71715 - {a-71714 -> a-71714 -> Bool-71628} - (\(v-71730 : - (\a-71731 -> - a-71731 -> - a-71731 -> - Bool-71628) - a-71714) - (v-71732 : - a-71714 -> - a-71714 -> - Ordering-71640) - (v-71733 : - a-71714 -> - a-71714 -> - Bool-71628) - (v-71734 : - a-71714 -> - a-71714 -> - Bool-71628) - (v-71735 : - a-71714 -> - a-71714 -> - Bool-71628) - (v-71736 : - a-71714 -> - a-71714 -> - Bool-71628) - (v-71737 : - a-71714 -> a-71714 -> a-71714) - (v-71738 : - a-71714 -> - a-71714 -> - a-71714) -> - v-71736)) - (/\dead-71739 -> - Ord_match-71647 - {a-71714} - `$dOrd`-71715 - {a-71714 -> a-71714 -> Bool-71628} - (\(v-71740 : - (\a-71741 -> - a-71741 -> - a-71741 -> - Bool-71628) - a-71714) - (v-71742 : - a-71714 -> - a-71714 -> - Ordering-71640) - (v-71743 : - a-71714 -> - a-71714 -> - Bool-71628) - (v-71744 : - a-71714 -> - a-71714 -> - Bool-71628) - (v-71745 : - a-71714 -> - a-71714 -> - Bool-71628) - (v-71746 : - a-71714 -> - a-71714 -> - Bool-71628) - (v-71747 : - a-71714 -> a-71714 -> a-71714) - (v-71748 : - a-71714 -> - a-71714 -> - a-71714) -> - v-71744)) - (/\dead-71749 -> - \(x-71750 : a-71714) - (y-71751 : a-71714) -> - Bool_match-71631 - (Ord_match-71647 - {a-71714} - `$dOrd`-71715 - {(\a-71752 -> - a-71752 -> - a-71752 -> - Bool-71628) - a-71714} - (\(v-71753 : - (\a-71754 -> - a-71754 -> - a-71754 -> - Bool-71628) - a-71714) - (v-71755 : - a-71714 -> - a-71714 -> - Ordering-71640) - (v-71756 : - a-71714 -> - a-71714 -> - Bool-71628) - (v-71757 : - a-71714 -> - a-71714 -> - Bool-71628) - (v-71758 : - a-71714 -> - a-71714 -> - Bool-71628) - (v-71759 : - a-71714 -> - a-71714 -> - Bool-71628) - (v-71760 : - a-71714 -> - a-71714 -> - a-71714) - (v-71761 : - a-71714 -> - a-71714 -> - a-71714) -> - v-71753) - x-71750 - y-71751) - {all dead-71762. Bool-71628} - (/\dead-71763 -> False-71630) - (/\dead-71764 -> True-71629) - {all dead-71765. dead-71765}) - {all dead-71766. dead-71766} + !meaning : a -> a -> Bool + = PredKey_match + predKey + {all dead. a -> a -> Bool} + (/\dead -> + Ord_match + {a} + `$dOrd` + {a -> a -> Bool} + (\(v : (\a -> a -> a -> Bool) a) + (v : a -> a -> Ordering) + (v : a -> a -> Bool) + (v : a -> a -> Bool) + (v : a -> a -> Bool) + (v : a -> a -> Bool) + (v : a -> a -> a) + (v : a -> a -> a) -> + v)) + (/\dead -> + Ord_match + {a} + `$dOrd` + {a -> a -> Bool} + (\(v : (\a -> a -> a -> Bool) a) + (v : a -> a -> Ordering) + (v : a -> a -> Bool) + (v : a -> a -> Bool) + (v : a -> a -> Bool) + (v : a -> a -> Bool) + (v : a -> a -> a) + (v : a -> a -> a) -> + v)) + (/\dead -> + \(x : a) (y : a) -> + Bool_match + (Ord_match + {a} + `$dOrd` + {(\a -> a -> a -> Bool) a} + (\(v : + (\a -> a -> a -> Bool) a) + (v : a -> a -> Ordering) + (v : a -> a -> Bool) + (v : a -> a -> Bool) + (v : a -> a -> Bool) + (v : a -> a -> Bool) + (v : a -> a -> a) + (v : a -> a -> a) -> + v) + x + y) + {all dead. Bool} + (/\dead -> False) + (/\dead -> True) + {all dead. dead}) + {all dead. dead} in letrec - !go-71768 : List-71608 a-71714 -> Bool-71628 - = \(ds-71769 : List-71608 a-71714) -> - List_match-71611 - {a-71714} - ds-71769 - {all dead-71770. Bool-71628} - (/\dead-71771 -> go-71719 xs-71724) - (\(x-71772 : a-71714) - (xs-71773 : List-71608 a-71714) -> - /\dead-71774 -> - Bool_match-71631 - (meaning-71767 - x-71772 - ds-71718) - {all dead-71775. Bool-71628} - (/\dead-71776 -> - go-71768 xs-71773) - (/\dead-71777 -> False-71630) - {all dead-71778. dead-71778}) - {all dead-71779. dead-71779} + !go : List a -> Bool + = \(ds : List a) -> + List_match + {a} + ds + {all dead. Bool} + (/\dead -> go xs) + (\(x : a) (xs : List a) -> + /\dead -> + Bool_match + (meaning x ds) + {all dead. Bool} + (/\dead -> go xs) + (/\dead -> False) + {all dead. dead}) + {all dead. dead} in - go-71768 expectedPredValues-71727)) - {all dead-71780. dead-71780} + go expectedPredValues)) + {all dead. dead} in - go-71719 ds-71716 - !equalsInteger-71700 : integer -> integer -> Bool-71628 - = \(x-71698 : integer) (y-71699 : integer) -> - ifThenElse - {Bool-71628} - (equalsInteger x-71698 y-71699) - True-71629 - False-71630 - !`$fOrdInteger_$ccompare`-71697 : integer -> integer -> Ordering-71640 - = \(eta-71687 : integer) (eta-71688 : integer) -> - Bool_match-71631 - (ifThenElse - {Bool-71628} - (equalsInteger eta-71687 eta-71688) - True-71629 - False-71630) - {all dead-71689. Ordering-71640} - (/\dead-71690 -> EQ-71641) - (/\dead-71691 -> - Bool_match-71631 - (ifThenElse - {Bool-71628} - (lessThanEqualsInteger eta-71687 eta-71688) - True-71629 - False-71630) - {all dead-71692. Ordering-71640} - (/\dead-71693 -> LT-71643) - (/\dead-71694 -> GT-71642) - {all dead-71695. dead-71695}) - {all dead-71696. dead-71696} - data Rational-71650 | Rational_match-71652 where - Rational-71651 : integer -> integer -> Rational-71650 - !`$fOrdRational0_$c<=`-71686 : - Rational-71650 -> Rational-71650 -> Bool-71628 - = \(ds-71680 : Rational-71650) (ds-71681 : Rational-71650) -> - Rational_match-71652 - ds-71680 - {Bool-71628} - (\(n-71682 : integer) (d-71683 : integer) -> - Rational_match-71652 - ds-71681 - {Bool-71628} - (\(n'-71684 : integer) (d'-71685 : integer) -> + go ds + !equalsInteger : integer -> integer -> Bool + = \(x : integer) (y : integer) -> + ifThenElse {Bool} (equalsInteger x y) True False + !`$fOrdInteger_$ccompare` : integer -> integer -> Ordering + = \(eta : integer) (eta : integer) -> + Bool_match + (ifThenElse {Bool} (equalsInteger eta eta) True False) + {all dead. Ordering} + (/\dead -> EQ) + (/\dead -> + Bool_match + (ifThenElse {Bool} (lessThanEqualsInteger eta eta) True False) + {all dead. Ordering} + (/\dead -> LT) + (/\dead -> GT) + {all dead. dead}) + {all dead. dead} + data Rational | Rational_match where + Rational : integer -> integer -> Rational + !`$fOrdRational0_$c<=` : Rational -> Rational -> Bool + = \(ds : Rational) (ds : Rational) -> + Rational_match + ds + {Bool} + (\(n : integer) (d : integer) -> + Rational_match + ds + {Bool} + (\(n' : integer) (d' : integer) -> ifThenElse - {Bool-71628} + {Bool} (lessThanEqualsInteger - (multiplyInteger n-71682 d'-71685) - (multiplyInteger n'-71684 d-71683)) - True-71629 - False-71630)) + (multiplyInteger n d') + (multiplyInteger n' d)) + True + False)) in letrec - !euclid-71661 : integer -> integer -> integer - = \(x-71662 : integer) (y-71663 : integer) -> - Bool_match-71631 - (ifThenElse - {Bool-71628} - (equalsInteger 0 y-71663) - True-71629 - False-71630) - {all dead-71664. integer} - (/\dead-71665 -> x-71662) - (/\dead-71666 -> euclid-71661 y-71663 (modInteger x-71662 y-71663)) - {all dead-71667. dead-71667} + !euclid : integer -> integer -> integer + = \(x : integer) (y : integer) -> + Bool_match + (ifThenElse {Bool} (equalsInteger 0 y) True False) + {all dead. integer} + (/\dead -> x) + (/\dead -> euclid y (modInteger x y)) + {all dead. dead} in letrec - !unsafeRatio-71668 : integer -> integer -> Rational-71650 - = \(n-71669 : integer) (d-71670 : integer) -> - Bool_match-71631 - (ifThenElse - {Bool-71628} - (equalsInteger 0 d-71670) - True-71629 - False-71630) - {all dead-71671. Rational-71650} - (/\dead-71672 -> error {Rational-71650}) - (/\dead-71673 -> - Bool_match-71631 - (ifThenElse - {Bool-71628} - (lessThanInteger d-71670 0) - True-71629 - False-71630) - {all dead-71674. Rational-71650} - (/\dead-71675 -> - unsafeRatio-71668 - (subtractInteger 0 n-71669) - (subtractInteger 0 d-71670)) - (/\dead-71676 -> + !unsafeRatio : integer -> integer -> Rational + = \(n : integer) (d : integer) -> + Bool_match + (ifThenElse {Bool} (equalsInteger 0 d) True False) + {all dead. Rational} + (/\dead -> error {Rational}) + (/\dead -> + Bool_match + (ifThenElse {Bool} (lessThanInteger d 0) True False) + {all dead. Rational} + (/\dead -> + unsafeRatio (subtractInteger 0 n) (subtractInteger 0 d)) + (/\dead -> let - !gcd'-71677 : integer = euclid-71661 n-71669 d-71670 + !gcd' : integer = euclid n d in - Rational-71651 - (quotientInteger n-71669 gcd'-71677) - (quotientInteger d-71670 gcd'-71677)) - {all dead-71678. dead-71678}) - {all dead-71679. dead-71679} + Rational (quotientInteger n gcd') (quotientInteger d gcd')) + {all dead. dead}) + {all dead. dead} in letrec - data ParamValue-71653 | ParamValue_match-71658 where - ParamAny-71654 : ParamValue-71653 - ParamInteger-71655 : - (\v-71659 -> - List-71608 (Tuple2-71613 PredKey-71635 (List-71608 v-71659))) - integer -> - ParamValue-71653 - ParamList-71656 : List-71608 ParamValue-71653 -> ParamValue-71653 - ParamRational-71657 : - (\v-71660 -> - List-71608 (Tuple2-71613 PredKey-71635 (List-71608 v-71660))) - Rational-71650 -> - ParamValue-71653 + data ParamValue | ParamValue_match where + ParamAny : ParamValue + ParamInteger : + (\v -> List (Tuple2 PredKey (List v))) integer -> ParamValue + ParamList : List ParamValue -> ParamValue + ParamRational : + (\v -> List (Tuple2 PredKey (List v))) Rational -> ParamValue in let - data Unit-71632 | Unit_match-71634 where - Unit-71633 : Unit-71632 + data Unit | Unit_match where + Unit : Unit in letrec - !validateParamValue-71701 : ParamValue-71653 -> data -> Bool-71628 - = \(eta-71702 : ParamValue-71653) (eta-71703 : data) -> + !validateParamValue : ParamValue -> data -> Bool + = \(eta : ParamValue) (eta : data) -> let - ~bl-71860 : list data = unListData eta-71703 - ~bl'-71861 : list data = tailList {data} bl-71860 + ~bl : list data = unListData eta + ~bl' : list data = tailList {data} bl in - ParamValue_match-71658 - eta-71702 - {all dead-71784. Bool-71628} - (/\dead-71785 -> True-71629) - (\(preds-71786 : - (\v-71787 -> - List-71608 - (Tuple2-71613 PredKey-71635 (List-71608 v-71787))) - integer) -> - /\dead-71788 -> - validatePreds-71781 + ParamValue_match + eta + {all dead. Bool} + (/\dead -> True) + (\(preds : (\v -> List (Tuple2 PredKey (List v))) integer) -> + /\dead -> + validatePreds {integer} - (CConsOrd-71646 + (CConsOrd {integer} - equalsInteger-71700 - `$fOrdInteger_$ccompare`-71697 - (\(x-71789 : integer) (y-71790 : integer) -> + equalsInteger + `$fOrdInteger_$ccompare` + (\(x : integer) (y : integer) -> + ifThenElse {Bool} (lessThanInteger x y) True False) + (\(x : integer) (y : integer) -> ifThenElse - {Bool-71628} - (lessThanInteger x-71789 y-71790) - True-71629 - False-71630) - (\(x-71791 : integer) (y-71792 : integer) -> + {Bool} + (lessThanEqualsInteger x y) + True + False) + (\(x : integer) (y : integer) -> ifThenElse - {Bool-71628} - (lessThanEqualsInteger x-71791 y-71792) - True-71629 - False-71630) - (\(x-71793 : integer) (y-71794 : integer) -> - ifThenElse - {Bool-71628} - (lessThanEqualsInteger x-71793 y-71794) - False-71630 - True-71629) - (\(x-71795 : integer) (y-71796 : integer) -> - ifThenElse - {Bool-71628} - (lessThanInteger x-71795 y-71796) - False-71630 - True-71629) - (\(x-71797 : integer) (y-71798 : integer) -> - Bool_match-71631 + {Bool} + (lessThanEqualsInteger x y) + False + True) + (\(x : integer) (y : integer) -> + ifThenElse {Bool} (lessThanInteger x y) False True) + (\(x : integer) (y : integer) -> + Bool_match (ifThenElse - {Bool-71628} - (lessThanEqualsInteger x-71797 y-71798) - True-71629 - False-71630) - {all dead-71799. integer} - (/\dead-71800 -> y-71798) - (/\dead-71801 -> x-71797) - {all dead-71802. dead-71802}) - (\(x-71803 : integer) (y-71804 : integer) -> - Bool_match-71631 + {Bool} + (lessThanEqualsInteger x y) + True + False) + {all dead. integer} + (/\dead -> y) + (/\dead -> x) + {all dead. dead}) + (\(x : integer) (y : integer) -> + Bool_match (ifThenElse - {Bool-71628} - (lessThanEqualsInteger x-71803 y-71804) - True-71629 - False-71630) - {all dead-71805. integer} - (/\dead-71806 -> x-71803) - (/\dead-71807 -> y-71804) - {all dead-71808. dead-71808})) - preds-71786 - (unIData eta-71703)) - (\(paramValues-71809 : List-71608 ParamValue-71653) -> - /\dead-71810 -> - validateParamValues-71704 - paramValues-71809 - (unListData eta-71703)) - (\(preds-71811 : - (\v-71812 -> - List-71608 - (Tuple2-71613 PredKey-71635 (List-71608 v-71812))) - Rational-71650) -> - /\dead-71813 -> - validatePreds-71781 - {Rational-71650} - (CConsOrd-71646 - {Rational-71650} - (\(ds-71814 : Rational-71650) - (ds-71815 : Rational-71650) -> - Rational_match-71652 - ds-71814 - {Bool-71628} - (\(n-71816 : integer) (d-71817 : integer) -> - Rational_match-71652 - ds-71815 - {Bool-71628} - (\(n'-71818 : integer) (d'-71819 : integer) -> - Bool_match-71631 + {Bool} + (lessThanEqualsInteger x y) + True + False) + {all dead. integer} + (/\dead -> x) + (/\dead -> y) + {all dead. dead})) + preds + (unIData eta)) + (\(paramValues : List ParamValue) -> + /\dead -> validateParamValues paramValues (unListData eta)) + (\(preds : (\v -> List (Tuple2 PredKey (List v))) Rational) -> + /\dead -> + validatePreds + {Rational} + (CConsOrd + {Rational} + (\(ds : Rational) (ds : Rational) -> + Rational_match + ds + {Bool} + (\(n : integer) (d : integer) -> + Rational_match + ds + {Bool} + (\(n' : integer) (d' : integer) -> + Bool_match (ifThenElse - {Bool-71628} - (equalsInteger n-71816 n'-71818) - True-71629 - False-71630) - {all dead-71820. Bool-71628} - (/\dead-71821 -> + {Bool} + (equalsInteger n n') + True + False) + {all dead. Bool} + (/\dead -> ifThenElse - {Bool-71628} - (equalsInteger d-71817 d'-71819) - True-71629 - False-71630) - (/\dead-71822 -> False-71630) - {all dead-71823. dead-71823}))) - (\(ds-71824 : Rational-71650) - (ds-71825 : Rational-71650) -> - Rational_match-71652 - ds-71824 - {Ordering-71640} - (\(n-71826 : integer) (d-71827 : integer) -> - Rational_match-71652 - ds-71825 - {Ordering-71640} - (\(n'-71828 : integer) (d'-71829 : integer) -> - `$fOrdInteger_$ccompare`-71697 - (multiplyInteger n-71826 d'-71829) - (multiplyInteger n'-71828 d-71827)))) - (\(ds-71830 : Rational-71650) - (ds-71831 : Rational-71650) -> - Rational_match-71652 - ds-71830 - {Bool-71628} - (\(n-71832 : integer) (d-71833 : integer) -> - Rational_match-71652 - ds-71831 - {Bool-71628} - (\(n'-71834 : integer) (d'-71835 : integer) -> + {Bool} + (equalsInteger d d') + True + False) + (/\dead -> False) + {all dead. dead}))) + (\(ds : Rational) (ds : Rational) -> + Rational_match + ds + {Ordering} + (\(n : integer) (d : integer) -> + Rational_match + ds + {Ordering} + (\(n' : integer) (d' : integer) -> + `$fOrdInteger_$ccompare` + (multiplyInteger n d') + (multiplyInteger n' d)))) + (\(ds : Rational) (ds : Rational) -> + Rational_match + ds + {Bool} + (\(n : integer) (d : integer) -> + Rational_match + ds + {Bool} + (\(n' : integer) (d' : integer) -> ifThenElse - {Bool-71628} + {Bool} (lessThanInteger - (multiplyInteger n-71832 d'-71835) - (multiplyInteger n'-71834 d-71833)) - True-71629 - False-71630))) - `$fOrdRational0_$c<=`-71686 - (\(ds-71836 : Rational-71650) - (ds-71837 : Rational-71650) -> - Rational_match-71652 - ds-71836 - {Bool-71628} - (\(n-71838 : integer) (d-71839 : integer) -> - Rational_match-71652 - ds-71837 - {Bool-71628} - (\(n'-71840 : integer) (d'-71841 : integer) -> + (multiplyInteger n d') + (multiplyInteger n' d)) + True + False))) + `$fOrdRational0_$c<=` + (\(ds : Rational) (ds : Rational) -> + Rational_match + ds + {Bool} + (\(n : integer) (d : integer) -> + Rational_match + ds + {Bool} + (\(n' : integer) (d' : integer) -> ifThenElse - {Bool-71628} + {Bool} (lessThanEqualsInteger - (multiplyInteger n-71838 d'-71841) - (multiplyInteger n'-71840 d-71839)) - False-71630 - True-71629))) - (\(ds-71842 : Rational-71650) - (ds-71843 : Rational-71650) -> - Rational_match-71652 - ds-71842 - {Bool-71628} - (\(n-71844 : integer) (d-71845 : integer) -> - Rational_match-71652 - ds-71843 - {Bool-71628} - (\(n'-71846 : integer) (d'-71847 : integer) -> + (multiplyInteger n d') + (multiplyInteger n' d)) + False + True))) + (\(ds : Rational) (ds : Rational) -> + Rational_match + ds + {Bool} + (\(n : integer) (d : integer) -> + Rational_match + ds + {Bool} + (\(n' : integer) (d' : integer) -> ifThenElse - {Bool-71628} + {Bool} (lessThanInteger - (multiplyInteger n-71844 d'-71847) - (multiplyInteger n'-71846 d-71845)) - False-71630 - True-71629))) - (\(x-71848 : Rational-71650) (y-71849 : Rational-71650) -> - Bool_match-71631 - (`$fOrdRational0_$c<=`-71686 x-71848 y-71849) - {all dead-71850. Rational-71650} - (/\dead-71851 -> y-71849) - (/\dead-71852 -> x-71848) - {all dead-71853. dead-71853}) - (\(x-71854 : Rational-71650) (y-71855 : Rational-71650) -> - Bool_match-71631 - (`$fOrdRational0_$c<=`-71686 x-71854 y-71855) - {all dead-71856. Rational-71650} - (/\dead-71857 -> x-71854) - (/\dead-71858 -> y-71855) - {all dead-71859. dead-71859})) - preds-71811 + (multiplyInteger n d') + (multiplyInteger n' d)) + False + True))) + (\(x : Rational) (y : Rational) -> + Bool_match + (`$fOrdRational0_$c<=` x y) + {all dead. Rational} + (/\dead -> y) + (/\dead -> x) + {all dead. dead}) + (\(x : Rational) (y : Rational) -> + Bool_match + (`$fOrdRational0_$c<=` x y) + {all dead. Rational} + (/\dead -> x) + (/\dead -> y) + {all dead. dead})) + preds (ifThenElse - {Unit-71632 -> Rational-71650} - (nullList {data} (tailList {data} bl'-71861)) - (\(ds-71862 : Unit-71632) -> - unsafeRatio-71668 - (unIData (headList {data} bl-71860)) - (unIData (headList {data} bl'-71861))) - (\(ds-71863 : Unit-71632) -> error {Rational-71650}) - Unit-71633)) - {all dead-71864. dead-71864} - !validateParamValues-71704 : - List-71608 ParamValue-71653 -> list data -> Bool-71628 - = \(ds-71705 : List-71608 ParamValue-71653) -> - List_match-71611 - {ParamValue-71653} - ds-71705 - {list data -> Bool-71628} - (\(eta-71706 : list data) -> - ifThenElse - {Bool-71628} - (nullList {data} eta-71706) - True-71629 - False-71630) - (\(paramValueHd-71707 : ParamValue-71653) - (paramValueTl-71708 : List-71608 ParamValue-71653) - (actualValueData-71709 : list data) -> - Bool_match-71631 - (validateParamValue-71701 - paramValueHd-71707 - (headList {data} actualValueData-71709)) - {all dead-71710. Bool-71628} - (/\dead-71711 -> - validateParamValues-71704 - paramValueTl-71708 - (tailList {data} actualValueData-71709)) - (/\dead-71712 -> False-71630) - {all dead-71713. dead-71713}) + {Unit -> Rational} + (nullList {data} (tailList {data} bl')) + (\(ds : Unit) -> + unsafeRatio + (unIData (headList {data} bl)) + (unIData (headList {data} bl'))) + (\(ds : Unit) -> error {Rational}) + Unit)) + {all dead. dead} + !validateParamValues : List ParamValue -> list data -> Bool + = \(ds : List ParamValue) -> + List_match + {ParamValue} + ds + {list data -> Bool} + (\(eta : list data) -> + ifThenElse {Bool} (nullList {data} eta) True False) + (\(paramValueHd : ParamValue) + (paramValueTl : List ParamValue) + (actualValueData : list data) -> + Bool_match + (validateParamValue + paramValueHd + (headList {data} actualValueData)) + {all dead. Bool} + (/\dead -> + validateParamValues + paramValueTl + (tailList {data} actualValueData)) + (/\dead -> False) + {all dead. dead}) in let - data (Maybe-71623 :: * -> *) a-71627 | Maybe_match-71626 where - Just-71624 : a-71627 -> Maybe-71623 a-71627 - Nothing-71625 : Maybe-71623 a-71627 + data (Maybe :: * -> *) a | Maybe_match where + Just : a -> Maybe a + Nothing : Maybe a in letrec - !go-71618 : list (pair data data) -> List-71608 (Tuple2-71613 data data) - = \(l-71619 : list (pair data data)) -> + !go : list (pair data data) -> List (Tuple2 data data) + = \(l : list (pair data data)) -> chooseList {pair data data} - {unit -> List-71608 (Tuple2-71613 data data)} - l-71619 - (\(ds-71620 : unit) -> Nil-71609 {Tuple2-71613 data data}) - (\(ds-71621 : unit) -> - Cons-71610 - {Tuple2-71613 data data} + {unit -> List (Tuple2 data data)} + l + (\(ds : unit) -> Nil {Tuple2 data data}) + (\(ds : unit) -> + Cons + {Tuple2 data data} (let - !p-71622 : pair data data = headList {pair data data} l-71619 + !p : pair data data = headList {pair data data} l in - Tuple2-71614 + Tuple2 {data} {data} - (fstPair {data} {data} p-71622) - (sndPair {data} {data} p-71622)) - (go-71618 (tailList {pair data data} l-71619))) + (fstPair {data} {data} p) + (sndPair {data} {data} p)) + (go (tailList {pair data data} l))) () in let - !cfg-72718 : List-71608 (Tuple2-71613 integer ParamValue-71653) + !cfg : List (Tuple2 integer ParamValue) = (let - a-71865 = Tuple2-71613 integer ParamValue-71653 + a = Tuple2 integer ParamValue in - \(g-71866 : - all b-71867. - (a-71865 -> b-71867 -> b-71867) -> b-71867 -> b-71867) -> - g-71866 - {List-71608 a-71865} - (\(ds-71868 : a-71865) (ds-71869 : List-71608 a-71865) -> - Cons-71610 {a-71865} ds-71868 ds-71869) - (Nil-71609 {a-71865})) - (/\a-71870 -> - \(c-71871 : - Tuple2-71613 integer ParamValue-71653 -> a-71870 -> a-71870) - (n-71872 : a-71870) -> - c-71871 - (Tuple2-71614 + \(g : all b. (a -> b -> b) -> b -> b) -> + g {List a} (\(ds : a) (ds : List a) -> Cons {a} ds ds) (Nil {a})) + (/\a -> + \(c : Tuple2 integer ParamValue -> a -> a) (n : a) -> + c + (Tuple2 {integer} - {ParamValue-71653} + {ParamValue} 0 - (ParamInteger-71655 + (ParamInteger ((let - a-71873 - = Tuple2-71613 PredKey-71635 (List-71608 integer) + a = Tuple2 PredKey (List integer) in - \(g-71874 : - all b-71875. - (a-71873 -> b-71875 -> b-71875) -> - b-71875 -> - b-71875) -> - g-71874 - {List-71608 a-71873} - (\(ds-71876 : a-71873) - (ds-71877 : List-71608 a-71873) -> - Cons-71610 {a-71873} ds-71876 ds-71877) - (Nil-71609 {a-71873})) - (/\a-71878 -> - \(c-71879 : - Tuple2-71613 - PredKey-71635 - (List-71608 integer) -> - a-71878 -> - a-71878) - (n-71880 : a-71878) -> - c-71879 - (Tuple2-71614 - {PredKey-71635} - {List-71608 integer} - MinValue-71637 + \(g : all b. (a -> b -> b) -> b -> b) -> + g + {List a} + (\(ds : a) (ds : List a) -> Cons {a} ds ds) + (Nil {a})) + (/\a -> + \(c : Tuple2 PredKey (List integer) -> a -> a) + (n : a) -> + c + (Tuple2 + {PredKey} + {List integer} + MinValue ((let - a-71881 = List-71608 integer + a = List integer in - \(c-71882 : - integer -> a-71881 -> a-71881) - (n-71883 : a-71881) -> - c-71882 30 (c-71882 0 n-71883)) - (\(ds-71884 : integer) - (ds-71885 : List-71608 integer) -> - Cons-71610 - {integer} - ds-71884 - ds-71885) - (Nil-71609 {integer}))) - (c-71879 - (Tuple2-71614 - {PredKey-71635} - {List-71608 integer} - MaxValue-71636 + \(c : integer -> a -> a) (n : a) -> + c 30 (c 0 n)) + (\(ds : integer) (ds : List integer) -> + Cons {integer} ds ds) + (Nil {integer}))) + (c + (Tuple2 + {PredKey} + {List integer} + MaxValue ((let - a-71886 = List-71608 integer + a = List integer in - \(c-71887 : - integer -> a-71886 -> a-71886) - (n-71888 : a-71886) -> - c-71887 1000 n-71888) - (\(ds-71889 : integer) - (ds-71890 : List-71608 integer) -> - Cons-71610 - {integer} - ds-71889 - ds-71890) - (Nil-71609 {integer}))) - n-71880))))) - (c-71871 - (Tuple2-71614 + \(c : integer -> a -> a) (n : a) -> + c 1000 n) + (\(ds : integer) + (ds : List integer) -> + Cons {integer} ds ds) + (Nil {integer}))) + n))))) + (c + (Tuple2 {integer} - {ParamValue-71653} + {ParamValue} 1 - (ParamInteger-71655 + (ParamInteger ((let - a-71891 - = Tuple2-71613 - PredKey-71635 - (List-71608 integer) + a = Tuple2 PredKey (List integer) in - \(g-71892 : - all b-71893. - (a-71891 -> b-71893 -> b-71893) -> - b-71893 -> - b-71893) -> - g-71892 - {List-71608 a-71891} - (\(ds-71894 : a-71891) - (ds-71895 : List-71608 a-71891) -> - Cons-71610 {a-71891} ds-71894 ds-71895) - (Nil-71609 {a-71891})) - (/\a-71896 -> - \(c-71897 : - Tuple2-71613 - PredKey-71635 - (List-71608 integer) -> - a-71896 -> - a-71896) - (n-71898 : a-71896) -> - c-71897 - (Tuple2-71614 - {PredKey-71635} - {List-71608 integer} - MinValue-71637 + \(g : all b. (a -> b -> b) -> b -> b) -> + g + {List a} + (\(ds : a) (ds : List a) -> Cons {a} ds ds) + (Nil {a})) + (/\a -> + \(c : Tuple2 PredKey (List integer) -> a -> a) + (n : a) -> + c + (Tuple2 + {PredKey} + {List integer} + MinValue ((let - a-71899 = List-71608 integer + a = List integer in - \(c-71900 : - integer -> a-71899 -> a-71899) - (n-71901 : a-71899) -> - c-71900 100000 (c-71900 0 n-71901)) - (\(ds-71902 : integer) - (ds-71903 : List-71608 integer) -> - Cons-71610 - {integer} - ds-71902 - ds-71903) - (Nil-71609 {integer}))) - (c-71897 - (Tuple2-71614 - {PredKey-71635} - {List-71608 integer} - MaxValue-71636 + \(c : integer -> a -> a) (n : a) -> + c 100000 (c 0 n)) + (\(ds : integer) + (ds : List integer) -> + Cons {integer} ds ds) + (Nil {integer}))) + (c + (Tuple2 + {PredKey} + {List integer} + MaxValue ((let - a-71904 = List-71608 integer + a = List integer in - \(c-71905 : - integer -> a-71904 -> a-71904) - (n-71906 : a-71904) -> - c-71905 10000000 n-71906) - (\(ds-71907 : integer) - (ds-71908 : - List-71608 integer) -> - Cons-71610 - {integer} - ds-71907 - ds-71908) - (Nil-71609 {integer}))) - n-71898))))) - (c-71871 - (Tuple2-71614 + \(c : integer -> a -> a) (n : a) -> + c 10000000 n) + (\(ds : integer) + (ds : List integer) -> + Cons {integer} ds ds) + (Nil {integer}))) + n))))) + (c + (Tuple2 {integer} - {ParamValue-71653} + {ParamValue} 2 - (ParamInteger-71655 + (ParamInteger ((let - a-71909 - = Tuple2-71613 - PredKey-71635 - (List-71608 integer) + a = Tuple2 PredKey (List integer) in - \(g-71910 : - all b-71911. - (a-71909 -> b-71911 -> b-71911) -> - b-71911 -> - b-71911) -> - g-71910 - {List-71608 a-71909} - (\(ds-71912 : a-71909) - (ds-71913 : List-71608 a-71909) -> - Cons-71610 {a-71909} ds-71912 ds-71913) - (Nil-71609 {a-71909})) - (/\a-71914 -> - \(c-71915 : - Tuple2-71613 - PredKey-71635 - (List-71608 integer) -> - a-71914 -> - a-71914) - (n-71916 : a-71914) -> - c-71915 - (Tuple2-71614 - {PredKey-71635} - {List-71608 integer} - MinValue-71637 + \(g : all b. (a -> b -> b) -> b -> b) -> + g + {List a} + (\(ds : a) (ds : List a) -> Cons {a} ds ds) + (Nil {a})) + (/\a -> + \(c : + Tuple2 PredKey (List integer) -> a -> a) + (n : a) -> + c + (Tuple2 + {PredKey} + {List integer} + MinValue ((let - a-71917 = List-71608 integer + a = List integer in - \(c-71918 : - integer -> a-71917 -> a-71917) - (n-71919 : a-71917) -> - c-71918 24576 n-71919) - (\(ds-71920 : integer) - (ds-71921 : - List-71608 integer) -> - Cons-71610 - {integer} - ds-71920 - ds-71921) - (Nil-71609 {integer}))) - (c-71915 - (Tuple2-71614 - {PredKey-71635} - {List-71608 integer} - MaxValue-71636 + \(c : integer -> a -> a) (n : a) -> + c 24576 n) + (\(ds : integer) + (ds : List integer) -> + Cons {integer} ds ds) + (Nil {integer}))) + (c + (Tuple2 + {PredKey} + {List integer} + MaxValue ((let - a-71922 = List-71608 integer + a = List integer in - \(c-71923 : - integer -> - a-71922 -> - a-71922) - (n-71924 : a-71922) -> - c-71923 122880 n-71924) - (\(ds-71925 : integer) - (ds-71926 : - List-71608 integer) -> - Cons-71610 - {integer} - ds-71925 - ds-71926) - (Nil-71609 {integer}))) - n-71916))))) - (c-71871 - (Tuple2-71614 + \(c : integer -> a -> a) + (n : a) -> + c 122880 n) + (\(ds : integer) + (ds : List integer) -> + Cons {integer} ds ds) + (Nil {integer}))) + n))))) + (c + (Tuple2 {integer} - {ParamValue-71653} + {ParamValue} 3 - (ParamInteger-71655 + (ParamInteger ((let - a-71927 - = Tuple2-71613 - PredKey-71635 - (List-71608 integer) + a = Tuple2 PredKey (List integer) in - \(g-71928 : - all b-71929. - (a-71927 -> b-71929 -> b-71929) -> - b-71929 -> - b-71929) -> - g-71928 - {List-71608 a-71927} - (\(ds-71930 : a-71927) - (ds-71931 : List-71608 a-71927) -> - Cons-71610 - {a-71927} - ds-71930 - ds-71931) - (Nil-71609 {a-71927})) - (/\a-71932 -> - \(c-71933 : - Tuple2-71613 - PredKey-71635 - (List-71608 integer) -> - a-71932 -> - a-71932) - (n-71934 : a-71932) -> - c-71933 - (Tuple2-71614 - {PredKey-71635} - {List-71608 integer} - MinValue-71637 + \(g : all b. (a -> b -> b) -> b -> b) -> + g + {List a} + (\(ds : a) (ds : List a) -> + Cons {a} ds ds) + (Nil {a})) + (/\a -> + \(c : + Tuple2 PredKey (List integer) -> + a -> + a) + (n : a) -> + c + (Tuple2 + {PredKey} + {List integer} + MinValue ((let - a-71935 = List-71608 integer + a = List integer in - \(c-71936 : - integer -> - a-71935 -> - a-71935) - (n-71937 : a-71935) -> - c-71936 0 n-71937) - (\(ds-71938 : integer) - (ds-71939 : - List-71608 integer) -> - Cons-71610 - {integer} - ds-71938 - ds-71939) - (Nil-71609 {integer}))) - (c-71933 - (Tuple2-71614 - {PredKey-71635} - {List-71608 integer} - MaxValue-71636 + \(c : integer -> a -> a) + (n : a) -> + c 0 n) + (\(ds : integer) + (ds : List integer) -> + Cons {integer} ds ds) + (Nil {integer}))) + (c + (Tuple2 + {PredKey} + {List integer} + MaxValue ((let - a-71940 - = List-71608 integer + a = List integer in - \(c-71941 : - integer -> - a-71940 -> - a-71940) - (n-71942 : a-71940) -> - c-71941 32768 n-71942) - (\(ds-71943 : integer) - (ds-71944 : - List-71608 integer) -> - Cons-71610 - {integer} - ds-71943 - ds-71944) - (Nil-71609 {integer}))) - n-71934))))) - (c-71871 - (Tuple2-71614 + \(c : integer -> a -> a) + (n : a) -> + c 32768 n) + (\(ds : integer) + (ds : List integer) -> + Cons {integer} ds ds) + (Nil {integer}))) + n))))) + (c + (Tuple2 {integer} - {ParamValue-71653} + {ParamValue} 4 - (ParamInteger-71655 + (ParamInteger ((let - a-71945 - = Tuple2-71613 - PredKey-71635 - (List-71608 integer) + a = Tuple2 PredKey (List integer) in - \(g-71946 : - all b-71947. - (a-71945 -> b-71947 -> b-71947) -> - b-71947 -> - b-71947) -> - g-71946 - {List-71608 a-71945} - (\(ds-71948 : a-71945) - (ds-71949 : List-71608 a-71945) -> - Cons-71610 - {a-71945} - ds-71948 - ds-71949) - (Nil-71609 {a-71945})) - (/\a-71950 -> - \(c-71951 : - Tuple2-71613 - PredKey-71635 - (List-71608 integer) -> - a-71950 -> - a-71950) - (n-71952 : a-71950) -> - c-71951 - (Tuple2-71614 - {PredKey-71635} - {List-71608 integer} - MinValue-71637 + \(g : all b. (a -> b -> b) -> b -> b) -> + g + {List a} + (\(ds : a) (ds : List a) -> + Cons {a} ds ds) + (Nil {a})) + (/\a -> + \(c : + Tuple2 PredKey (List integer) -> + a -> + a) + (n : a) -> + c + (Tuple2 + {PredKey} + {List integer} + MinValue ((let - a-71953 - = List-71608 integer + a = List integer in - \(c-71954 : - integer -> - a-71953 -> - a-71953) - (n-71955 : a-71953) -> - c-71954 0 n-71955) - (\(ds-71956 : integer) - (ds-71957 : - List-71608 integer) -> - Cons-71610 - {integer} - ds-71956 - ds-71957) - (Nil-71609 {integer}))) - (c-71951 - (Tuple2-71614 - {PredKey-71635} - {List-71608 integer} - MaxValue-71636 + \(c : integer -> a -> a) + (n : a) -> + c 0 n) + (\(ds : integer) + (ds : List integer) -> + Cons {integer} ds ds) + (Nil {integer}))) + (c + (Tuple2 + {PredKey} + {List integer} + MaxValue ((let - a-71958 - = List-71608 integer + a = List integer in - \(c-71959 : - integer -> - a-71958 -> - a-71958) - (n-71960 : a-71958) -> - c-71959 5000 n-71960) - (\(ds-71961 : integer) - (ds-71962 : - List-71608 - integer) -> - Cons-71610 - {integer} - ds-71961 - ds-71962) - (Nil-71609 {integer}))) - n-71952))))) - (c-71871 - (Tuple2-71614 + \(c : integer -> a -> a) + (n : a) -> + c 5000 n) + (\(ds : integer) + (ds : List integer) -> + Cons {integer} ds ds) + (Nil {integer}))) + n))))) + (c + (Tuple2 {integer} - {ParamValue-71653} + {ParamValue} 5 - (ParamInteger-71655 + (ParamInteger ((let - a-71963 - = Tuple2-71613 - PredKey-71635 - (List-71608 integer) + a = Tuple2 PredKey (List integer) in - \(g-71964 : - all b-71965. - (a-71963 -> - b-71965 -> - b-71965) -> - b-71965 -> - b-71965) -> - g-71964 - {List-71608 a-71963} - (\(ds-71966 : a-71963) - (ds-71967 : - List-71608 a-71963) -> - Cons-71610 - {a-71963} - ds-71966 - ds-71967) - (Nil-71609 {a-71963})) - (/\a-71968 -> - \(c-71969 : - Tuple2-71613 - PredKey-71635 - (List-71608 integer) -> - a-71968 -> - a-71968) - (n-71970 : a-71968) -> - c-71969 - (Tuple2-71614 - {PredKey-71635} - {List-71608 integer} - MinValue-71637 + \(g : + all b. (a -> b -> b) -> b -> b) -> + g + {List a} + (\(ds : a) (ds : List a) -> + Cons {a} ds ds) + (Nil {a})) + (/\a -> + \(c : + Tuple2 PredKey (List integer) -> + a -> + a) + (n : a) -> + c + (Tuple2 + {PredKey} + {List integer} + MinValue ((let - a-71971 - = List-71608 integer + a = List integer in - \(c-71972 : - integer -> - a-71971 -> - a-71971) - (n-71973 : a-71971) -> - c-71972 - 1000000 - (c-71972 0 n-71973)) - (\(ds-71974 : integer) - (ds-71975 : - List-71608 - integer) -> - Cons-71610 - {integer} - ds-71974 - ds-71975) - (Nil-71609 {integer}))) - (c-71969 - (Tuple2-71614 - {PredKey-71635} - {List-71608 integer} - MaxValue-71636 + \(c : integer -> a -> a) + (n : a) -> + c 1000000 (c 0 n)) + (\(ds : integer) + (ds : List integer) -> + Cons {integer} ds ds) + (Nil {integer}))) + (c + (Tuple2 + {PredKey} + {List integer} + MaxValue ((let - a-71976 - = List-71608 - integer + a = List integer in - \(c-71977 : - integer -> - a-71976 -> - a-71976) - (n-71978 : a-71976) -> - c-71977 - 5000000 - n-71978) - (\(ds-71979 : integer) - (ds-71980 : - List-71608 - integer) -> - Cons-71610 + \(c : + integer -> a -> a) + (n : a) -> + c 5000000 n) + (\(ds : integer) + (ds : + List integer) -> + Cons {integer} - ds-71979 - ds-71980) - (Nil-71609 {integer}))) - n-71970))))) - (c-71871 - (Tuple2-71614 + ds + ds) + (Nil {integer}))) + n))))) + (c + (Tuple2 {integer} - {ParamValue-71653} + {ParamValue} 6 - (ParamInteger-71655 + (ParamInteger ((let - a-71981 - = Tuple2-71613 - PredKey-71635 - (List-71608 integer) + a = Tuple2 PredKey (List integer) in - \(g-71982 : - all b-71983. - (a-71981 -> - b-71983 -> - b-71983) -> - b-71983 -> - b-71983) -> - g-71982 - {List-71608 a-71981} - (\(ds-71984 : a-71981) - (ds-71985 : - List-71608 a-71981) -> - Cons-71610 - {a-71981} - ds-71984 - ds-71985) - (Nil-71609 {a-71981})) - (/\a-71986 -> - \(c-71987 : - Tuple2-71613 - PredKey-71635 - (List-71608 integer) -> - a-71986 -> - a-71986) - (n-71988 : a-71986) -> - c-71987 - (Tuple2-71614 - {PredKey-71635} - {List-71608 integer} - MinValue-71637 + \(g : + all b. + (a -> b -> b) -> b -> b) -> + g + {List a} + (\(ds : a) (ds : List a) -> + Cons {a} ds ds) + (Nil {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List integer) -> + a -> + a) + (n : a) -> + c + (Tuple2 + {PredKey} + {List integer} + MinValue ((let - a-71989 - = List-71608 - integer + a = List integer in - \(c-71990 : - integer -> - a-71989 -> - a-71989) - (n-71991 : a-71989) -> - c-71990 - 250000000 - (c-71990 - 0 - n-71991)) - (\(ds-71992 : integer) - (ds-71993 : - List-71608 - integer) -> - Cons-71610 + \(c : + integer -> a -> a) + (n : a) -> + c 250000000 (c 0 n)) + (\(ds : integer) + (ds : + List integer) -> + Cons {integer} - ds-71992 - ds-71993) - (Nil-71609 {integer}))) - (c-71987 - (Tuple2-71614 - {PredKey-71635} - {List-71608 integer} - MaxValue-71636 + ds + ds) + (Nil {integer}))) + (c + (Tuple2 + {PredKey} + {List integer} + MaxValue ((let - a-71994 - = List-71608 - integer + a = List integer in - \(c-71995 : + \(c : integer -> - a-71994 -> - a-71994) - (n-71996 : - a-71994) -> - c-71995 - 500000000 - n-71996) - (\(ds-71997 : - integer) - (ds-71998 : - List-71608 + a -> + a) + (n : a) -> + c 500000000 n) + (\(ds : integer) + (ds : + List integer) -> - Cons-71610 + Cons {integer} - ds-71997 - ds-71998) - (Nil-71609 - {integer}))) - n-71988))))) - (c-71871 - (Tuple2-71614 + ds + ds) + (Nil {integer}))) + n))))) + (c + (Tuple2 {integer} - {ParamValue-71653} + {ParamValue} 7 - (ParamInteger-71655 + (ParamInteger ((let - a-71999 - = Tuple2-71613 - PredKey-71635 - (List-71608 integer) + a + = Tuple2 + PredKey + (List integer) in - \(g-72000 : - all b-72001. - (a-71999 -> - b-72001 -> - b-72001) -> - b-72001 -> - b-72001) -> - g-72000 - {List-71608 a-71999} - (\(ds-72002 : a-71999) - (ds-72003 : - List-71608 a-71999) -> - Cons-71610 - {a-71999} - ds-72002 - ds-72003) - (Nil-71609 {a-71999})) - (/\a-72004 -> - \(c-72005 : - Tuple2-71613 - PredKey-71635 - (List-71608 integer) -> - a-72004 -> - a-72004) - (n-72006 : a-72004) -> - c-72005 - (Tuple2-71614 - {PredKey-71635} - {List-71608 integer} - MinValue-71637 + \(g : + all b. + (a -> b -> b) -> b -> b) -> + g + {List a} + (\(ds : a) (ds : List a) -> + Cons {a} ds ds) + (Nil {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List integer) -> + a -> + a) + (n : a) -> + c + (Tuple2 + {PredKey} + {List integer} + MinValue ((let - a-72007 - = List-71608 - integer + a = List integer in - \(c-72008 : + \(c : integer -> - a-72007 -> - a-72007) - (n-72009 : - a-72007) -> - c-72008 0 n-72009) - (\(ds-72010 : - integer) - (ds-72011 : - List-71608 + a -> + a) + (n : a) -> + c 0 n) + (\(ds : integer) + (ds : + List integer) -> - Cons-71610 + Cons {integer} - ds-72010 - ds-72011) - (Nil-71609 - {integer}))) - n-72006)))) - (c-71871 - (Tuple2-71614 + ds + ds) + (Nil {integer}))) + n)))) + (c + (Tuple2 {integer} - {ParamValue-71653} + {ParamValue} 8 - (ParamInteger-71655 + (ParamInteger ((let - a-72012 - = Tuple2-71613 - PredKey-71635 - (List-71608 integer) + a + = Tuple2 + PredKey + (List integer) in - \(g-72013 : - all b-72014. - (a-72012 -> - b-72014 -> - b-72014) -> - b-72014 -> - b-72014) -> - g-72013 - {List-71608 a-72012} - (\(ds-72015 : a-72012) - (ds-72016 : - List-71608 - a-72012) -> - Cons-71610 - {a-72012} - ds-72015 - ds-72016) - (Nil-71609 {a-72012})) - (/\a-72017 -> - \(c-72018 : - Tuple2-71613 - PredKey-71635 - (List-71608 - integer) -> - a-72017 -> - a-72017) - (n-72019 : a-72017) -> - c-72018 - (Tuple2-71614 - {PredKey-71635} - {List-71608 integer} - MinValue-71637 + \(g : + all b. + (a -> b -> b) -> + b -> + b) -> + g + {List a} + (\(ds : a) + (ds : List a) -> + Cons {a} ds ds) + (Nil {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List integer) -> + a -> + a) + (n : a) -> + c + (Tuple2 + {PredKey} + {List integer} + MinValue ((let - a-72020 - = List-71608 + a + = List integer in - \(c-72021 : + \(c : integer -> - a-72020 -> - a-72020) - (n-72022 : - a-72020) -> - c-72021 - 250 - (c-72021 - 0 - n-72022)) - (\(ds-72023 : - integer) - (ds-72024 : - List-71608 + a -> + a) + (n : a) -> + c 250 (c 0 n)) + (\(ds : integer) + (ds : + List integer) -> - Cons-71610 + Cons {integer} - ds-72023 - ds-72024) - (Nil-71609 - {integer}))) - (c-72018 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - integer} - MaxValue-71636 + ds + ds) + (Nil {integer}))) + (c + (Tuple2 + {PredKey} + {List integer} + MaxValue ((let - a-72025 - = List-71608 + a + = List integer in - \(c-72026 : + \(c : integer -> - a-72025 -> - a-72025) - (n-72027 : - a-72025) -> - c-72026 - 2000 - n-72027) - (\(ds-72028 : + a -> + a) + (n : a) -> + c 2000 n) + (\(ds : integer) - (ds-72029 : - List-71608 + (ds : + List integer) -> - Cons-71610 + Cons {integer} - ds-72028 - ds-72029) - (Nil-71609 + ds + ds) + (Nil {integer}))) - (c-72018 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - integer} - NotEqual-71638 + (c + (Tuple2 + {PredKey} + {List integer} + NotEqual ((let - a-72030 - = List-71608 + a + = List integer in - \(c-72031 : + \(c : integer -> - a-72030 -> - a-72030) - (n-72032 : - a-72030) -> - c-72031 - 0 - n-72032) - (\(ds-72033 : + a -> + a) + (n : a) -> + c 0 n) + (\(ds : integer) - (ds-72034 : - List-71608 + (ds : + List integer) -> - Cons-71610 + Cons {integer} - ds-72033 - ds-72034) - (Nil-71609 + ds + ds) + (Nil {integer}))) - n-72019)))))) - (c-71871 - (Tuple2-71614 + n)))))) + (c + (Tuple2 {integer} - {ParamValue-71653} + {ParamValue} 9 - (ParamRational-71657 + (ParamRational ((let - a-72035 - = Tuple2-71613 - PredKey-71635 - (List-71608 - Rational-71650) + a + = Tuple2 + PredKey + (List Rational) in - \(g-72036 : - all b-72037. - (a-72035 -> - b-72037 -> - b-72037) -> - b-72037 -> - b-72037) -> - g-72036 - {List-71608 a-72035} - (\(ds-72038 : a-72035) - (ds-72039 : - List-71608 - a-72035) -> - Cons-71610 - {a-72035} - ds-72038 - ds-72039) - (Nil-71609 {a-72035})) - (/\a-72040 -> - \(c-72041 : - Tuple2-71613 - PredKey-71635 - (List-71608 - Rational-71650) -> - a-72040 -> - a-72040) - (n-72042 : a-72040) -> - c-72041 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - Rational-71650} - MinValue-71637 + \(g : + all b. + (a -> b -> b) -> + b -> + b) -> + g + {List a} + (\(ds : a) + (ds : List a) -> + Cons {a} ds ds) + (Nil {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List Rational) -> + a -> + a) + (n : a) -> + c + (Tuple2 + {PredKey} + {List Rational} + MinValue ((let - a-72043 - = List-71608 - Rational-71650 + a + = List + Rational in - \(c-72044 : - Rational-71650 -> - a-72043 -> - a-72043) - (n-72045 : - a-72043) -> - c-72044 - (unsafeRatio-71668 + \(c : + Rational -> + a -> + a) + (n : a) -> + c + (unsafeRatio 1 10) - (c-72044 - (unsafeRatio-71668 + (c + (unsafeRatio 0 1) - n-72045)) - (\(ds-72046 : - Rational-71650) - (ds-72047 : - List-71608 - Rational-71650) -> - Cons-71610 - {Rational-71650} - ds-72046 - ds-72047) - (Nil-71609 - {Rational-71650}))) - (c-72041 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - Rational-71650} - MaxValue-71636 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + (c + (Tuple2 + {PredKey} + {List + Rational} + MaxValue ((let - a-72048 - = List-71608 - Rational-71650 + a + = List + Rational in - \(c-72049 : - Rational-71650 -> - a-72048 -> - a-72048) - (n-72050 : - a-72048) -> - c-72049 - (unsafeRatio-71668 + \(c : + Rational -> + a -> + a) + (n : a) -> + c + (unsafeRatio 1 1) - n-72050) - (\(ds-72051 : - Rational-71650) - (ds-72052 : - List-71608 - Rational-71650) -> - Cons-71610 - {Rational-71650} - ds-72051 - ds-72052) - (Nil-71609 - {Rational-71650}))) - n-72042))))) - (c-71871 - (Tuple2-71614 + n) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + n))))) + (c + (Tuple2 {integer} - {ParamValue-71653} + {ParamValue} 10 - (ParamRational-71657 + (ParamRational ((let - a-72053 - = Tuple2-71613 - PredKey-71635 - (List-71608 - Rational-71650) + a + = Tuple2 + PredKey + (List Rational) in - \(g-72054 : - all b-72055. - (a-72053 -> - b-72055 -> - b-72055) -> - b-72055 -> - b-72055) -> - g-72054 - {List-71608 a-72053} - (\(ds-72056 : - a-72053) - (ds-72057 : - List-71608 - a-72053) -> - Cons-71610 - {a-72053} - ds-72056 - ds-72057) - (Nil-71609 - {a-72053})) - (/\a-72058 -> - \(c-72059 : - Tuple2-71613 - PredKey-71635 - (List-71608 - Rational-71650) -> - a-72058 -> - a-72058) - (n-72060 : - a-72058) -> - c-72059 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - Rational-71650} - MinValue-71637 + \(g : + all b. + (a -> b -> b) -> + b -> + b) -> + g + {List a} + (\(ds : a) + (ds : List a) -> + Cons {a} ds ds) + (Nil {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List + Rational) -> + a -> + a) + (n : a) -> + c + (Tuple2 + {PredKey} + {List + Rational} + MinValue ((let - a-72061 - = List-71608 - Rational-71650 + a + = List + Rational in - \(c-72062 : - Rational-71650 -> - a-72061 -> - a-72061) - (n-72063 : - a-72061) -> - c-72062 - (unsafeRatio-71668 + \(c : + Rational -> + a -> + a) + (n : a) -> + c + (unsafeRatio 1 1000) - (c-72062 - (unsafeRatio-71668 + (c + (unsafeRatio 0 1) - n-72063)) - (\(ds-72064 : - Rational-71650) - (ds-72065 : - List-71608 - Rational-71650) -> - Cons-71610 - {Rational-71650} - ds-72064 - ds-72065) - (Nil-71609 - {Rational-71650}))) - (c-72059 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - Rational-71650} - MaxValue-71636 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + (c + (Tuple2 + {PredKey} + {List + Rational} + MaxValue ((let - a-72066 - = List-71608 - Rational-71650 + a + = List + Rational in - \(c-72067 : - Rational-71650 -> - a-72066 -> - a-72066) - (n-72068 : - a-72066) -> - c-72067 - (unsafeRatio-71668 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 200) - n-72068) - (\(ds-72069 : - Rational-71650) - (ds-72070 : - List-71608 - Rational-71650) -> - Cons-71610 - {Rational-71650} - ds-72069 - ds-72070) - (Nil-71609 - {Rational-71650}))) - n-72060))))) - (c-71871 - (Tuple2-71614 + n) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + n))))) + (c + (Tuple2 {integer} - {ParamValue-71653} + {ParamValue} 11 - (ParamRational-71657 + (ParamRational ((let - a-72071 - = Tuple2-71613 - PredKey-71635 - (List-71608 - Rational-71650) + a + = Tuple2 + PredKey + (List + Rational) in - \(g-72072 : - all b-72073. - (a-72071 -> - b-72073 -> - b-72073) -> - b-72073 -> - b-72073) -> - g-72072 - {List-71608 - a-72071} - (\(ds-72074 : - a-72071) - (ds-72075 : - List-71608 - a-72071) -> - Cons-71610 - {a-72071} - ds-72074 - ds-72075) - (Nil-71609 - {a-72071})) - (/\a-72076 -> - \(c-72077 : - Tuple2-71613 - PredKey-71635 - (List-71608 - Rational-71650) -> - a-72076 -> - a-72076) - (n-72078 : - a-72076) -> - c-72077 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - Rational-71650} - MinValue-71637 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List a} + (\(ds : a) + (ds : + List a) -> + Cons + {a} + ds + ds) + (Nil {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List + Rational) -> + a -> + a) + (n : a) -> + c + (Tuple2 + {PredKey} + {List + Rational} + MinValue ((let - a-72079 - = List-71608 - Rational-71650 + a + = List + Rational in - \(c-72080 : - Rational-71650 -> - a-72079 -> - a-72079) - (n-72081 : - a-72079) -> - c-72080 - (unsafeRatio-71668 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 10) - (c-72080 - (unsafeRatio-71668 + (c + (unsafeRatio 0 1) - n-72081)) - (\(ds-72082 : - Rational-71650) - (ds-72083 : - List-71608 - Rational-71650) -> - Cons-71610 - {Rational-71650} - ds-72082 - ds-72083) - (Nil-71609 - {Rational-71650}))) - (c-72077 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - Rational-71650} - MaxValue-71636 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + (c + (Tuple2 + {PredKey} + {List + Rational} + MaxValue ((let - a-72084 - = List-71608 - Rational-71650 + a + = List + Rational in - \(c-72085 : - Rational-71650 -> - a-72084 -> - a-72084) - (n-72086 : - a-72084) -> - c-72085 - (unsafeRatio-71668 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 3 10) - (c-72085 - (unsafeRatio-71668 + (c + (unsafeRatio 1 1) - n-72086)) - (\(ds-72087 : - Rational-71650) - (ds-72088 : - List-71608 - Rational-71650) -> - Cons-71610 - {Rational-71650} - ds-72087 - ds-72088) - (Nil-71609 - {Rational-71650}))) - n-72078))))) - (c-71871 - (Tuple2-71614 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + n))))) + (c + (Tuple2 {integer} - {ParamValue-71653} + {ParamValue} 16 - (ParamInteger-71655 + (ParamInteger ((let - a-72089 - = Tuple2-71613 - PredKey-71635 - (List-71608 + a + = Tuple2 + PredKey + (List integer) in - \(g-72090 : - all b-72091. - (a-72089 -> - b-72091 -> - b-72091) -> - b-72091 -> - b-72091) -> - g-72090 - {List-71608 - a-72089} - (\(ds-72092 : - a-72089) - (ds-72093 : - List-71608 - a-72089) -> - Cons-71610 - {a-72089} - ds-72092 - ds-72093) - (Nil-71609 - {a-72089})) - (/\a-72094 -> - \(c-72095 : - Tuple2-71613 - PredKey-71635 - (List-71608 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List a} + (\(ds : a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List integer) -> - a-72094 -> - a-72094) - (n-72096 : - a-72094) -> - c-72095 - (Tuple2-71614 - {PredKey-71635} - {List-71608 + a -> + a) + (n : a) -> + c + (Tuple2 + {PredKey} + {List integer} - MinValue-71637 + MinValue ((let - a-72097 - = List-71608 + a + = List integer in - \(c-72098 : + \(c : integer -> - a-72097 -> - a-72097) - (n-72099 : - a-72097) -> - c-72098 + a -> + a) + (n : + a) -> + c 0 - n-72099) - (\(ds-72100 : + n) + (\(ds : integer) - (ds-72101 : - List-71608 + (ds : + List integer) -> - Cons-71610 + Cons {integer} - ds-72100 - ds-72101) - (Nil-71609 + ds + ds) + (Nil {integer}))) - (c-72095 - (Tuple2-71614 - {PredKey-71635} - {List-71608 + (c + (Tuple2 + {PredKey} + {List integer} - MaxValue-71636 + MaxValue ((let - a-72102 - = List-71608 + a + = List integer in - \(c-72103 : + \(c : integer -> - a-72102 -> - a-72102) - (n-72104 : - a-72102) -> - c-72103 + a -> + a) + (n : + a) -> + c 500000000 - n-72104) - (\(ds-72105 : + n) + (\(ds : integer) - (ds-72106 : - List-71608 + (ds : + List integer) -> - Cons-71610 + Cons {integer} - ds-72105 - ds-72106) - (Nil-71609 + ds + ds) + (Nil {integer}))) - n-72096))))) - (c-71871 - (Tuple2-71614 + n))))) + (c + (Tuple2 {integer} - {ParamValue-71653} + {ParamValue} 17 - (ParamInteger-71655 + (ParamInteger ((let - a-72107 - = Tuple2-71613 - PredKey-71635 - (List-71608 + a + = Tuple2 + PredKey + (List integer) in - \(g-72108 : - all b-72109. - (a-72107 -> - b-72109 -> - b-72109) -> - b-72109 -> - b-72109) -> - g-72108 - {List-71608 - a-72107} - (\(ds-72110 : - a-72107) - (ds-72111 : - List-71608 - a-72107) -> - Cons-71610 - {a-72107} - ds-72110 - ds-72111) - (Nil-71609 - {a-72107})) - (/\a-72112 -> - \(c-72113 : - Tuple2-71613 - PredKey-71635 - (List-71608 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List a} + (\(ds : a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List integer) -> - a-72112 -> - a-72112) - (n-72114 : - a-72112) -> - c-72113 - (Tuple2-71614 - {PredKey-71635} - {List-71608 + a -> + a) + (n : a) -> + c + (Tuple2 + {PredKey} + {List integer} - MinValue-71637 + MinValue ((let - a-72115 - = List-71608 + a + = List integer in - \(c-72116 : + \(c : integer -> - a-72115 -> - a-72115) - (n-72117 : - a-72115) -> - c-72116 + a -> + a) + (n : + a) -> + c 3000 - (c-72116 + (c 0 - n-72117)) - (\(ds-72118 : + n)) + (\(ds : integer) - (ds-72119 : - List-71608 + (ds : + List integer) -> - Cons-71610 + Cons {integer} - ds-72118 - ds-72119) - (Nil-71609 + ds + ds) + (Nil {integer}))) - (c-72113 - (Tuple2-71614 - {PredKey-71635} - {List-71608 + (c + (Tuple2 + {PredKey} + {List integer} - MaxValue-71636 + MaxValue ((let - a-72120 - = List-71608 + a + = List integer in - \(c-72121 : + \(c : integer -> - a-72120 -> - a-72120) - (n-72122 : - a-72120) -> - c-72121 + a -> + a) + (n : + a) -> + c 6500 - n-72122) - (\(ds-72123 : + n) + (\(ds : integer) - (ds-72124 : - List-71608 + (ds : + List integer) -> - Cons-71610 + Cons {integer} - ds-72123 - ds-72124) - (Nil-71609 + ds + ds) + (Nil {integer}))) - (c-72113 - (Tuple2-71614 - {PredKey-71635} - {List-71608 + (c + (Tuple2 + {PredKey} + {List integer} - NotEqual-71638 + NotEqual ((let - a-72125 - = List-71608 + a + = List integer in - \(c-72126 : + \(c : integer -> - a-72125 -> - a-72125) - (n-72127 : - a-72125) -> - c-72126 + a -> + a) + (n : + a) -> + c 0 - n-72127) - (\(ds-72128 : + n) + (\(ds : integer) - (ds-72129 : - List-71608 + (ds : + List integer) -> - Cons-71610 + Cons {integer} - ds-72128 - ds-72129) - (Nil-71609 + ds + ds) + (Nil {integer}))) - n-72114)))))) - (c-71871 - (Tuple2-71614 + n)))))) + (c + (Tuple2 {integer} - {ParamValue-71653} + {ParamValue} 18 - ParamAny-71654) - (c-71871 - (Tuple2-71614 + ParamAny) + (c + (Tuple2 {integer} - {ParamValue-71653} + {ParamValue} 19 - (ParamList-71656 + (ParamList ((let - a-72130 - = List-71608 - ParamValue-71653 + a + = List + ParamValue in - \(c-72131 : - ParamValue-71653 -> - a-72130 -> - a-72130) - (n-72132 : - a-72130) -> - c-72131 - (ParamRational-71657 + \(c : + ParamValue -> + a -> + a) + (n : + a) -> + c + (ParamRational ((let - a-72133 - = Tuple2-71613 - PredKey-71635 - (List-71608 - Rational-71650) + a + = Tuple2 + PredKey + (List + Rational) in - \(g-72134 : - all b-72135. - (a-72133 -> - b-72135 -> - b-72135) -> - b-72135 -> - b-72135) -> - g-72134 - {List-71608 - a-72133} - (\(ds-72136 : - a-72133) - (ds-72137 : - List-71608 - a-72133) -> - Cons-71610 - {a-72133} - ds-72136 - ds-72137) - (Nil-71609 - {a-72133})) - (/\a-72138 -> - \(c-72139 : - Tuple2-71613 - PredKey-71635 - (List-71608 - Rational-71650) -> - a-72138 -> - a-72138) - (n-72140 : - a-72138) -> - c-72139 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - Rational-71650} - MinValue-71637 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List + Rational) -> + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List + Rational} + MinValue ((let - a-72141 - = List-71608 - Rational-71650 + a + = List + Rational in - \(c-72142 : - Rational-71650 -> - a-72141 -> - a-72141) - (n-72143 : - a-72141) -> - c-72142 - (unsafeRatio-71668 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 25) - n-72143) - (\(ds-72144 : - Rational-71650) - (ds-72145 : - List-71608 - Rational-71650) -> - Cons-71610 - {Rational-71650} - ds-72144 - ds-72145) - (Nil-71609 - {Rational-71650}))) - (c-72139 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - Rational-71650} - MaxValue-71636 + n) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + (c + (Tuple2 + {PredKey} + {List + Rational} + MaxValue ((let - a-72146 - = List-71608 - Rational-71650 + a + = List + Rational in - \(c-72147 : - Rational-71650 -> - a-72146 -> - a-72146) - (n-72148 : - a-72146) -> - c-72147 - (unsafeRatio-71668 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 5) - n-72148) - (\(ds-72149 : - Rational-71650) - (ds-72150 : - List-71608 - Rational-71650) -> - Cons-71610 - {Rational-71650} - ds-72149 - ds-72150) - (Nil-71609 - {Rational-71650}))) - n-72140)))) - (c-72131 - (ParamRational-71657 + n) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + n)))) + (c + (ParamRational ((let - a-72151 - = Tuple2-71613 - PredKey-71635 - (List-71608 - Rational-71650) + a + = Tuple2 + PredKey + (List + Rational) in - \(g-72152 : - all b-72153. - (a-72151 -> - b-72153 -> - b-72153) -> - b-72153 -> - b-72153) -> - g-72152 - {List-71608 - a-72151} - (\(ds-72154 : - a-72151) - (ds-72155 : - List-71608 - a-72151) -> - Cons-71610 - {a-72151} - ds-72154 - ds-72155) - (Nil-71609 - {a-72151})) - (/\a-72156 -> - \(c-72157 : - Tuple2-71613 - PredKey-71635 - (List-71608 - Rational-71650) -> - a-72156 -> - a-72156) - (n-72158 : - a-72156) -> - c-72157 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - Rational-71650} - MinValue-71637 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List + Rational) -> + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List + Rational} + MinValue ((let - a-72159 - = List-71608 - Rational-71650 + a + = List + Rational in - \(c-72160 : - Rational-71650 -> - a-72159 -> - a-72159) - (n-72161 : - a-72159) -> - c-72160 - (unsafeRatio-71668 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 20000) - n-72161) - (\(ds-72162 : - Rational-71650) - (ds-72163 : - List-71608 - Rational-71650) -> - Cons-71610 - {Rational-71650} - ds-72162 - ds-72163) - (Nil-71609 - {Rational-71650}))) - (c-72157 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - Rational-71650} - MaxValue-71636 + n) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + (c + (Tuple2 + {PredKey} + {List + Rational} + MaxValue ((let - a-72164 - = List-71608 - Rational-71650 + a + = List + Rational in - \(c-72165 : - Rational-71650 -> - a-72164 -> - a-72164) - (n-72166 : - a-72164) -> - c-72165 - (unsafeRatio-71668 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 5000) - n-72166) - (\(ds-72167 : - Rational-71650) - (ds-72168 : - List-71608 - Rational-71650) -> - Cons-71610 - {Rational-71650} - ds-72167 - ds-72168) - (Nil-71609 - {Rational-71650}))) - n-72158)))) - n-72132)) - (\(ds-72169 : - ParamValue-71653) - (ds-72170 : - List-71608 - ParamValue-71653) -> - Cons-71610 - {ParamValue-71653} - ds-72169 - ds-72170) - (Nil-71609 - {ParamValue-71653})))) - (c-71871 - (Tuple2-71614 + n) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + n)))) + n)) + (\(ds : + ParamValue) + (ds : + List + ParamValue) -> + Cons + {ParamValue} + ds + ds) + (Nil + {ParamValue})))) + (c + (Tuple2 {integer} - {ParamValue-71653} + {ParamValue} 20 - (ParamList-71656 + (ParamList ((let - a-72171 - = List-71608 - ParamValue-71653 + a + = List + ParamValue in - \(c-72172 : - ParamValue-71653 -> - a-72171 -> - a-72171) - (n-72173 : - a-72171) -> - c-72172 - (ParamInteger-71655 + \(c : + ParamValue -> + a -> + a) + (n : + a) -> + c + (ParamInteger ((let - a-72174 - = Tuple2-71613 - PredKey-71635 - (List-71608 + a + = Tuple2 + PredKey + (List integer) in - \(g-72175 : - all b-72176. - (a-72174 -> - b-72176 -> - b-72176) -> - b-72176 -> - b-72176) -> - g-72175 - {List-71608 - a-72174} - (\(ds-72177 : - a-72174) - (ds-72178 : - List-71608 - a-72174) -> - Cons-71610 - {a-72174} - ds-72177 - ds-72178) - (Nil-71609 - {a-72174})) - (/\a-72179 -> - \(c-72180 : - Tuple2-71613 - PredKey-71635 - (List-71608 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List integer) -> - a-72179 -> - a-72179) - (n-72181 : - a-72179) -> - c-72180 - (Tuple2-71614 - {PredKey-71635} - {List-71608 + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List integer} - MinValue-71637 + MinValue ((let - a-72182 - = List-71608 + a + = List integer in - \(c-72183 : + \(c : integer -> - a-72182 -> - a-72182) - (n-72184 : - a-72182) -> - c-72183 + a -> + a) + (n : + a) -> + c 0 - n-72184) - (\(ds-72185 : + n) + (\(ds : integer) - (ds-72186 : - List-71608 + (ds : + List integer) -> - Cons-71610 + Cons {integer} - ds-72185 - ds-72186) - (Nil-71609 + ds + ds) + (Nil {integer}))) - (c-72180 - (Tuple2-71614 - {PredKey-71635} - {List-71608 + (c + (Tuple2 + {PredKey} + {List integer} - MaxValue-71636 + MaxValue ((let - a-72187 - = List-71608 + a + = List integer in - \(c-72188 : + \(c : integer -> - a-72187 -> - a-72187) - (n-72189 : - a-72187) -> - c-72188 + a -> + a) + (n : + a) -> + c 40000000 - n-72189) - (\(ds-72190 : + n) + (\(ds : integer) - (ds-72191 : - List-71608 + (ds : + List integer) -> - Cons-71610 + Cons {integer} - ds-72190 - ds-72191) - (Nil-71609 + ds + ds) + (Nil {integer}))) - n-72181)))) - (c-72172 - (ParamInteger-71655 + n)))) + (c + (ParamInteger ((let - a-72192 - = Tuple2-71613 - PredKey-71635 - (List-71608 + a + = Tuple2 + PredKey + (List integer) in - \(g-72193 : - all b-72194. - (a-72192 -> - b-72194 -> - b-72194) -> - b-72194 -> - b-72194) -> - g-72193 - {List-71608 - a-72192} - (\(ds-72195 : - a-72192) - (ds-72196 : - List-71608 - a-72192) -> - Cons-71610 - {a-72192} - ds-72195 - ds-72196) - (Nil-71609 - {a-72192})) - (/\a-72197 -> - \(c-72198 : - Tuple2-71613 - PredKey-71635 - (List-71608 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List integer) -> - a-72197 -> - a-72197) - (n-72199 : - a-72197) -> - c-72198 - (Tuple2-71614 - {PredKey-71635} - {List-71608 + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List integer} - MinValue-71637 + MinValue ((let - a-72200 - = List-71608 + a + = List integer in - \(c-72201 : + \(c : integer -> - a-72200 -> - a-72200) - (n-72202 : - a-72200) -> - c-72201 + a -> + a) + (n : + a) -> + c 0 - n-72202) - (\(ds-72203 : + n) + (\(ds : integer) - (ds-72204 : - List-71608 + (ds : + List integer) -> - Cons-71610 + Cons {integer} - ds-72203 - ds-72204) - (Nil-71609 + ds + ds) + (Nil {integer}))) - (c-72198 - (Tuple2-71614 - {PredKey-71635} - {List-71608 + (c + (Tuple2 + {PredKey} + {List integer} - MaxValue-71636 + MaxValue ((let - a-72205 - = List-71608 + a + = List integer in - \(c-72206 : + \(c : integer -> - a-72205 -> - a-72205) - (n-72207 : - a-72205) -> - c-72206 + a -> + a) + (n : + a) -> + c 15000000000 - n-72207) - (\(ds-72208 : + n) + (\(ds : integer) - (ds-72209 : - List-71608 + (ds : + List integer) -> - Cons-71610 + Cons {integer} - ds-72208 - ds-72209) - (Nil-71609 + ds + ds) + (Nil {integer}))) - n-72199)))) - n-72173)) - (\(ds-72210 : - ParamValue-71653) - (ds-72211 : - List-71608 - ParamValue-71653) -> - Cons-71610 - {ParamValue-71653} - ds-72210 - ds-72211) - (Nil-71609 - {ParamValue-71653})))) - (c-71871 - (Tuple2-71614 + n)))) + n)) + (\(ds : + ParamValue) + (ds : + List + ParamValue) -> + Cons + {ParamValue} + ds + ds) + (Nil + {ParamValue})))) + (c + (Tuple2 {integer} - {ParamValue-71653} + {ParamValue} 21 - (ParamList-71656 + (ParamList ((let - a-72212 - = List-71608 - ParamValue-71653 + a + = List + ParamValue in - \(c-72213 : - ParamValue-71653 -> - a-72212 -> - a-72212) - (n-72214 : - a-72212) -> - c-72213 - (ParamInteger-71655 + \(c : + ParamValue -> + a -> + a) + (n : + a) -> + c + (ParamInteger ((let - a-72215 - = Tuple2-71613 - PredKey-71635 - (List-71608 + a + = Tuple2 + PredKey + (List integer) in - \(g-72216 : - all b-72217. - (a-72215 -> - b-72217 -> - b-72217) -> - b-72217 -> - b-72217) -> - g-72216 - {List-71608 - a-72215} - (\(ds-72218 : - a-72215) - (ds-72219 : - List-71608 - a-72215) -> - Cons-71610 - {a-72215} - ds-72218 - ds-72219) - (Nil-71609 - {a-72215})) - (/\a-72220 -> - \(c-72221 : - Tuple2-71613 - PredKey-71635 - (List-71608 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List integer) -> - a-72220 -> - a-72220) - (n-72222 : - a-72220) -> - c-72221 - (Tuple2-71614 - {PredKey-71635} - {List-71608 + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List integer} - MinValue-71637 + MinValue ((let - a-72223 - = List-71608 + a + = List integer in - \(c-72224 : + \(c : integer -> - a-72223 -> - a-72223) - (n-72225 : - a-72223) -> - c-72224 + a -> + a) + (n : + a) -> + c 0 - n-72225) - (\(ds-72226 : + n) + (\(ds : integer) - (ds-72227 : - List-71608 + (ds : + List integer) -> - Cons-71610 + Cons {integer} - ds-72226 - ds-72227) - (Nil-71609 + ds + ds) + (Nil {integer}))) - (c-72221 - (Tuple2-71614 - {PredKey-71635} - {List-71608 + (c + (Tuple2 + {PredKey} + {List integer} - MaxValue-71636 + MaxValue ((let - a-72228 - = List-71608 + a + = List integer in - \(c-72229 : + \(c : integer -> - a-72228 -> - a-72228) - (n-72230 : - a-72228) -> - c-72229 + a -> + a) + (n : + a) -> + c 120000000 - n-72230) - (\(ds-72231 : + n) + (\(ds : integer) - (ds-72232 : - List-71608 + (ds : + List integer) -> - Cons-71610 + Cons {integer} - ds-72231 - ds-72232) - (Nil-71609 + ds + ds) + (Nil {integer}))) - n-72222)))) - (c-72213 - (ParamInteger-71655 + n)))) + (c + (ParamInteger ((let - a-72233 - = Tuple2-71613 - PredKey-71635 - (List-71608 + a + = Tuple2 + PredKey + (List integer) in - \(g-72234 : - all b-72235. - (a-72233 -> - b-72235 -> - b-72235) -> - b-72235 -> - b-72235) -> - g-72234 - {List-71608 - a-72233} - (\(ds-72236 : - a-72233) - (ds-72237 : - List-71608 - a-72233) -> - Cons-71610 - {a-72233} - ds-72236 - ds-72237) - (Nil-71609 - {a-72233})) - (/\a-72238 -> - \(c-72239 : - Tuple2-71613 - PredKey-71635 - (List-71608 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List integer) -> - a-72238 -> - a-72238) - (n-72240 : - a-72238) -> - c-72239 - (Tuple2-71614 - {PredKey-71635} - {List-71608 + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List integer} - MinValue-71637 + MinValue ((let - a-72241 - = List-71608 + a + = List integer in - \(c-72242 : + \(c : integer -> - a-72241 -> - a-72241) - (n-72243 : - a-72241) -> - c-72242 + a -> + a) + (n : + a) -> + c 0 - n-72243) - (\(ds-72244 : + n) + (\(ds : integer) - (ds-72245 : - List-71608 + (ds : + List integer) -> - Cons-71610 + Cons {integer} - ds-72244 - ds-72245) - (Nil-71609 + ds + ds) + (Nil {integer}))) - (c-72239 - (Tuple2-71614 - {PredKey-71635} - {List-71608 + (c + (Tuple2 + {PredKey} + {List integer} - MaxValue-71636 + MaxValue ((let - a-72246 - = List-71608 + a + = List integer in - \(c-72247 : + \(c : integer -> - a-72246 -> - a-72246) - (n-72248 : - a-72246) -> - c-72247 + a -> + a) + (n : + a) -> + c 40000000000 - n-72248) - (\(ds-72249 : + n) + (\(ds : integer) - (ds-72250 : - List-71608 + (ds : + List integer) -> - Cons-71610 + Cons {integer} - ds-72249 - ds-72250) - (Nil-71609 + ds + ds) + (Nil {integer}))) - n-72240)))) - n-72214)) - (\(ds-72251 : - ParamValue-71653) - (ds-72252 : - List-71608 - ParamValue-71653) -> - Cons-71610 - {ParamValue-71653} - ds-72251 - ds-72252) - (Nil-71609 - {ParamValue-71653})))) - (c-71871 - (Tuple2-71614 + n)))) + n)) + (\(ds : + ParamValue) + (ds : + List + ParamValue) -> + Cons + {ParamValue} + ds + ds) + (Nil + {ParamValue})))) + (c + (Tuple2 {integer} - {ParamValue-71653} + {ParamValue} 22 - (ParamInteger-71655 + (ParamInteger ((let - a-72253 - = Tuple2-71613 - PredKey-71635 - (List-71608 + a + = Tuple2 + PredKey + (List integer) in - \(g-72254 : - all b-72255. - (a-72253 -> - b-72255 -> - b-72255) -> - b-72255 -> - b-72255) -> - g-72254 - {List-71608 - a-72253} - (\(ds-72256 : - a-72253) - (ds-72257 : - List-71608 - a-72253) -> - Cons-71610 - {a-72253} - ds-72256 - ds-72257) - (Nil-71609 - {a-72253})) - (/\a-72258 -> - \(c-72259 : - Tuple2-71613 - PredKey-71635 - (List-71608 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List integer) -> - a-72258 -> - a-72258) - (n-72260 : - a-72258) -> - c-72259 - (Tuple2-71614 - {PredKey-71635} - {List-71608 + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List integer} - MinValue-71637 + MinValue ((let - a-72261 - = List-71608 + a + = List integer in - \(c-72262 : + \(c : integer -> - a-72261 -> - a-72261) - (n-72263 : - a-72261) -> - c-72262 + a -> + a) + (n : + a) -> + c 0 - n-72263) - (\(ds-72264 : + n) + (\(ds : integer) - (ds-72265 : - List-71608 + (ds : + List integer) -> - Cons-71610 + Cons {integer} - ds-72264 - ds-72265) - (Nil-71609 + ds + ds) + (Nil {integer}))) - (c-72259 - (Tuple2-71614 - {PredKey-71635} - {List-71608 + (c + (Tuple2 + {PredKey} + {List integer} - MaxValue-71636 + MaxValue ((let - a-72266 - = List-71608 + a + = List integer in - \(c-72267 : + \(c : integer -> - a-72266 -> - a-72266) - (n-72268 : - a-72266) -> - c-72267 + a -> + a) + (n : + a) -> + c 12288 - n-72268) - (\(ds-72269 : + n) + (\(ds : integer) - (ds-72270 : - List-71608 + (ds : + List integer) -> - Cons-71610 + Cons {integer} - ds-72269 - ds-72270) - (Nil-71609 + ds + ds) + (Nil {integer}))) - n-72260))))) - (c-71871 - (Tuple2-71614 + n))))) + (c + (Tuple2 {integer} - {ParamValue-71653} + {ParamValue} 23 - (ParamInteger-71655 + (ParamInteger ((let - a-72271 - = Tuple2-71613 - PredKey-71635 - (List-71608 + a + = Tuple2 + PredKey + (List integer) in - \(g-72272 : - all b-72273. - (a-72271 -> - b-72273 -> - b-72273) -> - b-72273 -> - b-72273) -> - g-72272 - {List-71608 - a-72271} - (\(ds-72274 : - a-72271) - (ds-72275 : - List-71608 - a-72271) -> - Cons-71610 - {a-72271} - ds-72274 - ds-72275) - (Nil-71609 - {a-72271})) - (/\a-72276 -> - \(c-72277 : - Tuple2-71613 - PredKey-71635 - (List-71608 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List integer) -> - a-72276 -> - a-72276) - (n-72278 : - a-72276) -> - c-72277 - (Tuple2-71614 - {PredKey-71635} - {List-71608 + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List integer} - MinValue-71637 + MinValue ((let - a-72279 - = List-71608 + a + = List integer in - \(c-72280 : + \(c : integer -> - a-72279 -> - a-72279) - (n-72281 : - a-72279) -> - c-72280 + a -> + a) + (n : + a) -> + c 100 - (c-72280 + (c 0 - n-72281)) - (\(ds-72282 : + n)) + (\(ds : integer) - (ds-72283 : - List-71608 + (ds : + List integer) -> - Cons-71610 + Cons {integer} - ds-72282 - ds-72283) - (Nil-71609 + ds + ds) + (Nil {integer}))) - (c-72277 - (Tuple2-71614 - {PredKey-71635} - {List-71608 + (c + (Tuple2 + {PredKey} + {List integer} - MaxValue-71636 + MaxValue ((let - a-72284 - = List-71608 + a + = List integer in - \(c-72285 : + \(c : integer -> - a-72284 -> - a-72284) - (n-72286 : - a-72284) -> - c-72285 + a -> + a) + (n : + a) -> + c 200 - n-72286) - (\(ds-72287 : + n) + (\(ds : integer) - (ds-72288 : - List-71608 + (ds : + List integer) -> - Cons-71610 + Cons {integer} - ds-72287 - ds-72288) - (Nil-71609 + ds + ds) + (Nil {integer}))) - (c-72277 - (Tuple2-71614 - {PredKey-71635} - {List-71608 + (c + (Tuple2 + {PredKey} + {List integer} - NotEqual-71638 + NotEqual ((let - a-72289 - = List-71608 + a + = List integer in - \(c-72290 : + \(c : integer -> - a-72289 -> - a-72289) - (n-72291 : - a-72289) -> - c-72290 + a -> + a) + (n : + a) -> + c 0 - n-72291) - (\(ds-72292 : + n) + (\(ds : integer) - (ds-72293 : - List-71608 + (ds : + List integer) -> - Cons-71610 + Cons {integer} - ds-72292 - ds-72293) - (Nil-71609 + ds + ds) + (Nil {integer}))) - n-72278)))))) - (c-71871 - (Tuple2-71614 + n)))))) + (c + (Tuple2 {integer} - {ParamValue-71653} + {ParamValue} 24 - (ParamInteger-71655 + (ParamInteger ((let - a-72294 - = Tuple2-71613 - PredKey-71635 - (List-71608 + a + = Tuple2 + PredKey + (List integer) in - \(g-72295 : - all b-72296. - (a-72294 -> - b-72296 -> - b-72296) -> - b-72296 -> - b-72296) -> - g-72295 - {List-71608 - a-72294} - (\(ds-72297 : - a-72294) - (ds-72298 : - List-71608 - a-72294) -> - Cons-71610 - {a-72294} - ds-72297 - ds-72298) - (Nil-71609 - {a-72294})) - (/\a-72299 -> - \(c-72300 : - Tuple2-71613 - PredKey-71635 - (List-71608 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List integer) -> - a-72299 -> - a-72299) - (n-72301 : - a-72299) -> - c-72300 - (Tuple2-71614 - {PredKey-71635} - {List-71608 + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List integer} - MinValue-71637 + MinValue ((let - a-72302 - = List-71608 + a + = List integer in - \(c-72303 : + \(c : integer -> - a-72302 -> - a-72302) - (n-72304 : - a-72302) -> - c-72303 + a -> + a) + (n : + a) -> + c 1 - n-72304) - (\(ds-72305 : + n) + (\(ds : integer) - (ds-72306 : - List-71608 + (ds : + List integer) -> - Cons-71610 + Cons {integer} - ds-72305 - ds-72306) - (Nil-71609 + ds + ds) + (Nil {integer}))) - n-72301)))) - (c-71871 - (Tuple2-71614 + n)))) + (c + (Tuple2 {integer} - {ParamValue-71653} + {ParamValue} 25 - (ParamList-71656 + (ParamList ((let - a-72307 - = List-71608 - ParamValue-71653 + a + = List + ParamValue in - \(c-72308 : - ParamValue-71653 -> - a-72307 -> - a-72307) - (n-72309 : - a-72307) -> - c-72308 - (ParamRational-71657 + \(c : + ParamValue -> + a -> + a) + (n : + a) -> + c + (ParamRational ((let - a-72310 - = Tuple2-71613 - PredKey-71635 - (List-71608 - Rational-71650) + a + = Tuple2 + PredKey + (List + Rational) in - \(g-72311 : - all b-72312. - (a-72310 -> - b-72312 -> - b-72312) -> - b-72312 -> - b-72312) -> - g-72311 - {List-71608 - a-72310} - (\(ds-72313 : - a-72310) - (ds-72314 : - List-71608 - a-72310) -> - Cons-71610 - {a-72310} - ds-72313 - ds-72314) - (Nil-71609 - {a-72310})) - (/\a-72315 -> - \(c-72316 : - Tuple2-71613 - PredKey-71635 - (List-71608 - Rational-71650) -> - a-72315 -> - a-72315) - (n-72317 : - a-72315) -> - c-72316 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - Rational-71650} - MinValue-71637 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List + Rational) -> + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List + Rational} + MinValue ((let - a-72318 - = List-71608 - Rational-71650 + a + = List + Rational in - \(c-72319 : - Rational-71650 -> - a-72318 -> - a-72318) - (n-72320 : - a-72318) -> - c-72319 - (unsafeRatio-71668 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 2) - (c-72319 - (unsafeRatio-71668 + (c + (unsafeRatio 51 100) - n-72320)) - (\(ds-72321 : - Rational-71650) - (ds-72322 : - List-71608 - Rational-71650) -> - Cons-71610 - {Rational-71650} - ds-72321 - ds-72322) - (Nil-71609 - {Rational-71650}))) - (c-72316 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - Rational-71650} - MaxValue-71636 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + (c + (Tuple2 + {PredKey} + {List + Rational} + MaxValue ((let - a-72323 - = List-71608 - Rational-71650 + a + = List + Rational in - \(c-72324 : - Rational-71650 -> - a-72323 -> - a-72323) - (n-72325 : - a-72323) -> - c-72324 - (unsafeRatio-71668 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 1) - (c-72324 - (unsafeRatio-71668 + (c + (unsafeRatio 3 4) - n-72325)) - (\(ds-72326 : - Rational-71650) - (ds-72327 : - List-71608 - Rational-71650) -> - Cons-71610 - {Rational-71650} - ds-72326 - ds-72327) - (Nil-71609 - {Rational-71650}))) - n-72317)))) - (c-72308 - (ParamRational-71657 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + n)))) + (c + (ParamRational ((let - a-72328 - = Tuple2-71613 - PredKey-71635 - (List-71608 - Rational-71650) + a + = Tuple2 + PredKey + (List + Rational) in - \(g-72329 : - all b-72330. - (a-72328 -> - b-72330 -> - b-72330) -> - b-72330 -> - b-72330) -> - g-72329 - {List-71608 - a-72328} - (\(ds-72331 : - a-72328) - (ds-72332 : - List-71608 - a-72328) -> - Cons-71610 - {a-72328} - ds-72331 - ds-72332) - (Nil-71609 - {a-72328})) - (/\a-72333 -> - \(c-72334 : - Tuple2-71613 - PredKey-71635 - (List-71608 - Rational-71650) -> - a-72333 -> - a-72333) - (n-72335 : - a-72333) -> - c-72334 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - Rational-71650} - MinValue-71637 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List + Rational) -> + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List + Rational} + MinValue ((let - a-72336 - = List-71608 - Rational-71650 + a + = List + Rational in - \(c-72337 : - Rational-71650 -> - a-72336 -> - a-72336) - (n-72338 : - a-72336) -> - c-72337 - (unsafeRatio-71668 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 2) - (c-72337 - (unsafeRatio-71668 + (c + (unsafeRatio 51 100) - n-72338)) - (\(ds-72339 : - Rational-71650) - (ds-72340 : - List-71608 - Rational-71650) -> - Cons-71610 - {Rational-71650} - ds-72339 - ds-72340) - (Nil-71609 - {Rational-71650}))) - (c-72334 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - Rational-71650} - MaxValue-71636 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + (c + (Tuple2 + {PredKey} + {List + Rational} + MaxValue ((let - a-72341 - = List-71608 - Rational-71650 + a + = List + Rational in - \(c-72342 : - Rational-71650 -> - a-72341 -> - a-72341) - (n-72343 : - a-72341) -> - c-72342 - (unsafeRatio-71668 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 1) - (c-72342 - (unsafeRatio-71668 + (c + (unsafeRatio 9 10) - n-72343)) - (\(ds-72344 : - Rational-71650) - (ds-72345 : - List-71608 - Rational-71650) -> - Cons-71610 - {Rational-71650} - ds-72344 - ds-72345) - (Nil-71609 - {Rational-71650}))) - n-72335)))) - (c-72308 - (ParamRational-71657 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + n)))) + (c + (ParamRational ((let - a-72346 - = Tuple2-71613 - PredKey-71635 - (List-71608 - Rational-71650) + a + = Tuple2 + PredKey + (List + Rational) in - \(g-72347 : - all b-72348. - (a-72346 -> - b-72348 -> - b-72348) -> - b-72348 -> - b-72348) -> - g-72347 - {List-71608 - a-72346} - (\(ds-72349 : - a-72346) - (ds-72350 : - List-71608 - a-72346) -> - Cons-71610 - {a-72346} - ds-72349 - ds-72350) - (Nil-71609 - {a-72346})) - (/\a-72351 -> - \(c-72352 : - Tuple2-71613 - PredKey-71635 - (List-71608 - Rational-71650) -> - a-72351 -> - a-72351) - (n-72353 : - a-72351) -> - c-72352 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - Rational-71650} - MinValue-71637 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List + Rational) -> + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List + Rational} + MinValue ((let - a-72354 - = List-71608 - Rational-71650 + a + = List + Rational in - \(c-72355 : - Rational-71650 -> - a-72354 -> - a-72354) - (n-72356 : - a-72354) -> - c-72355 - (unsafeRatio-71668 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 2) - (c-72355 - (unsafeRatio-71668 + (c + (unsafeRatio 51 100) - n-72356)) - (\(ds-72357 : - Rational-71650) - (ds-72358 : - List-71608 - Rational-71650) -> - Cons-71610 - {Rational-71650} - ds-72357 - ds-72358) - (Nil-71609 - {Rational-71650}))) - (c-72352 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - Rational-71650} - MaxValue-71636 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + (c + (Tuple2 + {PredKey} + {List + Rational} + MaxValue ((let - a-72359 - = List-71608 - Rational-71650 + a + = List + Rational in - \(c-72360 : - Rational-71650 -> - a-72359 -> - a-72359) - (n-72361 : - a-72359) -> - c-72360 - (unsafeRatio-71668 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 1) - (c-72360 - (unsafeRatio-71668 + (c + (unsafeRatio 9 10) - n-72361)) - (\(ds-72362 : - Rational-71650) - (ds-72363 : - List-71608 - Rational-71650) -> - Cons-71610 - {Rational-71650} - ds-72362 - ds-72363) - (Nil-71609 - {Rational-71650}))) - n-72353)))) - (c-72308 - (ParamRational-71657 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + n)))) + (c + (ParamRational ((let - a-72364 - = Tuple2-71613 - PredKey-71635 - (List-71608 - Rational-71650) + a + = Tuple2 + PredKey + (List + Rational) in - \(g-72365 : - all b-72366. - (a-72364 -> - b-72366 -> - b-72366) -> - b-72366 -> - b-72366) -> - g-72365 - {List-71608 - a-72364} - (\(ds-72367 : - a-72364) - (ds-72368 : - List-71608 - a-72364) -> - Cons-71610 - {a-72364} - ds-72367 - ds-72368) - (Nil-71609 - {a-72364})) - (/\a-72369 -> - \(c-72370 : - Tuple2-71613 - PredKey-71635 - (List-71608 - Rational-71650) -> - a-72369 -> - a-72369) - (n-72371 : - a-72369) -> - c-72370 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - Rational-71650} - MinValue-71637 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List + Rational) -> + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List + Rational} + MinValue ((let - a-72372 - = List-71608 - Rational-71650 + a + = List + Rational in - \(c-72373 : - Rational-71650 -> - a-72372 -> - a-72372) - (n-72374 : - a-72372) -> - c-72373 - (unsafeRatio-71668 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 2) - (c-72373 - (unsafeRatio-71668 + (c + (unsafeRatio 51 100) - n-72374)) - (\(ds-72375 : - Rational-71650) - (ds-72376 : - List-71608 - Rational-71650) -> - Cons-71610 - {Rational-71650} - ds-72375 - ds-72376) - (Nil-71609 - {Rational-71650}))) - (c-72370 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - Rational-71650} - MaxValue-71636 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + (c + (Tuple2 + {PredKey} + {List + Rational} + MaxValue ((let - a-72377 - = List-71608 - Rational-71650 + a + = List + Rational in - \(c-72378 : - Rational-71650 -> - a-72377 -> - a-72377) - (n-72379 : - a-72377) -> - c-72378 - (unsafeRatio-71668 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 1) - (c-72378 - (unsafeRatio-71668 + (c + (unsafeRatio 4 5) - n-72379)) - (\(ds-72380 : - Rational-71650) - (ds-72381 : - List-71608 - Rational-71650) -> - Cons-71610 - {Rational-71650} - ds-72380 - ds-72381) - (Nil-71609 - {Rational-71650}))) - n-72371)))) - (c-72308 - (ParamRational-71657 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + n)))) + (c + (ParamRational ((let - a-72382 - = Tuple2-71613 - PredKey-71635 - (List-71608 - Rational-71650) + a + = Tuple2 + PredKey + (List + Rational) in - \(g-72383 : - all b-72384. - (a-72382 -> - b-72384 -> - b-72384) -> - b-72384 -> - b-72384) -> - g-72383 - {List-71608 - a-72382} - (\(ds-72385 : - a-72382) - (ds-72386 : - List-71608 - a-72382) -> - Cons-71610 - {a-72382} - ds-72385 - ds-72386) - (Nil-71609 - {a-72382})) - (/\a-72387 -> - \(c-72388 : - Tuple2-71613 - PredKey-71635 - (List-71608 - Rational-71650) -> - a-72387 -> - a-72387) - (n-72389 : - a-72387) -> - c-72388 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - Rational-71650} - MinValue-71637 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List + Rational) -> + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List + Rational} + MinValue ((let - a-72390 - = List-71608 - Rational-71650 + a + = List + Rational in - \(c-72391 : - Rational-71650 -> - a-72390 -> - a-72390) - (n-72392 : - a-72390) -> - c-72391 - (unsafeRatio-71668 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 2) - n-72392) - (\(ds-72393 : - Rational-71650) - (ds-72394 : - List-71608 - Rational-71650) -> - Cons-71610 - {Rational-71650} - ds-72393 - ds-72394) - (Nil-71609 - {Rational-71650}))) - (c-72388 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - Rational-71650} - MaxValue-71636 + n) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + (c + (Tuple2 + {PredKey} + {List + Rational} + MaxValue ((let - a-72395 - = List-71608 - Rational-71650 + a + = List + Rational in - \(c-72396 : - Rational-71650 -> - a-72395 -> - a-72395) - (n-72397 : - a-72395) -> - c-72396 - (unsafeRatio-71668 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 1) - n-72397) - (\(ds-72398 : - Rational-71650) - (ds-72399 : - List-71608 - Rational-71650) -> - Cons-71610 - {Rational-71650} - ds-72398 - ds-72399) - (Nil-71609 - {Rational-71650}))) - n-72389)))) - n-72309))))) - (\(ds-72400 : - ParamValue-71653) - (ds-72401 : - List-71608 - ParamValue-71653) -> - Cons-71610 - {ParamValue-71653} - ds-72400 - ds-72401) - (Nil-71609 - {ParamValue-71653})))) - (c-71871 - (Tuple2-71614 + n) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + n)))) + n))))) + (\(ds : + ParamValue) + (ds : + List + ParamValue) -> + Cons + {ParamValue} + ds + ds) + (Nil + {ParamValue})))) + (c + (Tuple2 {integer} - {ParamValue-71653} + {ParamValue} 26 - (ParamList-71656 + (ParamList ((let - a-72402 - = List-71608 - ParamValue-71653 + a + = List + ParamValue in - \(c-72403 : - ParamValue-71653 -> - a-72402 -> - a-72402) - (n-72404 : - a-72402) -> - c-72403 - (ParamRational-71657 + \(c : + ParamValue -> + a -> + a) + (n : + a) -> + c + (ParamRational ((let - a-72405 - = Tuple2-71613 - PredKey-71635 - (List-71608 - Rational-71650) + a + = Tuple2 + PredKey + (List + Rational) in - \(g-72406 : - all b-72407. - (a-72405 -> - b-72407 -> - b-72407) -> - b-72407 -> - b-72407) -> - g-72406 - {List-71608 - a-72405} - (\(ds-72408 : - a-72405) - (ds-72409 : - List-71608 - a-72405) -> - Cons-71610 - {a-72405} - ds-72408 - ds-72409) - (Nil-71609 - {a-72405})) - (/\a-72410 -> - \(c-72411 : - Tuple2-71613 - PredKey-71635 - (List-71608 - Rational-71650) -> - a-72410 -> - a-72410) - (n-72412 : - a-72410) -> - c-72411 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - Rational-71650} - MinValue-71637 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List + Rational) -> + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List + Rational} + MinValue ((let - a-72413 - = List-71608 - Rational-71650 + a + = List + Rational in - \(c-72414 : - Rational-71650 -> - a-72413 -> - a-72413) - (n-72415 : - a-72413) -> - c-72414 - (unsafeRatio-71668 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 2) - (c-72414 - (unsafeRatio-71668 + (c + (unsafeRatio 51 100) - n-72415)) - (\(ds-72416 : - Rational-71650) - (ds-72417 : - List-71608 - Rational-71650) -> - Cons-71610 - {Rational-71650} - ds-72416 - ds-72417) - (Nil-71609 - {Rational-71650}))) - (c-72411 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - Rational-71650} - MaxValue-71636 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + (c + (Tuple2 + {PredKey} + {List + Rational} + MaxValue ((let - a-72418 - = List-71608 - Rational-71650 + a + = List + Rational in - \(c-72419 : - Rational-71650 -> - a-72418 -> - a-72418) - (n-72420 : - a-72418) -> - c-72419 - (unsafeRatio-71668 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 1) - (c-72419 - (unsafeRatio-71668 + (c + (unsafeRatio 3 4) - n-72420)) - (\(ds-72421 : - Rational-71650) - (ds-72422 : - List-71608 - Rational-71650) -> - Cons-71610 - {Rational-71650} - ds-72421 - ds-72422) - (Nil-71609 - {Rational-71650}))) - n-72412)))) - (c-72403 - (ParamRational-71657 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + n)))) + (c + (ParamRational ((let - a-72423 - = Tuple2-71613 - PredKey-71635 - (List-71608 - Rational-71650) + a + = Tuple2 + PredKey + (List + Rational) in - \(g-72424 : - all b-72425. - (a-72423 -> - b-72425 -> - b-72425) -> - b-72425 -> - b-72425) -> - g-72424 - {List-71608 - a-72423} - (\(ds-72426 : - a-72423) - (ds-72427 : - List-71608 - a-72423) -> - Cons-71610 - {a-72423} - ds-72426 - ds-72427) - (Nil-71609 - {a-72423})) - (/\a-72428 -> - \(c-72429 : - Tuple2-71613 - PredKey-71635 - (List-71608 - Rational-71650) -> - a-72428 -> - a-72428) - (n-72430 : - a-72428) -> - c-72429 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - Rational-71650} - MinValue-71637 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List + Rational) -> + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List + Rational} + MinValue ((let - a-72431 - = List-71608 - Rational-71650 + a + = List + Rational in - \(c-72432 : - Rational-71650 -> - a-72431 -> - a-72431) - (n-72433 : - a-72431) -> - c-72432 - (unsafeRatio-71668 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 2) - (c-72432 - (unsafeRatio-71668 + (c + (unsafeRatio 51 100) - n-72433)) - (\(ds-72434 : - Rational-71650) - (ds-72435 : - List-71608 - Rational-71650) -> - Cons-71610 - {Rational-71650} - ds-72434 - ds-72435) - (Nil-71609 - {Rational-71650}))) - (c-72429 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - Rational-71650} - MaxValue-71636 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + (c + (Tuple2 + {PredKey} + {List + Rational} + MaxValue ((let - a-72436 - = List-71608 - Rational-71650 + a + = List + Rational in - \(c-72437 : - Rational-71650 -> - a-72436 -> - a-72436) - (n-72438 : - a-72436) -> - c-72437 - (unsafeRatio-71668 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 1) - (c-72437 - (unsafeRatio-71668 + (c + (unsafeRatio 9 10) - n-72438)) - (\(ds-72439 : - Rational-71650) - (ds-72440 : - List-71608 - Rational-71650) -> - Cons-71610 - {Rational-71650} - ds-72439 - ds-72440) - (Nil-71609 - {Rational-71650}))) - n-72430)))) - (c-72403 - (ParamRational-71657 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + n)))) + (c + (ParamRational ((let - a-72441 - = Tuple2-71613 - PredKey-71635 - (List-71608 - Rational-71650) + a + = Tuple2 + PredKey + (List + Rational) in - \(g-72442 : - all b-72443. - (a-72441 -> - b-72443 -> - b-72443) -> - b-72443 -> - b-72443) -> - g-72442 - {List-71608 - a-72441} - (\(ds-72444 : - a-72441) - (ds-72445 : - List-71608 - a-72441) -> - Cons-71610 - {a-72441} - ds-72444 - ds-72445) - (Nil-71609 - {a-72441})) - (/\a-72446 -> - \(c-72447 : - Tuple2-71613 - PredKey-71635 - (List-71608 - Rational-71650) -> - a-72446 -> - a-72446) - (n-72448 : - a-72446) -> - c-72447 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - Rational-71650} - MinValue-71637 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List + Rational) -> + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List + Rational} + MinValue ((let - a-72449 - = List-71608 - Rational-71650 + a + = List + Rational in - \(c-72450 : - Rational-71650 -> - a-72449 -> - a-72449) - (n-72451 : - a-72449) -> - c-72450 - (unsafeRatio-71668 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 2) - (c-72450 - (unsafeRatio-71668 + (c + (unsafeRatio 51 100) - n-72451)) - (\(ds-72452 : - Rational-71650) - (ds-72453 : - List-71608 - Rational-71650) -> - Cons-71610 - {Rational-71650} - ds-72452 - ds-72453) - (Nil-71609 - {Rational-71650}))) - (c-72447 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - Rational-71650} - MaxValue-71636 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + (c + (Tuple2 + {PredKey} + {List + Rational} + MaxValue ((let - a-72454 - = List-71608 - Rational-71650 + a + = List + Rational in - \(c-72455 : - Rational-71650 -> - a-72454 -> - a-72454) - (n-72456 : - a-72454) -> - c-72455 - (unsafeRatio-71668 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 1) - (c-72455 - (unsafeRatio-71668 + (c + (unsafeRatio 9 10) - n-72456)) - (\(ds-72457 : - Rational-71650) - (ds-72458 : - List-71608 - Rational-71650) -> - Cons-71610 - {Rational-71650} - ds-72457 - ds-72458) - (Nil-71609 - {Rational-71650}))) - n-72448)))) - (c-72403 - (ParamRational-71657 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + n)))) + (c + (ParamRational ((let - a-72459 - = Tuple2-71613 - PredKey-71635 - (List-71608 - Rational-71650) + a + = Tuple2 + PredKey + (List + Rational) in - \(g-72460 : - all b-72461. - (a-72459 -> - b-72461 -> - b-72461) -> - b-72461 -> - b-72461) -> - g-72460 - {List-71608 - a-72459} - (\(ds-72462 : - a-72459) - (ds-72463 : - List-71608 - a-72459) -> - Cons-71610 - {a-72459} - ds-72462 - ds-72463) - (Nil-71609 - {a-72459})) - (/\a-72464 -> - \(c-72465 : - Tuple2-71613 - PredKey-71635 - (List-71608 - Rational-71650) -> - a-72464 -> - a-72464) - (n-72466 : - a-72464) -> - c-72465 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - Rational-71650} - MinValue-71637 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List + Rational) -> + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List + Rational} + MinValue ((let - a-72467 - = List-71608 - Rational-71650 + a + = List + Rational in - \(c-72468 : - Rational-71650 -> - a-72467 -> - a-72467) - (n-72469 : - a-72467) -> - c-72468 - (unsafeRatio-71668 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 2) - (c-72468 - (unsafeRatio-71668 + (c + (unsafeRatio 13 20) - n-72469)) - (\(ds-72470 : - Rational-71650) - (ds-72471 : - List-71608 - Rational-71650) -> - Cons-71610 - {Rational-71650} - ds-72470 - ds-72471) - (Nil-71609 - {Rational-71650}))) - (c-72465 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - Rational-71650} - MaxValue-71636 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + (c + (Tuple2 + {PredKey} + {List + Rational} + MaxValue ((let - a-72472 - = List-71608 - Rational-71650 + a + = List + Rational in - \(c-72473 : - Rational-71650 -> - a-72472 -> - a-72472) - (n-72474 : - a-72472) -> - c-72473 - (unsafeRatio-71668 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 1) - (c-72473 - (unsafeRatio-71668 + (c + (unsafeRatio 9 10) - n-72474)) - (\(ds-72475 : - Rational-71650) - (ds-72476 : - List-71608 - Rational-71650) -> - Cons-71610 - {Rational-71650} - ds-72475 - ds-72476) - (Nil-71609 - {Rational-71650}))) - n-72466)))) - (c-72403 - (ParamRational-71657 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + n)))) + (c + (ParamRational ((let - a-72477 - = Tuple2-71613 - PredKey-71635 - (List-71608 - Rational-71650) + a + = Tuple2 + PredKey + (List + Rational) in - \(g-72478 : - all b-72479. - (a-72477 -> - b-72479 -> - b-72479) -> - b-72479 -> - b-72479) -> - g-72478 - {List-71608 - a-72477} - (\(ds-72480 : - a-72477) - (ds-72481 : - List-71608 - a-72477) -> - Cons-71610 - {a-72477} - ds-72480 - ds-72481) - (Nil-71609 - {a-72477})) - (/\a-72482 -> - \(c-72483 : - Tuple2-71613 - PredKey-71635 - (List-71608 - Rational-71650) -> - a-72482 -> - a-72482) - (n-72484 : - a-72482) -> - c-72483 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - Rational-71650} - MinValue-71637 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List + Rational) -> + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List + Rational} + MinValue ((let - a-72485 - = List-71608 - Rational-71650 + a + = List + Rational in - \(c-72486 : - Rational-71650 -> - a-72485 -> - a-72485) - (n-72487 : - a-72485) -> - c-72486 - (unsafeRatio-71668 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 2) - (c-72486 - (unsafeRatio-71668 + (c + (unsafeRatio 51 100) - n-72487)) - (\(ds-72488 : - Rational-71650) - (ds-72489 : - List-71608 - Rational-71650) -> - Cons-71610 - {Rational-71650} - ds-72488 - ds-72489) - (Nil-71609 - {Rational-71650}))) - (c-72483 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - Rational-71650} - MaxValue-71636 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + (c + (Tuple2 + {PredKey} + {List + Rational} + MaxValue ((let - a-72490 - = List-71608 - Rational-71650 + a + = List + Rational in - \(c-72491 : - Rational-71650 -> - a-72490 -> - a-72490) - (n-72492 : - a-72490) -> - c-72491 - (unsafeRatio-71668 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 1) - (c-72491 - (unsafeRatio-71668 + (c + (unsafeRatio 4 5) - n-72492)) - (\(ds-72493 : - Rational-71650) - (ds-72494 : - List-71608 - Rational-71650) -> - Cons-71610 - {Rational-71650} - ds-72493 - ds-72494) - (Nil-71609 - {Rational-71650}))) - n-72484)))) - (c-72403 - (ParamRational-71657 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + n)))) + (c + (ParamRational ((let - a-72495 - = Tuple2-71613 - PredKey-71635 - (List-71608 - Rational-71650) + a + = Tuple2 + PredKey + (List + Rational) in - \(g-72496 : - all b-72497. - (a-72495 -> - b-72497 -> - b-72497) -> - b-72497 -> - b-72497) -> - g-72496 - {List-71608 - a-72495} - (\(ds-72498 : - a-72495) - (ds-72499 : - List-71608 - a-72495) -> - Cons-71610 - {a-72495} - ds-72498 - ds-72499) - (Nil-71609 - {a-72495})) - (/\a-72500 -> - \(c-72501 : - Tuple2-71613 - PredKey-71635 - (List-71608 - Rational-71650) -> - a-72500 -> - a-72500) - (n-72502 : - a-72500) -> - c-72501 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - Rational-71650} - MinValue-71637 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List + Rational) -> + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List + Rational} + MinValue ((let - a-72503 - = List-71608 - Rational-71650 + a + = List + Rational in - \(c-72504 : - Rational-71650 -> - a-72503 -> - a-72503) - (n-72505 : - a-72503) -> - c-72504 - (unsafeRatio-71668 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 2) - (c-72504 - (unsafeRatio-71668 + (c + (unsafeRatio 51 100) - n-72505)) - (\(ds-72506 : - Rational-71650) - (ds-72507 : - List-71608 - Rational-71650) -> - Cons-71610 - {Rational-71650} - ds-72506 - ds-72507) - (Nil-71609 - {Rational-71650}))) - (c-72501 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - Rational-71650} - MaxValue-71636 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + (c + (Tuple2 + {PredKey} + {List + Rational} + MaxValue ((let - a-72508 - = List-71608 - Rational-71650 + a + = List + Rational in - \(c-72509 : - Rational-71650 -> - a-72508 -> - a-72508) - (n-72510 : - a-72508) -> - c-72509 - (unsafeRatio-71668 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 1) - (c-72509 - (unsafeRatio-71668 + (c + (unsafeRatio 3 4) - n-72510)) - (\(ds-72511 : - Rational-71650) - (ds-72512 : - List-71608 - Rational-71650) -> - Cons-71610 - {Rational-71650} - ds-72511 - ds-72512) - (Nil-71609 - {Rational-71650}))) - n-72502)))) - (c-72403 - (ParamRational-71657 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + n)))) + (c + (ParamRational ((let - a-72513 - = Tuple2-71613 - PredKey-71635 - (List-71608 - Rational-71650) + a + = Tuple2 + PredKey + (List + Rational) in - \(g-72514 : - all b-72515. - (a-72513 -> - b-72515 -> - b-72515) -> - b-72515 -> - b-72515) -> - g-72514 - {List-71608 - a-72513} - (\(ds-72516 : - a-72513) - (ds-72517 : - List-71608 - a-72513) -> - Cons-71610 - {a-72513} - ds-72516 - ds-72517) - (Nil-71609 - {a-72513})) - (/\a-72518 -> - \(c-72519 : - Tuple2-71613 - PredKey-71635 - (List-71608 - Rational-71650) -> - a-72518 -> - a-72518) - (n-72520 : - a-72518) -> - c-72519 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - Rational-71650} - MinValue-71637 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List + Rational) -> + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List + Rational} + MinValue ((let - a-72521 - = List-71608 - Rational-71650 + a + = List + Rational in - \(c-72522 : - Rational-71650 -> - a-72521 -> - a-72521) - (n-72523 : - a-72521) -> - c-72522 - (unsafeRatio-71668 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 2) - (c-72522 - (unsafeRatio-71668 + (c + (unsafeRatio 51 100) - n-72523)) - (\(ds-72524 : - Rational-71650) - (ds-72525 : - List-71608 - Rational-71650) -> - Cons-71610 - {Rational-71650} - ds-72524 - ds-72525) - (Nil-71609 - {Rational-71650}))) - (c-72519 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - Rational-71650} - MaxValue-71636 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + (c + (Tuple2 + {PredKey} + {List + Rational} + MaxValue ((let - a-72526 - = List-71608 - Rational-71650 + a + = List + Rational in - \(c-72527 : - Rational-71650 -> - a-72526 -> - a-72526) - (n-72528 : - a-72526) -> - c-72527 - (unsafeRatio-71668 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 1) - (c-72527 - (unsafeRatio-71668 + (c + (unsafeRatio 3 4) - n-72528)) - (\(ds-72529 : - Rational-71650) - (ds-72530 : - List-71608 - Rational-71650) -> - Cons-71610 - {Rational-71650} - ds-72529 - ds-72530) - (Nil-71609 - {Rational-71650}))) - n-72520)))) - (c-72403 - (ParamRational-71657 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + n)))) + (c + (ParamRational ((let - a-72531 - = Tuple2-71613 - PredKey-71635 - (List-71608 - Rational-71650) + a + = Tuple2 + PredKey + (List + Rational) in - \(g-72532 : - all b-72533. - (a-72531 -> - b-72533 -> - b-72533) -> - b-72533 -> - b-72533) -> - g-72532 - {List-71608 - a-72531} - (\(ds-72534 : - a-72531) - (ds-72535 : - List-71608 - a-72531) -> - Cons-71610 - {a-72531} - ds-72534 - ds-72535) - (Nil-71609 - {a-72531})) - (/\a-72536 -> - \(c-72537 : - Tuple2-71613 - PredKey-71635 - (List-71608 - Rational-71650) -> - a-72536 -> - a-72536) - (n-72538 : - a-72536) -> - c-72537 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - Rational-71650} - MinValue-71637 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List + Rational) -> + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List + Rational} + MinValue ((let - a-72539 - = List-71608 - Rational-71650 + a + = List + Rational in - \(c-72540 : - Rational-71650 -> - a-72539 -> - a-72539) - (n-72541 : - a-72539) -> - c-72540 - (unsafeRatio-71668 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 2) - (c-72540 - (unsafeRatio-71668 + (c + (unsafeRatio 51 100) - n-72541)) - (\(ds-72542 : - Rational-71650) - (ds-72543 : - List-71608 - Rational-71650) -> - Cons-71610 - {Rational-71650} - ds-72542 - ds-72543) - (Nil-71609 - {Rational-71650}))) - (c-72537 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - Rational-71650} - MaxValue-71636 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + (c + (Tuple2 + {PredKey} + {List + Rational} + MaxValue ((let - a-72544 - = List-71608 - Rational-71650 + a + = List + Rational in - \(c-72545 : - Rational-71650 -> - a-72544 -> - a-72544) - (n-72546 : - a-72544) -> - c-72545 - (unsafeRatio-71668 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 1) - (c-72545 - (unsafeRatio-71668 + (c + (unsafeRatio 3 4) - n-72546)) - (\(ds-72547 : - Rational-71650) - (ds-72548 : - List-71608 - Rational-71650) -> - Cons-71610 - {Rational-71650} - ds-72547 - ds-72548) - (Nil-71609 - {Rational-71650}))) - n-72538)))) - (c-72403 - (ParamRational-71657 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + n)))) + (c + (ParamRational ((let - a-72549 - = Tuple2-71613 - PredKey-71635 - (List-71608 - Rational-71650) + a + = Tuple2 + PredKey + (List + Rational) in - \(g-72550 : - all b-72551. - (a-72549 -> - b-72551 -> - b-72551) -> - b-72551 -> - b-72551) -> - g-72550 - {List-71608 - a-72549} - (\(ds-72552 : - a-72549) - (ds-72553 : - List-71608 - a-72549) -> - Cons-71610 - {a-72549} - ds-72552 - ds-72553) - (Nil-71609 - {a-72549})) - (/\a-72554 -> - \(c-72555 : - Tuple2-71613 - PredKey-71635 - (List-71608 - Rational-71650) -> - a-72554 -> - a-72554) - (n-72556 : - a-72554) -> - c-72555 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - Rational-71650} - MinValue-71637 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List + Rational) -> + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List + Rational} + MinValue ((let - a-72557 - = List-71608 - Rational-71650 + a + = List + Rational in - \(c-72558 : - Rational-71650 -> - a-72557 -> - a-72557) - (n-72559 : - a-72557) -> - c-72558 - (unsafeRatio-71668 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 2) - (c-72558 - (unsafeRatio-71668 + (c + (unsafeRatio 3 4) - n-72559)) - (\(ds-72560 : - Rational-71650) - (ds-72561 : - List-71608 - Rational-71650) -> - Cons-71610 - {Rational-71650} - ds-72560 - ds-72561) - (Nil-71609 - {Rational-71650}))) - (c-72555 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - Rational-71650} - MaxValue-71636 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + (c + (Tuple2 + {PredKey} + {List + Rational} + MaxValue ((let - a-72562 - = List-71608 - Rational-71650 + a + = List + Rational in - \(c-72563 : - Rational-71650 -> - a-72562 -> - a-72562) - (n-72564 : - a-72562) -> - c-72563 - (unsafeRatio-71668 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 1) - (c-72563 - (unsafeRatio-71668 + (c + (unsafeRatio 9 10) - n-72564)) - (\(ds-72565 : - Rational-71650) - (ds-72566 : - List-71608 - Rational-71650) -> - Cons-71610 - {Rational-71650} - ds-72565 - ds-72566) - (Nil-71609 - {Rational-71650}))) - n-72556)))) - (c-72403 - (ParamRational-71657 + n)) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + n)))) + (c + (ParamRational ((let - a-72567 - = Tuple2-71613 - PredKey-71635 - (List-71608 - Rational-71650) + a + = Tuple2 + PredKey + (List + Rational) in - \(g-72568 : - all b-72569. - (a-72567 -> - b-72569 -> - b-72569) -> - b-72569 -> - b-72569) -> - g-72568 - {List-71608 - a-72567} - (\(ds-72570 : - a-72567) - (ds-72571 : - List-71608 - a-72567) -> - Cons-71610 - {a-72567} - ds-72570 - ds-72571) - (Nil-71609 - {a-72567})) - (/\a-72572 -> - \(c-72573 : - Tuple2-71613 - PredKey-71635 - (List-71608 - Rational-71650) -> - a-72572 -> - a-72572) - (n-72574 : - a-72572) -> - c-72573 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - Rational-71650} - MinValue-71637 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List + Rational) -> + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List + Rational} + MinValue ((let - a-72575 - = List-71608 - Rational-71650 + a + = List + Rational in - \(c-72576 : - Rational-71650 -> - a-72575 -> - a-72575) - (n-72577 : - a-72575) -> - c-72576 - (unsafeRatio-71668 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 2) - n-72577) - (\(ds-72578 : - Rational-71650) - (ds-72579 : - List-71608 - Rational-71650) -> - Cons-71610 - {Rational-71650} - ds-72578 - ds-72579) - (Nil-71609 - {Rational-71650}))) - (c-72573 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - Rational-71650} - MaxValue-71636 + n) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + (c + (Tuple2 + {PredKey} + {List + Rational} + MaxValue ((let - a-72580 - = List-71608 - Rational-71650 + a + = List + Rational in - \(c-72581 : - Rational-71650 -> - a-72580 -> - a-72580) - (n-72582 : - a-72580) -> - c-72581 - (unsafeRatio-71668 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1 1) - n-72582) - (\(ds-72583 : - Rational-71650) - (ds-72584 : - List-71608 - Rational-71650) -> - Cons-71610 - {Rational-71650} - ds-72583 - ds-72584) - (Nil-71609 - {Rational-71650}))) - n-72574)))) - n-72404)))))))))) - (\(ds-72585 : - ParamValue-71653) - (ds-72586 : - List-71608 - ParamValue-71653) -> - Cons-71610 - {ParamValue-71653} - ds-72585 - ds-72586) - (Nil-71609 - {ParamValue-71653})))) - (c-71871 - (Tuple2-71614 + n) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + n)))) + n)))))))))) + (\(ds : + ParamValue) + (ds : + List + ParamValue) -> + Cons + {ParamValue} + ds + ds) + (Nil + {ParamValue})))) + (c + (Tuple2 {integer} - {ParamValue-71653} + {ParamValue} 27 - (ParamInteger-71655 + (ParamInteger ((let - a-72587 - = Tuple2-71613 - PredKey-71635 - (List-71608 + a + = Tuple2 + PredKey + (List integer) in - \(g-72588 : - all b-72589. - (a-72587 -> - b-72589 -> - b-72589) -> - b-72589 -> - b-72589) -> - g-72588 - {List-71608 - a-72587} - (\(ds-72590 : - a-72587) - (ds-72591 : - List-71608 - a-72587) -> - Cons-71610 - {a-72587} - ds-72590 - ds-72591) - (Nil-71609 - {a-72587})) - (/\a-72592 -> - \(c-72593 : - Tuple2-71613 - PredKey-71635 - (List-71608 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List integer) -> - a-72592 -> - a-72592) - (n-72594 : - a-72592) -> - c-72593 - (Tuple2-71614 - {PredKey-71635} - {List-71608 + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List integer} - MinValue-71637 + MinValue ((let - a-72595 - = List-71608 + a + = List integer in - \(c-72596 : + \(c : integer -> - a-72595 -> - a-72595) - (n-72597 : - a-72595) -> - c-72596 + a -> + a) + (n : + a) -> + c 0 - (c-72596 + (c 3 - n-72597)) - (\(ds-72598 : + n)) + (\(ds : integer) - (ds-72599 : - List-71608 + (ds : + List integer) -> - Cons-71610 + Cons {integer} - ds-72598 - ds-72599) - (Nil-71609 + ds + ds) + (Nil {integer}))) - (c-72593 - (Tuple2-71614 - {PredKey-71635} - {List-71608 + (c + (Tuple2 + {PredKey} + {List integer} - MaxValue-71636 + MaxValue ((let - a-72600 - = List-71608 + a + = List integer in - \(c-72601 : + \(c : integer -> - a-72600 -> - a-72600) - (n-72602 : - a-72600) -> - c-72601 + a -> + a) + (n : + a) -> + c 10 - n-72602) - (\(ds-72603 : + n) + (\(ds : integer) - (ds-72604 : - List-71608 + (ds : + List integer) -> - Cons-71610 + Cons {integer} - ds-72603 - ds-72604) - (Nil-71609 + ds + ds) + (Nil {integer}))) - n-72594))))) - (c-71871 - (Tuple2-71614 + n))))) + (c + (Tuple2 {integer} - {ParamValue-71653} + {ParamValue} 28 - (ParamInteger-71655 + (ParamInteger ((let - a-72605 - = Tuple2-71613 - PredKey-71635 - (List-71608 + a + = Tuple2 + PredKey + (List integer) in - \(g-72606 : - all b-72607. - (a-72605 -> - b-72607 -> - b-72607) -> - b-72607 -> - b-72607) -> - g-72606 - {List-71608 - a-72605} - (\(ds-72608 : - a-72605) - (ds-72609 : - List-71608 - a-72605) -> - Cons-71610 - {a-72605} - ds-72608 - ds-72609) - (Nil-71609 - {a-72605})) - (/\a-72610 -> - \(c-72611 : - Tuple2-71613 - PredKey-71635 - (List-71608 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List integer) -> - a-72610 -> - a-72610) - (n-72612 : - a-72610) -> - c-72611 - (Tuple2-71614 - {PredKey-71635} - {List-71608 + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List integer} - MinValue-71637 + MinValue ((let - a-72613 - = List-71608 + a + = List integer in - \(c-72614 : + \(c : integer -> - a-72613 -> - a-72613) - (n-72615 : - a-72613) -> - c-72614 + a -> + a) + (n : + a) -> + c 0 - (c-72614 + (c 18 - n-72615)) - (\(ds-72616 : + n)) + (\(ds : integer) - (ds-72617 : - List-71608 + (ds : + List integer) -> - Cons-71610 + Cons {integer} - ds-72616 - ds-72617) - (Nil-71609 + ds + ds) + (Nil {integer}))) - (c-72611 - (Tuple2-71614 - {PredKey-71635} - {List-71608 + (c + (Tuple2 + {PredKey} + {List integer} - MaxValue-71636 + MaxValue ((let - a-72618 - = List-71608 + a + = List integer in - \(c-72619 : + \(c : integer -> - a-72618 -> - a-72618) - (n-72620 : - a-72618) -> - c-72619 + a -> + a) + (n : + a) -> + c 293 - n-72620) - (\(ds-72621 : + n) + (\(ds : integer) - (ds-72622 : - List-71608 + (ds : + List integer) -> - Cons-71610 + Cons {integer} - ds-72621 - ds-72622) - (Nil-71609 + ds + ds) + (Nil {integer}))) - (c-72611 - (Tuple2-71614 - {PredKey-71635} - {List-71608 + (c + (Tuple2 + {PredKey} + {List integer} - NotEqual-71638 + NotEqual ((let - a-72623 - = List-71608 + a + = List integer in - \(c-72624 : + \(c : integer -> - a-72623 -> - a-72623) - (n-72625 : - a-72623) -> - c-72624 + a -> + a) + (n : + a) -> + c 0 - n-72625) - (\(ds-72626 : + n) + (\(ds : integer) - (ds-72627 : - List-71608 + (ds : + List integer) -> - Cons-71610 + Cons {integer} - ds-72626 - ds-72627) - (Nil-71609 + ds + ds) + (Nil {integer}))) - n-72612)))))) - (c-71871 - (Tuple2-71614 + n)))))) + (c + (Tuple2 {integer} - {ParamValue-71653} + {ParamValue} 29 - (ParamInteger-71655 + (ParamInteger ((let - a-72628 - = Tuple2-71613 - PredKey-71635 - (List-71608 + a + = Tuple2 + PredKey + (List integer) in - \(g-72629 : - all b-72630. - (a-72628 -> - b-72630 -> - b-72630) -> - b-72630 -> - b-72630) -> - g-72629 - {List-71608 - a-72628} - (\(ds-72631 : - a-72628) - (ds-72632 : - List-71608 - a-72628) -> - Cons-71610 - {a-72628} - ds-72631 - ds-72632) - (Nil-71609 - {a-72628})) - (/\a-72633 -> - \(c-72634 : - Tuple2-71613 - PredKey-71635 - (List-71608 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List integer) -> - a-72633 -> - a-72633) - (n-72635 : - a-72633) -> - c-72634 - (Tuple2-71614 - {PredKey-71635} - {List-71608 + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List integer} - MinValue-71637 + MinValue ((let - a-72636 - = List-71608 + a + = List integer in - \(c-72637 : + \(c : integer -> - a-72636 -> - a-72636) - (n-72638 : - a-72636) -> - c-72637 + a -> + a) + (n : + a) -> + c 1 - n-72638) - (\(ds-72639 : + n) + (\(ds : integer) - (ds-72640 : - List-71608 + (ds : + List integer) -> - Cons-71610 + Cons {integer} - ds-72639 - ds-72640) - (Nil-71609 + ds + ds) + (Nil {integer}))) - (c-72634 - (Tuple2-71614 - {PredKey-71635} - {List-71608 + (c + (Tuple2 + {PredKey} + {List integer} - MaxValue-71636 + MaxValue ((let - a-72641 - = List-71608 + a + = List integer in - \(c-72642 : + \(c : integer -> - a-72641 -> - a-72641) - (n-72643 : - a-72641) -> - c-72642 + a -> + a) + (n : + a) -> + c 15 - n-72643) - (\(ds-72644 : + n) + (\(ds : integer) - (ds-72645 : - List-71608 + (ds : + List integer) -> - Cons-71610 + Cons {integer} - ds-72644 - ds-72645) - (Nil-71609 + ds + ds) + (Nil {integer}))) - n-72635))))) - (c-71871 - (Tuple2-71614 + n))))) + (c + (Tuple2 {integer} - {ParamValue-71653} + {ParamValue} 30 - (ParamInteger-71655 + (ParamInteger ((let - a-72646 - = Tuple2-71613 - PredKey-71635 - (List-71608 + a + = Tuple2 + PredKey + (List integer) in - \(g-72647 : - all b-72648. - (a-72646 -> - b-72648 -> - b-72648) -> - b-72648 -> - b-72648) -> - g-72647 - {List-71608 - a-72646} - (\(ds-72649 : - a-72646) - (ds-72650 : - List-71608 - a-72646) -> - Cons-71610 - {a-72646} - ds-72649 - ds-72650) - (Nil-71609 - {a-72646})) - (/\a-72651 -> - \(c-72652 : - Tuple2-71613 - PredKey-71635 - (List-71608 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List integer) -> - a-72651 -> - a-72651) - (n-72653 : - a-72651) -> - c-72652 - (Tuple2-71614 - {PredKey-71635} - {List-71608 + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List integer} - MinValue-71637 + MinValue ((let - a-72654 - = List-71608 + a + = List integer in - \(c-72655 : + \(c : integer -> - a-72654 -> - a-72654) - (n-72656 : - a-72654) -> - c-72655 + a -> + a) + (n : + a) -> + c 0 - (c-72655 + (c 1000000 - n-72656)) - (\(ds-72657 : + n)) + (\(ds : integer) - (ds-72658 : - List-71608 + (ds : + List integer) -> - Cons-71610 + Cons {integer} - ds-72657 - ds-72658) - (Nil-71609 + ds + ds) + (Nil {integer}))) - (c-72652 - (Tuple2-71614 - {PredKey-71635} - {List-71608 + (c + (Tuple2 + {PredKey} + {List integer} - MaxValue-71636 + MaxValue ((let - a-72659 - = List-71608 + a + = List integer in - \(c-72660 : + \(c : integer -> - a-72659 -> - a-72659) - (n-72661 : - a-72659) -> - c-72660 + a -> + a) + (n : + a) -> + c 10000000000000 - n-72661) - (\(ds-72662 : + n) + (\(ds : integer) - (ds-72663 : - List-71608 + (ds : + List integer) -> - Cons-71610 + Cons {integer} - ds-72662 - ds-72663) - (Nil-71609 + ds + ds) + (Nil {integer}))) - n-72653))))) - (c-71871 - (Tuple2-71614 + n))))) + (c + (Tuple2 {integer} - {ParamValue-71653} + {ParamValue} 31 - (ParamInteger-71655 + (ParamInteger ((let - a-72664 - = Tuple2-71613 - PredKey-71635 - (List-71608 + a + = Tuple2 + PredKey + (List integer) in - \(g-72665 : - all b-72666. - (a-72664 -> - b-72666 -> - b-72666) -> - b-72666 -> - b-72666) -> - g-72665 - {List-71608 - a-72664} - (\(ds-72667 : - a-72664) - (ds-72668 : - List-71608 - a-72664) -> - Cons-71610 - {a-72664} - ds-72667 - ds-72668) - (Nil-71609 - {a-72664})) - (/\a-72669 -> - \(c-72670 : - Tuple2-71613 - PredKey-71635 - (List-71608 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List integer) -> - a-72669 -> - a-72669) - (n-72671 : - a-72669) -> - c-72670 - (Tuple2-71614 - {PredKey-71635} - {List-71608 + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List integer} - MinValue-71637 + MinValue ((let - a-72672 - = List-71608 + a + = List integer in - \(c-72673 : + \(c : integer -> - a-72672 -> - a-72672) - (n-72674 : - a-72672) -> - c-72673 + a -> + a) + (n : + a) -> + c 0 - (c-72673 + (c 1000000 - n-72674)) - (\(ds-72675 : + n)) + (\(ds : integer) - (ds-72676 : - List-71608 + (ds : + List integer) -> - Cons-71610 + Cons {integer} - ds-72675 - ds-72676) - (Nil-71609 + ds + ds) + (Nil {integer}))) - (c-72670 - (Tuple2-71614 - {PredKey-71635} - {List-71608 + (c + (Tuple2 + {PredKey} + {List integer} - MaxValue-71636 + MaxValue ((let - a-72677 - = List-71608 + a + = List integer in - \(c-72678 : + \(c : integer -> - a-72677 -> - a-72677) - (n-72679 : - a-72677) -> - c-72678 + a -> + a) + (n : + a) -> + c 100000000000 - n-72679) - (\(ds-72680 : + n) + (\(ds : integer) - (ds-72681 : - List-71608 + (ds : + List integer) -> - Cons-71610 + Cons {integer} - ds-72680 - ds-72681) - (Nil-71609 + ds + ds) + (Nil {integer}))) - n-72671))))) - (c-71871 - (Tuple2-71614 + n))))) + (c + (Tuple2 {integer} - {ParamValue-71653} + {ParamValue} 32 - (ParamInteger-71655 + (ParamInteger ((let - a-72682 - = Tuple2-71613 - PredKey-71635 - (List-71608 + a + = Tuple2 + PredKey + (List integer) in - \(g-72683 : - all b-72684. - (a-72682 -> - b-72684 -> - b-72684) -> - b-72684 -> - b-72684) -> - g-72683 - {List-71608 - a-72682} - (\(ds-72685 : - a-72682) - (ds-72686 : - List-71608 - a-72682) -> - Cons-71610 - {a-72682} - ds-72685 - ds-72686) - (Nil-71609 - {a-72682})) - (/\a-72687 -> - \(c-72688 : - Tuple2-71613 - PredKey-71635 - (List-71608 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List integer) -> - a-72687 -> - a-72687) - (n-72689 : - a-72687) -> - c-72688 - (Tuple2-71614 - {PredKey-71635} - {List-71608 + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List integer} - MinValue-71637 + MinValue ((let - a-72690 - = List-71608 + a + = List integer in - \(c-72691 : + \(c : integer -> - a-72690 -> - a-72690) - (n-72692 : - a-72690) -> - c-72691 + a -> + a) + (n : + a) -> + c 13 - (c-72691 + (c 0 - n-72692)) - (\(ds-72693 : + n)) + (\(ds : integer) - (ds-72694 : - List-71608 + (ds : + List integer) -> - Cons-71610 + Cons {integer} - ds-72693 - ds-72694) - (Nil-71609 + ds + ds) + (Nil {integer}))) - (c-72688 - (Tuple2-71614 - {PredKey-71635} - {List-71608 + (c + (Tuple2 + {PredKey} + {List integer} - MaxValue-71636 + MaxValue ((let - a-72695 - = List-71608 + a + = List integer in - \(c-72696 : + \(c : integer -> - a-72695 -> - a-72695) - (n-72697 : - a-72695) -> - c-72696 + a -> + a) + (n : + a) -> + c 37 - n-72697) - (\(ds-72698 : + n) + (\(ds : integer) - (ds-72699 : - List-71608 + (ds : + List integer) -> - Cons-71610 + Cons {integer} - ds-72698 - ds-72699) - (Nil-71609 + ds + ds) + (Nil {integer}))) - n-72689))))) - (c-71871 - (Tuple2-71614 + n))))) + (c + (Tuple2 {integer} - {ParamValue-71653} + {ParamValue} 33 - (ParamRational-71657 + (ParamRational ((let - a-72700 - = Tuple2-71613 - PredKey-71635 - (List-71608 - Rational-71650) + a + = Tuple2 + PredKey + (List + Rational) in - \(g-72701 : - all b-72702. - (a-72700 -> - b-72702 -> - b-72702) -> - b-72702 -> - b-72702) -> - g-72701 - {List-71608 - a-72700} - (\(ds-72703 : - a-72700) - (ds-72704 : - List-71608 - a-72700) -> - Cons-71610 - {a-72700} - ds-72703 - ds-72704) - (Nil-71609 - {a-72700})) - (/\a-72705 -> - \(c-72706 : - Tuple2-71613 - PredKey-71635 - (List-71608 - Rational-71650) -> - a-72705 -> - a-72705) - (n-72707 : - a-72705) -> - c-72706 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - Rational-71650} - MinValue-71637 + \(g : + all b. + (a -> + b -> + b) -> + b -> + b) -> + g + {List + a} + (\(ds : + a) + (ds : + List + a) -> + Cons + {a} + ds + ds) + (Nil + {a})) + (/\a -> + \(c : + Tuple2 + PredKey + (List + Rational) -> + a -> + a) + (n : + a) -> + c + (Tuple2 + {PredKey} + {List + Rational} + MinValue ((let - a-72708 - = List-71608 - Rational-71650 + a + = List + Rational in - \(c-72709 : - Rational-71650 -> - a-72708 -> - a-72708) - (n-72710 : - a-72708) -> - c-72709 - (unsafeRatio-71668 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 0 1) - n-72710) - (\(ds-72711 : - Rational-71650) - (ds-72712 : - List-71608 - Rational-71650) -> - Cons-71610 - {Rational-71650} - ds-72711 - ds-72712) - (Nil-71609 - {Rational-71650}))) - (c-72706 - (Tuple2-71614 - {PredKey-71635} - {List-71608 - Rational-71650} - MaxValue-71636 + n) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + (c + (Tuple2 + {PredKey} + {List + Rational} + MaxValue ((let - a-72713 - = List-71608 - Rational-71650 + a + = List + Rational in - \(c-72714 : - Rational-71650 -> - a-72713 -> - a-72713) - (n-72715 : - a-72713) -> - c-72714 - (unsafeRatio-71668 + \(c : + Rational -> + a -> + a) + (n : + a) -> + c + (unsafeRatio 1000 1) - n-72715) - (\(ds-72716 : - Rational-71650) - (ds-72717 : - List-71608 - Rational-71650) -> - Cons-71610 - {Rational-71650} - ds-72716 - ds-72717) - (Nil-71609 - {Rational-71650}))) - n-72707))))) - n-71872)))))))))))))))))))))))))))))) - !fun-72752 : List-71608 (Tuple2-71613 data data) -> Bool-71628 + n) + (\(ds : + Rational) + (ds : + List + Rational) -> + Cons + {Rational} + ds + ds) + (Nil + {Rational}))) + n))))) + n)))))))))))))))))))))))))))))) + !fun : List (Tuple2 data data) -> Bool = (let - a-72719 = Tuple2-71613 data data + a = Tuple2 data data in - \(f-72720 : a-72719 -> Bool-71628) -> + \(f : a -> Bool) -> letrec - !go-72722 : List-71608 a-72719 -> Bool-71628 - = \(ds-72723 : List-71608 a-72719) -> - List_match-71611 - {a-72719} - ds-72723 - {all dead-72724. Bool-71628} - (/\dead-72725 -> True-71629) - (\(x-72726 : a-72719) (xs-72727 : List-71608 a-72719) -> - /\dead-72728 -> - Bool_match-71631 - (f-72720 x-72726) - {all dead-72729. Bool-71628} - (/\dead-72730 -> go-72722 xs-72727) - (/\dead-72731 -> False-71630) - {all dead-72732. dead-72732}) - {all dead-72733. dead-72733} + !go : List a -> Bool + = \(ds : List a) -> + List_match + {a} + ds + {all dead. Bool} + (/\dead -> True) + (\(x : a) (xs : List a) -> + /\dead -> + Bool_match + (f x) + {all dead. Bool} + (/\dead -> go xs) + (/\dead -> False) + {all dead. dead}) + {all dead. dead} in - \(eta-72721 : List-71608 a-72719) -> go-72722 eta-72721) - (\(ds-72734 : Tuple2-71613 data data) -> - Tuple2_match-71615 + \(eta : List a) -> go eta) + (\(ds : Tuple2 data data) -> + Tuple2_match {data} {data} - ds-72734 - {Bool-71628} - (\(ds-72735 : data) (actualValueData-72736 : data) -> - validateParamValue-71701 + ds + {Bool} + (\(ds : data) (actualValueData : data) -> + validateParamValue ((let - !k-72737 : integer = unIData ds-72735 + !k : integer = unIData ds in letrec - !go-72738 : - List-71608 - (Tuple2-71613 integer ParamValue-71653) -> - ParamValue-71653 - = \(ds-72739 : - List-71608 - (Tuple2-71613 integer ParamValue-71653)) -> - List_match-71611 - {Tuple2-71613 integer ParamValue-71653} - ds-72739 - {all dead-72740. ParamValue-71653} - (/\dead-72741 -> error {ParamValue-71653}) - (\(ds-72742 : - Tuple2-71613 integer ParamValue-71653) - (xs'-72743 : - List-71608 - (Tuple2-71613 - integer - ParamValue-71653)) -> - /\dead-72744 -> - Tuple2_match-71615 + !go : List (Tuple2 integer ParamValue) -> ParamValue + = \(ds : List (Tuple2 integer ParamValue)) -> + List_match + {Tuple2 integer ParamValue} + ds + {all dead. ParamValue} + (/\dead -> error {ParamValue}) + (\(ds : Tuple2 integer ParamValue) + (xs' : List (Tuple2 integer ParamValue)) -> + /\dead -> + Tuple2_match {integer} - {ParamValue-71653} - ds-72742 - {ParamValue-71653} - (\(k'-72745 : integer) - (i-72746 : ParamValue-71653) -> - Bool_match-71631 - (equalsInteger-71700 - k-72737 - k'-72745) - {all dead-72747. ParamValue-71653} - (/\dead-72748 -> i-72746) - (/\dead-72749 -> - go-72738 xs'-72743) - {all dead-72750. dead-72750})) - {all dead-72751. dead-72751} + {ParamValue} + ds + {ParamValue} + (\(k' : integer) (i : ParamValue) -> + Bool_match + (equalsInteger k k') + {all dead. ParamValue} + (/\dead -> i) + (/\dead -> go xs') + {all dead. dead})) + {all dead. dead} in - go-72738) - cfg-72718) - actualValueData-72736)) + go) + cfg) + actualValueData)) in - \(ds-72753 : data) -> - Maybe_match-71626 - {List-71608 (Tuple2-71613 data data)} + \(ds : data) -> + Maybe_match + {List (Tuple2 data data)} (let - !ds-72760 : data + !ds : data = headList {data} (tailList @@ -5681,7 +5224,7 @@ program {list data} (unConstrData (let - !ds-72754 : data + !ds : data = headList {data} (tailList @@ -5691,69 +5234,56 @@ program (sndPair {integer} {list data} - (unConstrData ds-72753)))) - ~si-72755 : pair integer (list data) - = unConstrData ds-72754 + (unConstrData ds)))) + ~si : pair integer (list data) = unConstrData ds in - Bool_match-71631 + Bool_match (ifThenElse - {Bool-71628} + {Bool} (equalsInteger 5 - (fstPair {integer} {list data} si-72755)) - True-71629 - False-71630) - {all dead-72756. data} - (/\dead-72757 -> + (fstPair {integer} {list data} si)) + True + False) + {all dead. data} + (/\dead -> headList {data} (tailList {data} - (sndPair {integer} {list data} si-72755))) - (/\dead-72758 -> error {data}) - {all dead-72759. dead-72759}))))) - ~ds-72761 : pair integer (list data) = unConstrData ds-72760 - !x-72762 : integer = fstPair {integer} {list data} ds-72761 + (sndPair {integer} {list data} si))) + (/\dead -> error {data}) + {all dead. dead}))))) + ~ds : pair integer (list data) = unConstrData ds + !x : integer = fstPair {integer} {list data} ds in - Bool_match-71631 - (ifThenElse - {Bool-71628} - (equalsInteger 0 x-72762) - True-71629 - False-71630) - {all dead-72763. Maybe-71623 (List-71608 (Tuple2-71613 data data))} - (/\dead-72764 -> - Just-71624 - {List-71608 (Tuple2-71613 data data)} - (go-71618 + Bool_match + (ifThenElse {Bool} (equalsInteger 0 x) True False) + {all dead. Maybe (List (Tuple2 data data))} + (/\dead -> + Just + {List (Tuple2 data data)} + (go (unMapData (headList {data} - (tailList - {data} - (sndPair {integer} {list data} ds-72761)))))) - (/\dead-72765 -> - Bool_match-71631 - (ifThenElse - {Bool-71628} - (equalsInteger 2 x-72762) - True-71629 - False-71630) - {all dead-72766. Maybe-71623 (List-71608 (Tuple2-71613 data data))} - (/\dead-72767 -> - Nothing-71625 {List-71608 (Tuple2-71613 data data)}) - (/\dead-72768 -> - error {Maybe-71623 (List-71608 (Tuple2-71613 data data))}) - {all dead-72769. dead-72769}) - {all dead-72770. dead-72770}) - {all dead-72771. unit} - (\(cparams-72772 : List-71608 (Tuple2-71613 data data)) -> - /\dead-72773 -> - Bool_match-71631 - (fun-72752 cparams-72772) - {all dead-72774. unit} - (/\dead-72775 -> ()) - (/\dead-72776 -> error {unit}) - {all dead-72777. dead-72777}) - (/\dead-72778 -> ()) - {all dead-72779. dead-72779}) \ No newline at end of file + (tailList {data} (sndPair {integer} {list data} ds)))))) + (/\dead -> + Bool_match + (ifThenElse {Bool} (equalsInteger 2 x) True False) + {all dead. Maybe (List (Tuple2 data data))} + (/\dead -> Nothing {List (Tuple2 data data)}) + (/\dead -> error {Maybe (List (Tuple2 data data))}) + {all dead. dead}) + {all dead. dead}) + {all dead. unit} + (\(cparams : List (Tuple2 data data)) -> + /\dead -> + Bool_match + (fun cparams) + {all dead. unit} + (/\dead -> ()) + (/\dead -> error {unit}) + {all dead. dead}) + (/\dead -> ()) + {all dead. dead}) \ No newline at end of file diff --git a/cardano-constitution/test/Cardano/Constitution/Validator/GoldenTests/unsorted.uplc.golden b/cardano-constitution/test/Cardano/Constitution/Validator/GoldenTests/unsorted.uplc.golden index fe38b6af17f..8d58ae70df1 100644 --- a/cardano-constitution/test/Cardano/Constitution/Validator/GoldenTests/unsorted.uplc.golden +++ b/cardano-constitution/test/Cardano/Constitution/Validator/GoldenTests/unsorted.uplc.golden @@ -1,63 +1,63 @@ program 1.1.0 - ((\fix1!0 -> - (\`$fOrdRational0_$c<=`!0 -> - (\`$fOrdInteger_$ccompare`!0 -> - (\equalsInteger!0 -> - (\validatePreds!0 -> - (\euclid!0 -> - (\unsafeRatio!0 -> - (\cse!0 -> - (\validateParamValue!0 -> - (\validateParamValues!0 -> - (\go!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\cfg!0 -> - (\fun!0 - ds!0 -> + ((\fix1 -> + (\`$fOrdRational0_$c<=` -> + (\`$fOrdInteger_$ccompare` -> + (\equalsInteger -> + (\validatePreds -> + (\euclid -> + (\unsafeRatio -> + (\cse -> + (\validateParamValue -> + (\validateParamValues -> + (\go -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cse -> + (\cfg -> + (\fun + ds -> force (case - ((\cse!0 -> - (\x!0 -> + ((\cse -> + (\x -> force (force (force ifThenElse (equalsInteger 0 - x!1) + x) (delay (delay (constr 0 - [ (go!35 + [ (go (unMapData (force headList @@ -66,7 +66,7 @@ program (force (force sndPair) - cse!2))))) ]))) + cse))))) ]))) (delay (delay (force @@ -75,7 +75,7 @@ program ifThenElse (equalsInteger 2 - x!1) + x) (delay (delay (constr 1 @@ -86,7 +86,7 @@ program (force (force fstPair) - cse!1)) + cse)) (unConstrData (force headList @@ -98,7 +98,7 @@ program (force sndPair) (unConstrData - ((\cse!0 -> + ((\cse -> force (force (force @@ -108,7 +108,7 @@ program (force (force fstPair) - cse!1)) + cse)) (delay (delay (force @@ -118,7 +118,7 @@ program (force (force sndPair) - cse!1))))) + cse))))) (delay (delay error))))) @@ -133,75 +133,75 @@ program (force sndPair) (unConstrData - ds!1)))))))))))))) - [ (\cparams!0 -> + ds)))))))))))))) + [ (\cparams -> delay (force (case - (fun!3 - cparams!1) + (fun + cparams) [ (delay ()) , (delay error) ]))) , (delay ()) ])) - ((\go!0 - eta!0 -> - go!2 - eta!1) - (fix1!41 - (\go!0 - ds!0 -> + ((\go + eta -> + go + eta) + (fix1 + (\go + ds -> force (case - ds!1 + ds [ (delay (constr 0 [ ])) - , (\x!0 - xs!0 -> + , (\x + xs -> delay (force (case (case - x!2 - [ (\ds!0 - actualValueData!0 -> - validateParamValue!39 - ((\k!0 -> - fix1!48 - (\go!0 - ds!0 -> + x + [ (\ds + actualValueData -> + validateParamValue + ((\k -> + fix1 + (\go + ds -> force (case - ds!1 + ds [ (delay error) - , (\ds!0 - xs'!0 -> + , (\ds + xs' -> delay (case - ds!2 - [ (\k'!0 - i!0 -> + ds + [ (\k' + i -> force (case - (equalsInteger!51 - k!7 - k'!2) + (equalsInteger + k + k') [ (delay - i!1) + i) , (delay - (go!6 - xs'!3)) ])) ])) ]))) + (go + xs')) ])) ])) ]))) (unIData - ds!2) - cfg!7) - actualValueData!1) ]) + ds) + cfg) + actualValueData) ]) [ (delay - (go!4 - xs!1)) + (go + xs)) , (delay (constr 1 [ ])) ]))) ]))))) @@ -215,7 +215,7 @@ program [ ]) , (constr 1 [ 30 - , cse!27 ]) ]) + , cse ]) ]) , (constr 1 [ (constr 0 [ (constr 0 @@ -236,7 +236,7 @@ program [ ]) , (constr 1 [ 100000 - , cse!27 ]) ]) + , cse ]) ]) , (constr 1 [ (constr 0 [ (constr 0 @@ -274,7 +274,7 @@ program [ 3 , (constr 1 [ (constr 1 - [ cse!16 + [ cse , (constr 1 [ (constr 0 [ (constr 0 @@ -290,7 +290,7 @@ program [ 4 , (constr 1 [ (constr 1 - [ cse!16 + [ cse , (constr 1 [ (constr 0 [ (constr 0 @@ -311,7 +311,7 @@ program [ ]) , (constr 1 [ 1000000 - , cse!27 ]) ]) + , cse ]) ]) , (constr 1 [ (constr 0 [ (constr 0 @@ -332,14 +332,14 @@ program [ ]) , (constr 1 [ 250000000 - , cse!27 ]) ]) - , cse!11 ]) ]) ]) + , cse ]) ]) + , cse ]) ]) ]) , (constr 1 [ (constr 0 [ 7 , (constr 1 [ (constr 1 - [ cse!16 + [ cse , (constr 0 [ ]) ]) ]) ]) , (constr 1 @@ -352,7 +352,7 @@ program [ ]) , (constr 1 [ 250 - , cse!27 ]) ]) + , cse ]) ]) , (constr 1 [ (constr 0 [ (constr 0 @@ -361,14 +361,14 @@ program [ 2000 , (constr 0 [ ]) ]) ]) - , cse!10 ]) ]) ]) ]) + , cse ]) ]) ]) ]) , (constr 1 [ (constr 0 [ 9 , (constr 3 [ (constr 1 - [ cse!6 - , cse!8 ]) ]) ]) + [ cse + , cse ]) ]) ]) , (constr 1 [ (constr 0 [ 10 @@ -378,15 +378,15 @@ program [ (constr 1 [ ]) , (constr 1 - [ (cse!29 + [ (cse 1000) - , cse!14 ]) ]) + , cse ]) ]) , (constr 1 [ (constr 0 [ (constr 0 [ ]) , (constr 1 - [ (cse!29 + [ (cse 200) , (constr 0 [ ]) ]) ]) @@ -397,15 +397,15 @@ program [ 11 , (constr 3 [ (constr 1 - [ cse!6 + [ cse , (constr 1 [ (constr 0 [ (constr 0 [ ]) , (constr 1 - [ (cse!25 + [ (cse 10) - , cse!13 ]) ]) + , cse ]) ]) , (constr 0 [ ]) ]) ]) ]) ]) , (constr 1 @@ -413,8 +413,8 @@ program [ 16 , (constr 1 [ (constr 1 - [ cse!16 - , cse!11 ]) ]) ]) + [ cse + , cse ]) ]) ]) , (constr 1 [ (constr 0 [ 17 @@ -425,7 +425,7 @@ program [ ]) , (constr 1 [ 3000 - , cse!27 ]) ]) + , cse ]) ]) , (constr 1 [ (constr 0 [ (constr 0 @@ -434,7 +434,7 @@ program [ 6500 , (constr 0 [ ]) ]) ]) - , cse!10 ]) ]) ]) ]) + , cse ]) ]) ]) ]) , (constr 1 [ (constr 0 [ 18 @@ -451,7 +451,7 @@ program [ (constr 1 [ ]) , (constr 1 - [ (cse!29 + [ (cse 25) , (constr 0 [ ]) ]) ]) @@ -460,7 +460,7 @@ program [ (constr 0 [ ]) , (constr 1 - [ (cse!29 + [ (cse 5) , (constr 0 [ ]) ]) ]) @@ -473,7 +473,7 @@ program [ (constr 1 [ ]) , (constr 1 - [ (cse!29 + [ (cse 20000) , (constr 0 [ ]) ]) ]) @@ -482,7 +482,7 @@ program [ (constr 0 [ ]) , (constr 1 - [ (cse!29 + [ (cse 5000) , (constr 0 [ ]) ]) ]) @@ -497,7 +497,7 @@ program [ (constr 1 [ (constr 1 [ (constr 1 - [ cse!16 + [ cse , (constr 1 [ (constr 0 [ (constr 0 @@ -511,7 +511,7 @@ program , (constr 1 [ (constr 1 [ (constr 1 - [ cse!16 + [ cse , (constr 1 [ (constr 0 [ (constr 0 @@ -531,7 +531,7 @@ program [ (constr 1 [ (constr 1 [ (constr 1 - [ cse!16 + [ cse , (constr 1 [ (constr 0 [ (constr 0 @@ -545,7 +545,7 @@ program , (constr 1 [ (constr 1 [ (constr 1 - [ cse!16 + [ cse , (constr 1 [ (constr 0 [ (constr 0 @@ -563,7 +563,7 @@ program [ 22 , (constr 1 [ (constr 1 - [ cse!16 + [ cse , (constr 1 [ (constr 0 [ (constr 0 @@ -584,7 +584,7 @@ program [ ]) , (constr 1 [ 100 - , cse!27 ]) ]) + , cse ]) ]) , (constr 1 [ (constr 0 [ (constr 0 @@ -593,13 +593,13 @@ program [ 200 , (constr 0 [ ]) ]) ]) - , cse!10 ]) ]) ]) ]) + , cse ]) ]) ]) ]) , (constr 1 [ (constr 0 [ 24 , (constr 1 [ (constr 1 - [ cse!19 + [ cse , (constr 0 [ ]) ]) ]) ]) , (constr 1 @@ -607,24 +607,24 @@ program [ 25 , (constr 2 [ (constr 1 - [ cse!1 + [ cse , (constr 1 - [ cse!3 + [ cse , (constr 1 - [ cse!3 + [ cse , (constr 1 - [ cse!2 - , cse!4 ]) ]) ]) ]) ]) ]) + [ cse + , cse ]) ]) ]) ]) ]) ]) , (constr 1 [ (constr 0 [ 26 , (constr 2 [ (constr 1 - [ cse!1 + [ cse , (constr 1 - [ cse!3 + [ cse , (constr 1 - [ cse!3 + [ cse , (constr 1 [ (constr 3 [ (constr 1 @@ -632,22 +632,22 @@ program [ (constr 1 [ ]) , (constr 1 - [ cse!18 + [ cse , (constr 1 - [ (unsafeRatio!34 + [ (unsafeRatio 13 20) , (constr 0 [ ]) ]) ]) ]) - , cse!5 ]) ]) + , cse ]) ]) , (constr 1 - [ cse!2 + [ cse , (constr 1 - [ cse!1 + [ cse , (constr 1 - [ cse!1 + [ cse , (constr 1 - [ cse!1 + [ cse , (constr 1 [ (constr 3 [ (constr 1 @@ -655,10 +655,10 @@ program [ (constr 1 [ ]) , (constr 1 - [ cse!18 - , cse!12 ]) ]) - , cse!5 ]) ]) - , cse!4 ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) + [ cse + , cse ]) ]) + , cse ]) ]) + , cse ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) , (constr 1 [ (constr 0 [ 27 @@ -705,13 +705,13 @@ program [ 293 , (constr 0 [ ]) ]) ]) - , cse!10 ]) ]) ]) ]) + , cse ]) ]) ]) ]) , (constr 1 [ (constr 0 [ 29 , (constr 1 [ (constr 1 - [ cse!19 + [ cse , (constr 1 [ (constr 0 [ (constr 0 @@ -727,7 +727,7 @@ program [ 30 , (constr 1 [ (constr 1 - [ cse!9 + [ cse , (constr 1 [ (constr 0 [ (constr 0 @@ -743,7 +743,7 @@ program [ 31 , (constr 1 [ (constr 1 - [ cse!9 + [ cse , (constr 1 [ (constr 0 [ (constr 0 @@ -764,7 +764,7 @@ program [ ]) , (constr 1 [ 13 - , cse!27 ]) ]) + , cse ]) ]) , (constr 1 [ (constr 0 [ (constr 0 @@ -783,13 +783,13 @@ program [ (constr 0 [ (constr 1 [ ]) - , cse!14 ]) + , cse ]) , (constr 1 [ (constr 0 [ (constr 0 [ ]) , (constr 1 - [ (unsafeRatio!34 + [ (unsafeRatio 1000 1) , (constr 0 @@ -800,35 +800,35 @@ program [ ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ])) (constr 3 [ (constr 1 - [ cse!6 + [ cse , (constr 1 [ (constr 0 [ (constr 0 [ ]) , (constr 1 - [ cse!14 - , cse!11 ]) ]) + [ cse + , cse ]) ]) , (constr 0 [ ]) ]) ]) ])) (constr 3 [ (constr 1 - [ cse!5 + [ cse , (constr 1 [ (constr 0 [ (constr 0 [ ]) , (constr 1 - [ cse!13 + [ cse , (constr 1 - [ cse!19 + [ cse , (constr 0 [ ]) ]) ]) ]) , (constr 0 [ ]) ]) ]) ])) (constr 3 [ (constr 1 - [ cse!4 - , cse!2 ]) ])) + [ cse + , cse ]) ])) (constr 1 [ (constr 3 [ (constr 1 @@ -836,10 +836,10 @@ program [ (constr 1 [ ]) , (constr 1 - [ cse!14 + [ cse , (constr 0 [ ]) ]) ]) - , cse!4 ]) ]) + , cse ]) ]) , (constr 0 [ ]) ])) (constr 1 @@ -847,9 +847,9 @@ program [ (constr 0 [ ]) , (constr 1 - [ cse!10 + [ cse , (constr 1 - [ (cse!18 + [ (cse 10) , (constr 0 [ ]) ]) ]) ]) @@ -859,23 +859,23 @@ program [ (constr 1 [ ]) , (constr 1 - [ (cse!23 + [ (cse 10) - , cse!8 ]) ])) + , cse ]) ])) (constr 0 [ (constr 1 [ ]) , (constr 1 - [ cse!11 + [ cse , (constr 1 - [ cse!10 + [ cse , (constr 0 [ ]) ]) ]) ])) (constr 1 [ (constr 0 [ (constr 0 [ ]) - , cse!5 ]) + , cse ]) , (constr 0 [ ]) ])) (constr 0 @@ -891,7 +891,7 @@ program [ (constr 0 [ (constr 2 [ ]) - , cse!17 ]) + , cse ]) , (constr 0 [ ]) ])) (constr 1 @@ -905,27 +905,26 @@ program , (constr 0 [ ]) ])) (constr 1 - [ cse!8 + [ cse , (constr 0 [ ]) ])) (constr 1 - [ cse!2 + [ cse , (constr 0 [ ]) ])) (constr 1 - [ cse!8 + [ cse , (constr 0 [ ]) ])) - (cse!14 + (cse 1)) (constr 0 [ (constr 1 [ ]) - , cse!11 ])) - (cse!11 + , cse ])) + (cse 100)) - (cse!11 - 2)) + (cse 2)) (constr 0 [ (constr 1 []) @@ -933,168 +932,163 @@ program [ 1 , (constr 0 [ ]) ]) ])) - (cse!5 4)) - (cse!5 5)) - (cse!2 1)) - (unsafeRatio!11 9)) - (unsafeRatio!10 0)) - (unsafeRatio!9 3)) - (unsafeRatio!8 4)) + (cse 4)) + (cse 5)) + (cse 1)) + (unsafeRatio 9)) + (unsafeRatio 0)) + (unsafeRatio 3)) + (unsafeRatio 4)) (constr 1 [0, (constr 0 [])])) - (unsafeRatio!6 51)) - (unsafeRatio!5 1)) - (fix1!10 - (\go!0 l!0 -> + (unsafeRatio 51)) + (unsafeRatio 1)) + (fix1 + (\go l -> force (force chooseList) - l!1 - (\ds!0 -> constr 0 []) - (\ds!0 -> + l + (\ds -> constr 0 []) + (\ds -> constr 1 - [ ((\p!0 -> + [ ((\p -> constr 0 [ (force (force fstPair) - p!1) + p) , (force (force sndPair) - p!1) ]) - (force headList l!2)) - , (go!3 (force tailList l!2)) ]) + p) ]) + (force headList l)) + , (go (force tailList l)) ]) ()))) - (cse!2 (\arg_0!0 arg_1!0 -> arg_1!1))) - (cse!1 (\arg_0!0 arg_1!0 -> arg_0!2))) + (cse (\arg_0 arg_1 -> arg_1))) + (cse (\arg_0 arg_1 -> arg_0))) (force - ((\s!0 -> s!1 s!1) - (\s!0 h!0 -> + ((\s -> s s) + (\s h -> delay - (\fr!0 -> - (\k!0 -> - fr!2 - (\x!0 -> - k!2 (\f_0!0 f_1!0 -> f_0!2 x!3)) - (\x!0 -> - k!2 - (\f_0!0 f_1!0 -> f_1!1 x!3))) - (\fq!0 -> - force (s!4 s!4 h!3) - (force h!3 fq!1)))) + (\fr -> + (\k -> + fr + (\x -> k (\f_0 f_1 -> f_0 x)) + (\x -> k (\f_0 f_1 -> f_1 x))) + (\fq -> force (s s h) (force h fq)))) (delay - (\choose!0 - validateParamValue!0 - validateParamValues!0 -> - choose!3 - (\eta!0 eta!0 -> + (\choose + validateParamValue + validateParamValues -> + choose + (\eta eta -> force (case - eta!2 + eta [ (delay (constr 0 [])) - , (\preds!0 -> + , (\preds -> delay - (validatePreds!9 + (validatePreds (constr 0 - [ equalsInteger!10 - , `$fOrdInteger_$ccompare`!11 - , (\x!0 y!0 -> + [ equalsInteger + , `$fOrdInteger_$ccompare` + , (\x y -> force ifThenElse (lessThanInteger - x!2 - y!1) + x + y) (constr 0 []) (constr 1 [])) - , (\x!0 y!0 -> + , (\x y -> force ifThenElse (lessThanEqualsInteger - x!2 - y!1) + x + y) (constr 0 []) (constr 1 [])) - , (\x!0 y!0 -> + , (\x y -> force ifThenElse (lessThanEqualsInteger - x!2 - y!1) + x + y) (constr 1 []) (constr 0 [])) - , (\x!0 y!0 -> + , (\x y -> force ifThenElse (lessThanInteger - x!2 - y!1) + x + y) (constr 1 []) (constr 0 [])) - , (\x!0 y!0 -> + , (\x y -> force (force (force ifThenElse (lessThanEqualsInteger - x!2 - y!1) + x + y) (delay (delay - y!1)) + y)) (delay (delay - x!2))))) - , (\x!0 y!0 -> + x))))) + , (\x y -> force (force (force ifThenElse (lessThanEqualsInteger - x!2 - y!1) + x + y) (delay (delay - x!2)) + x)) (delay (delay - y!1))))) ]) - preds!1 - (unIData eta!2))) - , (\paramValues!0 -> + y))))) ]) + preds + (unIData eta))) + , (\paramValues -> delay - (validateParamValues!4 - paramValues!1 - (unListData eta!2))) - , (\preds!0 -> + (validateParamValues + paramValues + (unListData eta))) + , (\preds -> delay - ((\cse!0 -> - validatePreds!10 + ((\cse -> + validatePreds (constr 0 - [ (\ds!0 ds!0 -> + [ (\ds ds -> case - ds!2 - [ (\n!0 - d!0 -> + ds + [ (\n + d -> case - ds!3 - [ (\n'!0 - d'!0 -> + ds + [ (\n' + d' -> force (force (force ifThenElse (equalsInteger - n!4 - n'!2) + n + n') (delay (delay (force ifThenElse (equalsInteger - d!3 - d'!1) + d + d') (constr 0 [ ]) (constr 1 @@ -1103,320 +1097,316 @@ program (delay (constr 1 [ ])))))) ]) ]) - , (\ds!0 ds!0 -> + , (\ds ds -> case - ds!2 - [ (\n!0 - d!0 -> + ds + [ (\n + d -> case - ds!3 - [ (\n'!0 - d'!0 -> - `$fOrdInteger_$ccompare`!18 + ds + [ (\n' + d' -> + `$fOrdInteger_$ccompare` (multiplyInteger - n!4 - d'!1) + n + d') (multiplyInteger - n'!2 - d!3)) ]) ]) - , (\ds!0 ds!0 -> + n' + d)) ]) ]) + , (\ds ds -> case - ds!2 - [ (\n!0 - d!0 -> + ds + [ (\n + d -> case - ds!3 - [ (\n'!0 - d'!0 -> + ds + [ (\n' + d' -> force ifThenElse (lessThanInteger (multiplyInteger - n!4 - d'!1) + n + d') (multiplyInteger - n'!2 - d!3)) + n' + d)) (constr 0 [ ]) (constr 1 [ ])) ]) ]) - , `$fOrdRational0_$c<=`!13 - , (\ds!0 ds!0 -> + , `$fOrdRational0_$c<=` + , (\ds ds -> case - ds!2 - [ (\n!0 - d!0 -> + ds + [ (\n + d -> case - ds!3 - [ (\n'!0 - d'!0 -> + ds + [ (\n' + d' -> force ifThenElse (lessThanEqualsInteger (multiplyInteger - n!4 - d'!1) + n + d') (multiplyInteger - n'!2 - d!3)) + n' + d)) (constr 1 [ ]) (constr 0 [ ])) ]) ]) - , (\ds!0 ds!0 -> + , (\ds ds -> case - ds!2 - [ (\n!0 - d!0 -> + ds + [ (\n + d -> case - ds!3 - [ (\n'!0 - d'!0 -> + ds + [ (\n' + d' -> force ifThenElse (lessThanInteger (multiplyInteger - n!4 - d'!1) + n + d') (multiplyInteger - n'!2 - d!3)) + n' + d)) (constr 1 [ ]) (constr 0 [ ])) ]) ]) - , (\x!0 y!0 -> + , (\x y -> force (case - (`$fOrdRational0_$c<=`!15 - x!2 - y!1) + (`$fOrdRational0_$c<=` + x + y) [ (delay - y!1) + y) , (delay - x!2) ])) - , (\x!0 y!0 -> + x) ])) + , (\x y -> force (case - (`$fOrdRational0_$c<=`!15 - x!2 - y!1) + (`$fOrdRational0_$c<=` + x + y) [ (delay - x!2) + x) , (delay - y!1) ])) ]) - preds!2 - ((\cse!0 -> + y) ])) ]) + preds + ((\cse -> force ifThenElse (force nullList (force tailList - cse!1)) - (\ds!0 -> - unsafeRatio!10 + cse)) + (\ds -> + unsafeRatio (unIData (force headList - cse!3)) + cse)) (unIData (force headList - cse!2)))) + cse)))) (force tailList - cse!1) - (\ds!0 -> error) + cse) + (\ds -> error) (constr 0 []))) - (unListData - eta!2))) ])) - (\ds!0 -> + (unListData eta))) ])) + (\ds -> case - ds!1 - [ (\eta!0 -> + ds + [ (\eta -> force ifThenElse - (force nullList eta!1) + (force nullList eta) (constr 0 []) (constr 1 [])) - , (\paramValueHd!0 - paramValueTl!0 - actualValueData!0 -> + , (\paramValueHd + paramValueTl + actualValueData -> force (case - (validateParamValue!6 - paramValueHd!3 + (validateParamValue + paramValueHd (force headList - actualValueData!1)) + actualValueData)) [ (delay - (validateParamValues!5 - paramValueTl!2 + (validateParamValues + paramValueTl (force tailList - actualValueData!1))) + actualValueData))) , (delay (constr 1 [])) ])) ])))))) - (fix1!6 - (\unsafeRatio!0 n!0 d!0 -> + (fix1 + (\unsafeRatio n d -> force (force (force ifThenElse - (equalsInteger 0 d!1) + (equalsInteger 0 d) (delay (delay error)) (delay (delay (force (force (force ifThenElse - (lessThanInteger d!1 0) + (lessThanInteger d 0) (delay (delay - (unsafeRatio!3 + (unsafeRatio (subtractInteger 0 - n!2) + n) (subtractInteger 0 - d!1)))) + d)))) (delay (delay - ((\gcd'!0 -> + ((\gcd' -> constr 0 [ (quotientInteger - n!3 - gcd'!1) + n + gcd') , (quotientInteger - d!2 - gcd'!1) ]) - (euclid!4 - n!2 - d!1)))))))))))))) - (fix1!5 - (\euclid!0 x!0 y!0 -> + d + gcd') ]) + (euclid + n + d)))))))))))))) + (fix1 + (\euclid x y -> force (force (force ifThenElse - (equalsInteger 0 y!1) - (delay (delay x!2)) + (equalsInteger 0 y) + (delay (delay x)) (delay - (delay - (euclid!3 - y!1 - (modInteger x!2 y!1))))))))) - (\`$dOrd`!0 ds!0 ds!0 -> - fix1!7 - (\go!0 ds!0 -> + (delay (euclid y (modInteger x y))))))))) + (\`$dOrd` ds ds -> + fix1 + (\go ds -> force (case - ds!1 + ds [ (delay (constr 0 [])) - , (\x!0 xs!0 -> + , (\x xs -> delay (case - x!2 - [ (\predKey!0 expectedPredValues!0 -> - (\meaning!0 -> - fix1!14 - (\go!0 ds!0 -> + x + [ (\predKey expectedPredValues -> + (\meaning -> + fix1 + (\go ds -> force (case - ds!1 - [ (delay (go!9 xs!6)) - , (\x!0 xs!0 -> + ds + [ (delay (go xs)) + , (\x xs -> delay (force (case - (meaning!5 - x!2 - ds!12) + (meaning + x + ds) [ (delay - (go!4 - xs!1)) + (go + xs)) , (delay (constr 1 [ ])) ]))) ])) - expectedPredValues!2) + expectedPredValues) (force (case - predKey!2 + predKey [ (delay (case - `$dOrd`!9 - [ (\v!0 - v!0 - v!0 - v!0 - v!0 - v!0 - v!0 - v!0 -> - v!3) ])) + `$dOrd` + [ (\v + v + v + v + v + v + v + v -> + v) ])) , (delay (case - `$dOrd`!9 - [ (\v!0 - v!0 - v!0 - v!0 - v!0 - v!0 - v!0 - v!0 -> - v!5) ])) + `$dOrd` + [ (\v + v + v + v + v + v + v + v -> + v) ])) , (delay - (\x!0 y!0 -> + (\x y -> force (case (case - `$dOrd`!11 - [ (\v!0 - v!0 - v!0 - v!0 - v!0 - v!0 - v!0 - v!0 -> - v!8) ] - x!2 - y!1) + `$dOrd` + [ (\v + v + v + v + v + v + v + v -> + v) ] + x + y) [ (delay (constr 1 [])) , (delay (constr 0 [ ])) ]))) ]))) ])) ])) - ds!2)) - (\x!0 y!0 -> + ds)) + (\x y -> force ifThenElse - (equalsInteger x!2 y!1) + (equalsInteger x y) (constr 0 []) (constr 1 []))) - (\eta!0 eta!0 -> + (\eta eta -> force (force (force ifThenElse - (equalsInteger eta!2 eta!1) + (equalsInteger eta eta) (delay (delay (constr 0 []))) (delay (delay (force (force (force ifThenElse - (lessThanEqualsInteger eta!2 eta!1) + (lessThanEqualsInteger eta eta) (delay (delay (constr 2 []))) (delay (delay (constr 1 [])))))))))))) - (\ds!0 ds!0 -> + (\ds ds -> case - ds!2 - [ (\n!0 d!0 -> + ds + [ (\n d -> case - ds!3 - [ (\n'!0 d'!0 -> + ds + [ (\n' d' -> force ifThenElse (lessThanEqualsInteger - (multiplyInteger n!4 d'!1) - (multiplyInteger n'!2 d!3)) + (multiplyInteger n d') + (multiplyInteger n' d)) (constr 0 []) (constr 1 [])) ]) ])) - (\f!0 -> (\s!0 -> s!1 s!1) (\s!0 -> f!2 (\x!0 -> s!2 s!2 x!1)))) \ No newline at end of file + (\f -> (\s -> s s) (\s -> f (\x -> s s x)))) \ No newline at end of file diff --git a/plutus-tx-plugin/test/Plugin/Debug/9.6/fib.pir.golden b/plutus-tx-plugin/test/Plugin/Debug/9.6/fib.pir.golden index 7be80da7b1c..45afefbea79 100644 --- a/plutus-tx-plugin/test/Plugin/Debug/9.6/fib.pir.golden +++ b/plutus-tx-plugin/test/Plugin/Debug/9.6/fib.pir.golden @@ -9,7 +9,7 @@ (strict) (vardecl { no-src-span } - addInteger-538 + addInteger (fun { no-src-span } (con { no-src-span } integer) @@ -27,7 +27,7 @@ (nonstrict) (vardecl { no-src-span } - addInteger-543 + addInteger (fun { no-src-span } (con { no-src-span } integer) @@ -40,7 +40,7 @@ ) (lam { no-src-span } - x-539 + x (con { no-src-span } integer) (let { no-src-span } @@ -48,12 +48,12 @@ (termbind { no-src-span } (strict) - (vardecl { no-src-span } x-541 (con { no-src-span } integer)) - { no-src-span } x-539 + (vardecl { no-src-span } x (con { no-src-span } integer)) + { no-src-span } x ) (lam { no-src-span } - y-540 + y (con { no-src-span } integer) (let { no-src-span } @@ -61,17 +61,13 @@ (termbind { no-src-span } (strict) - (vardecl { no-src-span } y-542 (con { no-src-span } integer)) - { no-src-span } y-540 + (vardecl { no-src-span } y (con { no-src-span } integer)) + { no-src-span } y ) [ { no-src-span } - [ - { no-src-span } - { no-src-span } addInteger-538 - { no-src-span } x-541 - ] - { no-src-span } y-542 + [ { no-src-span } { no-src-span } addInteger { no-src-span } x ] + { no-src-span } y ] ) ) @@ -82,11 +78,11 @@ { no-src-span } (datatype { no-src-span } - (tyvardecl { no-src-span } Bool-528 ({ no-src-span } type)) + (tyvardecl { no-src-span } Bool ({ no-src-span } type)) - Bool_match-531 - (vardecl { no-src-span } True-529 { no-src-span } Bool-528) - (vardecl { no-src-span } False-530 { no-src-span } Bool-528) + Bool_match + (vardecl { no-src-span } True { no-src-span } Bool) + (vardecl { no-src-span } False { no-src-span } Bool) ) ) (termbind @@ -94,7 +90,7 @@ (strict) (vardecl { no-src-span } - equalsInteger-527 + equalsInteger (fun { no-src-span } (con { no-src-span } integer) @@ -112,18 +108,18 @@ (strict) (vardecl { no-src-span } - ifThenElse-525 + ifThenElse (all { no-src-span } - a-526 + a ({ no-src-span } type) (fun { no-src-span } (con { no-src-span } bool) (fun { no-src-span } - { no-src-span } a-526 - (fun { no-src-span } { no-src-span } a-526 { no-src-span } a-526) + { no-src-span } a + (fun { no-src-span } { no-src-span } a { no-src-span } a) ) ) ) @@ -135,20 +131,18 @@ (nonstrict) (vardecl { no-src-span } - equalsInteger-537 + equalsInteger (fun { no-src-span } (con { no-src-span } integer) (fun - { no-src-span } - (con { no-src-span } integer) - { no-src-span } Bool-528 + { no-src-span } (con { no-src-span } integer) { no-src-span } Bool ) ) ) (lam { no-src-span } - x-532 + x (con { no-src-span } integer) (let { no-src-span } @@ -156,12 +150,12 @@ (termbind { no-src-span } (strict) - (vardecl { no-src-span } x-534 (con { no-src-span } integer)) - { no-src-span } x-532 + (vardecl { no-src-span } x (con { no-src-span } integer)) + { no-src-span } x ) (lam { no-src-span } - y-533 + y (con { no-src-span } integer) (let { no-src-span } @@ -169,21 +163,21 @@ (termbind { no-src-span } (strict) - (vardecl { no-src-span } y-535 (con { no-src-span } integer)) - { no-src-span } y-533 + (vardecl { no-src-span } y (con { no-src-span } integer)) + { no-src-span } y ) (termbind { no-src-span } (strict) - (vardecl { no-src-span } b-536 (con { no-src-span } bool)) + (vardecl { no-src-span } b (con { no-src-span } bool)) [ { no-src-span } [ { no-src-span } - { no-src-span } equalsInteger-527 - { no-src-span } x-534 + { no-src-span } equalsInteger + { no-src-span } x ] - { no-src-span } y-535 + { no-src-span } y ] ) [ @@ -194,14 +188,14 @@ { no-src-span } { { no-src-span } - { no-src-span } ifThenElse-525 - { no-src-span } Bool-528 + { no-src-span } ifThenElse + { no-src-span } Bool } - { no-src-span } b-536 + { no-src-span } b ] - { no-src-span } True-529 + { no-src-span } True ] - { no-src-span } False-530 + { no-src-span } False ] ) ) @@ -213,7 +207,7 @@ (strict) (vardecl { no-src-span } - subtractInteger-519 + subtractInteger (fun { no-src-span } (con { no-src-span } integer) @@ -231,7 +225,7 @@ (nonstrict) (vardecl { no-src-span } - subtractInteger-524 + subtractInteger (fun { no-src-span } (con { no-src-span } integer) @@ -244,7 +238,7 @@ ) (lam { no-src-span } - x-520 + x (con { no-src-span } integer) (let { no-src-span } @@ -252,12 +246,12 @@ (termbind { no-src-span } (strict) - (vardecl { no-src-span } x-522 (con { no-src-span } integer)) - { no-src-span } x-520 + (vardecl { no-src-span } x (con { no-src-span } integer)) + { no-src-span } x ) (lam { no-src-span } - y-521 + y (con { no-src-span } integer) (let { no-src-span } @@ -265,17 +259,17 @@ (termbind { no-src-span } (strict) - (vardecl { no-src-span } y-523 (con { no-src-span } integer)) - { no-src-span } y-521 + (vardecl { no-src-span } y (con { no-src-span } integer)) + { no-src-span } y ) [ { no-src-span } [ { no-src-span } - { no-src-span } subtractInteger-519 - { no-src-span } x-522 + { no-src-span } subtractInteger + { no-src-span } x ] - { no-src-span } y-523 + { no-src-span } y ] ) ) @@ -290,7 +284,7 @@ (nonstrict) (vardecl { no-src-span } - fib-544 + fib (fun { no-src-span } (con { no-src-span } integer) @@ -299,7 +293,7 @@ ) (lam { no-src-span } - n-545 + n (con { no-src-span } integer) (let { test/Plugin/Debug/Spec.hs:46:15-55:72 } @@ -309,10 +303,10 @@ (strict) (vardecl { test/Plugin/Debug/Spec.hs:46:15-55:72 } - n-546 + n (con { test/Plugin/Debug/Spec.hs:46:15-55:72 } integer) ) - { test/Plugin/Debug/Spec.hs:46:15-55:72 } n-545 + { test/Plugin/Debug/Spec.hs:46:15-55:72 } n ) { { test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72 } @@ -325,15 +319,15 @@ [ { test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72 } { test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72 } - Bool_match-531 + Bool_match [ { test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72 } [ { test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72 } { test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72 } - equalsInteger-537 + equalsInteger { test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72, test/Plugin/Debug/Spec.hs:47:43-47:43 } - n-546 + n ] (con { test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72, test/Plugin/Debug/Spec.hs:47:45-47:45 } @@ -344,7 +338,7 @@ ] (all { test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72 } - dead-547 + dead ({ test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72 } type) (con @@ -355,7 +349,7 @@ } (abs { test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72 } - dead-548 + dead ({ test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72 } type) (con @@ -367,7 +361,7 @@ ] (abs { test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72 } - dead-549 + dead ({ test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72 } type) { @@ -381,15 +375,15 @@ [ { test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72, test/Plugin/Debug/Spec.hs:50:25-55:72 } { test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72, test/Plugin/Debug/Spec.hs:50:25-55:72 } - Bool_match-531 + Bool_match [ { test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72, test/Plugin/Debug/Spec.hs:50:25-55:72 } [ { test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72, test/Plugin/Debug/Spec.hs:50:25-55:72 } { test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72, test/Plugin/Debug/Spec.hs:50:25-55:72 } - equalsInteger-537 + equalsInteger { test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72, test/Plugin/Debug/Spec.hs:50:25-55:72, test/Plugin/Debug/Spec.hs:50:51-50:51 } - n-546 + n ] (con { test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72, test/Plugin/Debug/Spec.hs:50:25-55:72, test/Plugin/Debug/Spec.hs:50:53-50:53 } @@ -400,7 +394,7 @@ ] (all { test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72, test/Plugin/Debug/Spec.hs:50:25-55:72 } - dead-550 + dead ({ test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72, test/Plugin/Debug/Spec.hs:50:25-55:72 } type) (con @@ -411,7 +405,7 @@ } (abs { test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72, test/Plugin/Debug/Spec.hs:50:25-55:72 } - dead-551 + dead ({ test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72, test/Plugin/Debug/Spec.hs:50:25-55:72 } type) (con @@ -423,7 +417,7 @@ ] (abs { test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72, test/Plugin/Debug/Spec.hs:50:25-55:72 } - dead-552 + dead ({ test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72, test/Plugin/Debug/Spec.hs:50:25-55:72 } type) [ @@ -431,19 +425,19 @@ [ { test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72, test/Plugin/Debug/Spec.hs:50:25-55:72, test/Plugin/Debug/Spec.hs:53:33-55:72 } { test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72, test/Plugin/Debug/Spec.hs:50:25-55:72, test/Plugin/Debug/Spec.hs:53:33-55:72 } - addInteger-543 + addInteger [ { test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72, test/Plugin/Debug/Spec.hs:50:25-55:72, test/Plugin/Debug/Spec.hs:53:33-55:72, test/Plugin/Debug/Spec.hs:54:37-54:72 } { test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72, test/Plugin/Debug/Spec.hs:50:25-55:72, test/Plugin/Debug/Spec.hs:53:33-55:72, test/Plugin/Debug/Spec.hs:54:37-54:72 } - fib-544 + fib [ { test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72, test/Plugin/Debug/Spec.hs:50:25-55:72, test/Plugin/Debug/Spec.hs:53:33-55:72, test/Plugin/Debug/Spec.hs:54:37-54:72, test/Plugin/Debug/Spec.hs:54:42-54:71 } [ { test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72, test/Plugin/Debug/Spec.hs:50:25-55:72, test/Plugin/Debug/Spec.hs:53:33-55:72, test/Plugin/Debug/Spec.hs:54:37-54:72, test/Plugin/Debug/Spec.hs:54:42-54:71 } { test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72, test/Plugin/Debug/Spec.hs:50:25-55:72, test/Plugin/Debug/Spec.hs:53:33-55:72, test/Plugin/Debug/Spec.hs:54:37-54:72, test/Plugin/Debug/Spec.hs:54:42-54:71 } - subtractInteger-524 + subtractInteger { test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72, test/Plugin/Debug/Spec.hs:50:25-55:72, test/Plugin/Debug/Spec.hs:53:33-55:72, test/Plugin/Debug/Spec.hs:54:37-54:72, test/Plugin/Debug/Spec.hs:54:42-54:71, test/Plugin/Debug/Spec.hs:54:68-54:68 } - n-546 + n ] (con { test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72, test/Plugin/Debug/Spec.hs:50:25-55:72, test/Plugin/Debug/Spec.hs:53:33-55:72, test/Plugin/Debug/Spec.hs:54:37-54:72, test/Plugin/Debug/Spec.hs:54:42-54:71, test/Plugin/Debug/Spec.hs:54:70-54:70 } @@ -456,15 +450,15 @@ [ { test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72, test/Plugin/Debug/Spec.hs:50:25-55:72, test/Plugin/Debug/Spec.hs:53:33-55:72, test/Plugin/Debug/Spec.hs:55:37-55:72 } { test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72, test/Plugin/Debug/Spec.hs:50:25-55:72, test/Plugin/Debug/Spec.hs:53:33-55:72, test/Plugin/Debug/Spec.hs:55:37-55:72 } - fib-544 + fib [ { test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72, test/Plugin/Debug/Spec.hs:50:25-55:72, test/Plugin/Debug/Spec.hs:53:33-55:72, test/Plugin/Debug/Spec.hs:55:37-55:72, test/Plugin/Debug/Spec.hs:55:42-55:71 } [ { test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72, test/Plugin/Debug/Spec.hs:50:25-55:72, test/Plugin/Debug/Spec.hs:53:33-55:72, test/Plugin/Debug/Spec.hs:55:37-55:72, test/Plugin/Debug/Spec.hs:55:42-55:71 } { test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72, test/Plugin/Debug/Spec.hs:50:25-55:72, test/Plugin/Debug/Spec.hs:53:33-55:72, test/Plugin/Debug/Spec.hs:55:37-55:72, test/Plugin/Debug/Spec.hs:55:42-55:71 } - subtractInteger-524 + subtractInteger { test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72, test/Plugin/Debug/Spec.hs:50:25-55:72, test/Plugin/Debug/Spec.hs:53:33-55:72, test/Plugin/Debug/Spec.hs:55:37-55:72, test/Plugin/Debug/Spec.hs:55:42-55:71, test/Plugin/Debug/Spec.hs:55:68-55:68 } - n-546 + n ] (con { test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72, test/Plugin/Debug/Spec.hs:50:25-55:72, test/Plugin/Debug/Spec.hs:53:33-55:72, test/Plugin/Debug/Spec.hs:55:37-55:72, test/Plugin/Debug/Spec.hs:55:42-55:71, test/Plugin/Debug/Spec.hs:55:70-55:70 } @@ -478,28 +472,28 @@ ] (all { test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72, test/Plugin/Debug/Spec.hs:50:25-55:72 } - dead-553 + dead ({ test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72, test/Plugin/Debug/Spec.hs:50:25-55:72 } type) { test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72, test/Plugin/Debug/Spec.hs:50:25-55:72 } - dead-553 + dead ) } ) ] (all { test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72 } - dead-554 + dead ({ test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72 } type) { test/Plugin/Debug/Spec.hs:46:15-55:72, test/Plugin/Debug/Spec.hs:47:17-55:72 } - dead-554 + dead ) } ) ) ) - { test/Plugin/Debug/Spec.hs:45:9-57:9 } fib-544 + { test/Plugin/Debug/Spec.hs:45:9-57:9 } fib ) ) ) \ No newline at end of file diff --git a/plutus-tx-plugin/test/Plugin/Debug/9.6/letFun.pir.golden b/plutus-tx-plugin/test/Plugin/Debug/9.6/letFun.pir.golden index e3ff78c1481..4c61eb0073f 100644 --- a/plutus-tx-plugin/test/Plugin/Debug/9.6/letFun.pir.golden +++ b/plutus-tx-plugin/test/Plugin/Debug/9.6/letFun.pir.golden @@ -8,11 +8,11 @@ { no-src-span } (datatype { no-src-span } - (tyvardecl { no-src-span } Bool-445 ({ no-src-span } type)) + (tyvardecl { no-src-span } Bool ({ no-src-span } type)) - Bool_match-448 - (vardecl { no-src-span } True-446 { no-src-span } Bool-445) - (vardecl { no-src-span } False-447 { no-src-span } Bool-445) + Bool_match + (vardecl { no-src-span } True { no-src-span } Bool) + (vardecl { no-src-span } False { no-src-span } Bool) ) ) (termbind @@ -20,7 +20,7 @@ (strict) (vardecl { no-src-span } - equalsInteger-444 + equalsInteger (fun { no-src-span } (con { no-src-span } integer) @@ -38,18 +38,18 @@ (strict) (vardecl { no-src-span } - ifThenElse-442 + ifThenElse (all { no-src-span } - a-443 + a ({ no-src-span } type) (fun { no-src-span } (con { no-src-span } bool) (fun { no-src-span } - { no-src-span } a-443 - (fun { no-src-span } { no-src-span } a-443 { no-src-span } a-443) + { no-src-span } a + (fun { no-src-span } { no-src-span } a { no-src-span } a) ) ) ) @@ -61,20 +61,18 @@ (nonstrict) (vardecl { no-src-span } - equalsInteger-454 + equalsInteger (fun { no-src-span } (con { no-src-span } integer) (fun - { no-src-span } - (con { no-src-span } integer) - { no-src-span } Bool-445 + { no-src-span } (con { no-src-span } integer) { no-src-span } Bool ) ) ) (lam { no-src-span } - x-449 + x (con { no-src-span } integer) (let { no-src-span } @@ -82,12 +80,12 @@ (termbind { no-src-span } (strict) - (vardecl { no-src-span } x-451 (con { no-src-span } integer)) - { no-src-span } x-449 + (vardecl { no-src-span } x (con { no-src-span } integer)) + { no-src-span } x ) (lam { no-src-span } - y-450 + y (con { no-src-span } integer) (let { no-src-span } @@ -95,21 +93,21 @@ (termbind { no-src-span } (strict) - (vardecl { no-src-span } y-452 (con { no-src-span } integer)) - { no-src-span } y-450 + (vardecl { no-src-span } y (con { no-src-span } integer)) + { no-src-span } y ) (termbind { no-src-span } (strict) - (vardecl { no-src-span } b-453 (con { no-src-span } bool)) + (vardecl { no-src-span } b (con { no-src-span } bool)) [ { no-src-span } [ { no-src-span } - { no-src-span } equalsInteger-444 - { no-src-span } x-451 + { no-src-span } equalsInteger + { no-src-span } x ] - { no-src-span } y-452 + { no-src-span } y ] ) [ @@ -120,14 +118,14 @@ { no-src-span } { { no-src-span } - { no-src-span } ifThenElse-442 - { no-src-span } Bool-445 + { no-src-span } ifThenElse + { no-src-span } Bool } - { no-src-span } b-453 + { no-src-span } b ] - { no-src-span } True-446 + { no-src-span } True ] - { no-src-span } False-447 + { no-src-span } False ] ) ) @@ -136,7 +134,7 @@ ) (lam { no-src-span } - ds-455 + ds (con { no-src-span } integer) (let { test/Plugin/Debug/Spec.hs:38:9-38:87 } @@ -146,14 +144,14 @@ (strict) (vardecl { test/Plugin/Debug/Spec.hs:38:9-38:87 } - ds-457 + ds (con { test/Plugin/Debug/Spec.hs:38:9-38:87 } integer) ) - { test/Plugin/Debug/Spec.hs:38:9-38:87 } ds-455 + { test/Plugin/Debug/Spec.hs:38:9-38:87 } ds ) (lam { no-src-span } - ds-456 + ds (con { no-src-span } integer) (let { test/Plugin/Debug/Spec.hs:38:9-38:87 } @@ -163,22 +161,22 @@ (strict) (vardecl { test/Plugin/Debug/Spec.hs:38:9-38:87 } - ds-458 + ds (con { test/Plugin/Debug/Spec.hs:38:9-38:87 } integer) ) - { test/Plugin/Debug/Spec.hs:38:9-38:87 } ds-456 + { test/Plugin/Debug/Spec.hs:38:9-38:87 } ds ) [ { test/Plugin/Debug/Spec.hs:38:9-38:87, test/Plugin/Debug/Spec.hs:38:44-38:86, test/Plugin/Debug/Spec.hs:38:54-38:79 } [ { test/Plugin/Debug/Spec.hs:38:9-38:87, test/Plugin/Debug/Spec.hs:38:44-38:86, test/Plugin/Debug/Spec.hs:38:54-38:79 } { test/Plugin/Debug/Spec.hs:38:9-38:87, test/Plugin/Debug/Spec.hs:38:44-38:86, test/Plugin/Debug/Spec.hs:38:54-38:79 } - equalsInteger-454 + equalsInteger { test/Plugin/Debug/Spec.hs:38:9-38:87, test/Plugin/Debug/Spec.hs:38:44-38:86, test/Plugin/Debug/Spec.hs:38:54-38:79, test/Plugin/Debug/Spec.hs:38:77-38:77 } - ds-457 + ds ] { test/Plugin/Debug/Spec.hs:38:9-38:87, test/Plugin/Debug/Spec.hs:38:44-38:86, test/Plugin/Debug/Spec.hs:38:54-38:79, test/Plugin/Debug/Spec.hs:38:79-38:79 } - ds-458 + ds ] ) ) diff --git a/plutus-tx-plugin/test/Plugin/Debug/Spec.hs b/plutus-tx-plugin/test/Plugin/Debug/Spec.hs index 250d29daa59..e389a31eb86 100644 --- a/plutus-tx-plugin/test/Plugin/Debug/Spec.hs +++ b/plutus-tx-plugin/test/Plugin/Debug/Spec.hs @@ -29,7 +29,7 @@ debug = , goldenPirBy config "fib" fib ] where - config = PrettyConfigClassic prettyConfigName True + config = PrettyConfigClassic prettyConfigNameSimple True letFun :: CompiledCode (Integer -> Integer -> Bool) letFun =