From 1423699580b68ceacb1943133e464340c6b56edf Mon Sep 17 00:00:00 2001 From: RSoulatIOHK Date: Fri, 12 Jul 2024 09:34:53 +0200 Subject: [PATCH] fix: types in defaultConstitution More descriptive type names in the defaultConstitution Co-authored-by: Nikolaos Bezirgiannis <329939+bezirg@users.noreply.github.com> --- .../data/defaultConstitution.json | 67 +- .../Constitution/Config/Instance/FromJSON.hs | 35 +- .../Validator/GoldenTests/sorted.pir.golden | 9650 +++++++++-------- .../Validator/GoldenTests/sorted.uplc.golden | 1573 +-- .../Validator/GoldenTests/unsorted.pir.golden | 9595 ++++++++-------- .../GoldenTests/unsorted.uplc.golden | 1147 +- 6 files changed, 11065 insertions(+), 11002 deletions(-) diff --git a/cardano-constitution/data/defaultConstitution.json b/cardano-constitution/data/defaultConstitution.json index 8146907333d..e44abdfc55a 100644 --- a/cardano-constitution/data/defaultConstitution.json +++ b/cardano-constitution/data/defaultConstitution.json @@ -1,6 +1,6 @@ { "0": { - "type": "integer", + "type": "coin", "predicates": [ { "minValue": 30, @@ -19,7 +19,7 @@ }, "1": { - "type": "integer", + "type": "coin", "predicates": [ { "minValue": 100000, @@ -36,7 +36,6 @@ ], "$comment": "txFeeFixed" }, - "10": { "type": "unit_interval", "predicates": [ @@ -80,7 +79,7 @@ }, "16": { - "type": "integer", + "type": "coin", "predicates": [ { "minValue": 0, @@ -94,7 +93,7 @@ }, "17": { - "type": "integer", + "type": "coin", "predicates": [ { "minValue": 3000, @@ -115,9 +114,12 @@ ], "$comment": "utxoCostPerByte" }, - + "18": { + "type": "costMdls", + "$comment": "costmodels for all plutus versions" + }, "19[0]": { - "type": "unit_interval", + "type": "nonnegative_interval", "predicates": [ { "maxValue": { "numerator": 2000, "denominator": 10000 }, @@ -132,7 +134,7 @@ }, "19[1]": { - "type": "unit_interval", + "type": "nonnegative_interval", "predicates": [ { "maxValue": { "numerator": 2000, "denominator": 10000000 }, @@ -147,7 +149,7 @@ }, "2": { - "type": "integer", + "type": "uint.size4", "predicates": [ { "maxValue": 122880, @@ -162,7 +164,7 @@ }, "20[0]": { - "type": "integer", + "type": "uint", "predicates": [ { "maxValue": 40000000, @@ -178,7 +180,7 @@ }, "20[1]": { - "type": "integer", + "type": "uint", "predicates": [ { "maxValue": 15000000000, @@ -194,7 +196,7 @@ }, "21[0]": { - "type": "integer", + "type": "uint", "predicates": [ { "maxValue": 120000000, @@ -209,7 +211,7 @@ }, "21[1]": { - "type": "integer", + "type": "uint", "predicates": [ { "maxValue": 40000000000, @@ -224,7 +226,7 @@ }, "22": { - "type": "integer", + "type": "uint.size4", "predicates": [ { "maxValue": 12288, @@ -240,7 +242,7 @@ }, "23": { - "type": "integer", + "type": "uint.size2", "predicates": [ { "minValue": 100, @@ -264,7 +266,7 @@ }, "24": { - "type": "integer", + "type": "uint.size2", "predicates": [ { "minValue": 1, @@ -604,7 +606,7 @@ }, "27": { - "type": "integer", + "type": "uint.size2", "predicates": [ { "minValue": 0, @@ -623,7 +625,7 @@ }, "28": { - "type": "integer", + "type": "epoch_interval", "predicates": [ { "notEqual": 0, @@ -646,7 +648,7 @@ }, "29": { - "type": "integer", + "type": "epoch_interval", "predicates": [ { "minValue": 1, @@ -661,7 +663,7 @@ }, "3": { - "type": "integer", + "type": "uint.size4", "predicates": [ { "maxValue": 32768, @@ -676,7 +678,7 @@ }, "30": { - "type": "integer", + "type": "coin", "predicates": [ { "minValue": 0, @@ -695,7 +697,7 @@ }, "31": { - "type": "integer", + "type": "coin", "predicates": [ { "minValue": 0, @@ -714,7 +716,7 @@ }, "32": { - "type": "integer", + "type": "epoch_interval", "predicates": [ { "minValue": 13, @@ -733,7 +735,7 @@ }, "33": { - "type": "unit_interval", + "type": "nonnegative_interval", "predicates": [ { "maxValue": { "numerator": 1000, "denominator": 1 }, @@ -748,7 +750,7 @@ }, "4": { - "type": "integer", + "type": "uint.size2", "predicates": [ { "maxValue": 5000, @@ -763,7 +765,7 @@ }, "5": { - "type": "integer", + "type": "coin", "predicates": [ { "minValue": 1000000, @@ -782,7 +784,7 @@ }, "6": { - "type": "integer", + "type": "coin", "predicates": [ { "minValue": 250000000, @@ -801,7 +803,7 @@ }, "7": { - "type": "integer", + "type": "epoch_interval", "predicates": [ { "minValue": 0, @@ -812,7 +814,7 @@ }, "8": { - "type": "integer", + "type": "uint.size2", "predicates": [ { "minValue": 250, @@ -835,7 +837,7 @@ }, "9": { - "type": "unit_interval", + "type": "nonnegative_interval", "predicates": [ { "minValue": { "numerator": 1, "denominator": 10 }, @@ -851,10 +853,5 @@ } ], "$comment": "poolPledgeInfluence" - }, - - "18": { - "type": "any", - "$comment": "costmodels for all plutus versions" } } diff --git a/cardano-constitution/src/Cardano/Constitution/Config/Instance/FromJSON.hs b/cardano-constitution/src/Cardano/Constitution/Config/Instance/FromJSON.hs index c5d9dac9b80..87dd8721d06 100644 --- a/cardano-constitution/src/Cardano/Constitution/Config/Instance/FromJSON.hs +++ b/cardano-constitution/src/Cardano/Constitution/Config/Instance/FromJSON.hs @@ -115,16 +115,33 @@ parseParamValue = \case -- if we parsed a sub-index, treat the param value as a `M.singleton subIndex value` Just subIndex -> fmap (RawParamList . M.singleton subIndex) . parseTypedParamValue where + parseTypedParamValue :: Value -> Parser RawParamValue parseTypedParamValue = withObject "RawParamValue" $ \o -> do - String ty <- o .: typeKey - case ty of - "integer" -> RawParamInteger <$> (o .: predicatesKey) - -- NOTE: even if the Tx.Ratio.Rational constructor is not exposed, the 2 arguments to the constructor - -- will be normalized (co-primed) when Tx.lift is called on them. - -- SO there is no speed benefit to statically co-prime them ourselves for efficiency. - "unit_interval" -> RawParamRational <$> (o .: predicatesKey) - "any" -> pure RawParamAny - _ -> fail "invalid type tag" + ty <- o .: typeKey + parseSynonymType ty o + + -- the base types we support + parseBaseType :: Key -> Object -> Parser RawParamValue + parseBaseType ty o = case ty of + "integer" -> RawParamInteger <$> (o .: predicatesKey) + -- NOTE: even if the Tx.Ratio.Rational constructor is not exposed, the 2 arguments to the constructor + -- will be normalized (co-primed) when Tx.lift is called on them. + -- SO there is no speed benefit to statically co-prime them ourselves for efficiency. + "rational" -> RawParamRational <$> (o .: predicatesKey) + "any" -> pure RawParamAny + _ -> fail "invalid type tag" + + -- synonyms to ease the transition from cddl + parseSynonymType = \case + "coin" -> parseBaseType "integer" + "uint.size4" -> parseBaseType "integer" + "uint.size2" -> parseBaseType "integer" + "uint" -> parseBaseType "integer" -- For ex units + "epoch_interval" -> parseBaseType "integer" -- Rename of uint.size4 + "unit_interval" -> parseBaseType "rational" + "nonnegative_interval" -> parseBaseType "rational" + "costMdls" -> parseBaseType "any" + x -> parseBaseType x -- didn't find synonym, try as basetype -- | It is like an `mappend` when both inputs are ParamList's. mergeParamValues :: MonadFail m => RawParamValue -> RawParamValue -> m RawParamValue 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 170fe68030c..48a4730d258 100644 --- a/cardano-constitution/test/Cardano/Constitution/Validator/GoldenTests/sorted.pir.golden +++ b/cardano-constitution/test/Cardano/Constitution/Validator/GoldenTests/sorted.pir.golden @@ -1,5716 +1,5720 @@ program 1.1.0 (let - data Ordering-73055 | Ordering_match-73059 where - EQ-73056 : Ordering-73055 - GT-73057 : Ordering-73055 - LT-73058 : Ordering-73055 - data Bool-73046 | Bool_match-73049 where - True-73047 : Bool-73046 - False-73048 : Bool-73046 - data (Ord-73060 :: * -> *) a-73063 | Ord_match-73062 where - CConsOrd-73061 : - (\a-73064 -> a-73064 -> a-73064 -> Bool-73046) a-73063 -> - (a-73063 -> a-73063 -> Ordering-73055) -> - (a-73063 -> a-73063 -> Bool-73046) -> - (a-73063 -> a-73063 -> Bool-73046) -> - (a-73063 -> a-73063 -> Bool-73046) -> - (a-73063 -> a-73063 -> Bool-73046) -> - (a-73063 -> a-73063 -> a-73063) -> - (a-73063 -> a-73063 -> a-73063) -> - Ord-73060 a-73063 - data PredKey-73050 | PredKey_match-73054 where - MaxValue-73051 : PredKey-73050 - MinValue-73052 : PredKey-73050 - NotEqual-73053 : PredKey-73050 - data (Tuple2-73031 :: * -> * -> *) a-73034 - b-73035 | Tuple2_match-73033 where - Tuple2-73032 : a-73034 -> b-73035 -> Tuple2-73031 a-73034 b-73035 + 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 in letrec - data (List-73026 :: * -> *) a-73030 | List_match-73029 where - Nil-73027 : List-73026 a-73030 - Cons-73028 : a-73030 -> List-73026 a-73030 -> List-73026 a-73030 + 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 in let - !validatePreds-73196 : - all a-73197. - Ord-73060 a-73197 -> - (\v-73198 -> - List-73026 (Tuple2-73031 PredKey-73050 (List-73026 v-73198))) - a-73197 -> - a-73197 -> - Bool-73046 - = /\a-73129 -> - \(`$dOrd`-73130 : Ord-73060 a-73129) - (ds-73131 : - (\v-73132 -> - List-73026 (Tuple2-73031 PredKey-73050 (List-73026 v-73132))) - a-73129) - (ds-73133 : a-73129) -> + !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) -> letrec - !go-73134 : - List-73026 (Tuple2-73031 PredKey-73050 (List-73026 a-73129)) -> - Bool-73046 - = \(ds-73135 : - List-73026 - (Tuple2-73031 PredKey-73050 (List-73026 a-73129))) -> - List_match-73029 - {Tuple2-73031 PredKey-73050 (List-73026 a-73129)} - ds-73135 - {all dead-73136. Bool-73046} - (/\dead-73137 -> True-73047) - (\(x-73138 : - Tuple2-73031 PredKey-73050 (List-73026 a-73129)) - (xs-73139 : - List-73026 - (Tuple2-73031 - PredKey-73050 - (List-73026 a-73129))) -> - /\dead-73140 -> - Tuple2_match-73033 - {PredKey-73050} - {List-73026 a-73129} - x-73138 - {Bool-73046} - (\(predKey-73141 : PredKey-73050) - (expectedPredValues-73142 : - List-73026 a-73129) -> + !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) -> let - !meaning-73182 : - a-73129 -> a-73129 -> Bool-73046 - = PredKey_match-73054 - predKey-73141 - {all dead-73143. - a-73129 -> a-73129 -> Bool-73046} - (/\dead-73144 -> - Ord_match-73062 - {a-73129} - `$dOrd`-73130 - {a-73129 -> a-73129 -> Bool-73046} - (\(v-73145 : - (\a-73146 -> - a-73146 -> - a-73146 -> - Bool-73046) - a-73129) - (v-73147 : - a-73129 -> - a-73129 -> - Ordering-73055) - (v-73148 : - a-73129 -> - a-73129 -> - Bool-73046) - (v-73149 : - a-73129 -> - a-73129 -> - Bool-73046) - (v-73150 : - a-73129 -> - a-73129 -> - Bool-73046) - (v-73151 : - a-73129 -> - a-73129 -> - Bool-73046) - (v-73152 : - a-73129 -> a-73129 -> a-73129) - (v-73153 : - a-73129 -> - a-73129 -> - a-73129) -> - v-73151)) - (/\dead-73154 -> - Ord_match-73062 - {a-73129} - `$dOrd`-73130 - {a-73129 -> a-73129 -> Bool-73046} - (\(v-73155 : - (\a-73156 -> - a-73156 -> - a-73156 -> - Bool-73046) - a-73129) - (v-73157 : - a-73129 -> - a-73129 -> - Ordering-73055) - (v-73158 : - a-73129 -> - a-73129 -> - Bool-73046) - (v-73159 : - a-73129 -> - a-73129 -> - Bool-73046) - (v-73160 : - a-73129 -> - a-73129 -> - Bool-73046) - (v-73161 : - a-73129 -> - a-73129 -> - Bool-73046) - (v-73162 : - a-73129 -> a-73129 -> a-73129) - (v-73163 : - a-73129 -> - a-73129 -> - a-73129) -> - v-73159)) - (/\dead-73164 -> - \(x-73165 : a-73129) - (y-73166 : a-73129) -> - Bool_match-73049 - (Ord_match-73062 - {a-73129} - `$dOrd`-73130 - {(\a-73167 -> - a-73167 -> - a-73167 -> - Bool-73046) - a-73129} - (\(v-73168 : - (\a-73169 -> - a-73169 -> - a-73169 -> - Bool-73046) - a-73129) - (v-73170 : - a-73129 -> - a-73129 -> - Ordering-73055) - (v-73171 : - a-73129 -> - a-73129 -> - Bool-73046) - (v-73172 : - a-73129 -> - a-73129 -> - Bool-73046) - (v-73173 : - a-73129 -> - a-73129 -> - Bool-73046) - (v-73174 : - a-73129 -> - a-73129 -> - Bool-73046) - (v-73175 : - a-73129 -> - a-73129 -> - a-73129) - (v-73176 : - a-73129 -> - a-73129 -> - a-73129) -> - v-73168) - x-73165 - y-73166) - {all dead-73177. Bool-73046} - (/\dead-73178 -> False-73048) - (/\dead-73179 -> True-73047) - {all dead-73180. dead-73180}) - {all dead-73181. dead-73181} + !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} in letrec - !go-73183 : List-73026 a-73129 -> Bool-73046 - = \(ds-73184 : List-73026 a-73129) -> - List_match-73029 - {a-73129} - ds-73184 - {all dead-73185. Bool-73046} - (/\dead-73186 -> go-73134 xs-73139) - (\(x-73187 : a-73129) - (xs-73188 : List-73026 a-73129) -> - /\dead-73189 -> - Bool_match-73049 - (meaning-73182 - x-73187 - ds-73133) - {all dead-73190. Bool-73046} - (/\dead-73191 -> - go-73183 xs-73188) - (/\dead-73192 -> False-73048) - {all dead-73193. dead-73193}) - {all dead-73194. dead-73194} + !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} in - go-73183 expectedPredValues-73142)) - {all dead-73195. dead-73195} + go-73259 expectedPredValues-73218)) + {all dead-73271. dead-73271} in - go-73134 ds-73131 - !`$fOrdInteger_$ccompare`-73115 : integer -> integer -> Ordering-73055 - = \(eta-73105 : integer) (eta-73106 : integer) -> - Bool_match-73049 + go-73210 ds-73207 + !`$fOrdInteger_$ccompare`-73191 : integer -> integer -> Ordering-73134 + = \(eta-73181 : integer) (eta-73182 : integer) -> + Bool_match-73125 (ifThenElse - {Bool-73046} - (equalsInteger eta-73105 eta-73106) - True-73047 - False-73048) - {all dead-73107. Ordering-73055} - (/\dead-73108 -> EQ-73056) - (/\dead-73109 -> - Bool_match-73049 + {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-73046} - (lessThanEqualsInteger eta-73105 eta-73106) - True-73047 - False-73048) - {all dead-73110. Ordering-73055} - (/\dead-73111 -> LT-73058) - (/\dead-73112 -> GT-73057) - {all dead-73113. dead-73113}) - {all dead-73114. dead-73114} - data Rational-73065 | Rational_match-73067 where - Rational-73066 : integer -> integer -> Rational-73065 - !`$fOrdRational0_$c<=`-73104 : - Rational-73065 -> Rational-73065 -> Bool-73046 - = \(ds-73098 : Rational-73065) (ds-73099 : Rational-73065) -> - Rational_match-73067 - ds-73098 - {Bool-73046} - (\(n-73100 : integer) (d-73101 : integer) -> - Rational_match-73067 - ds-73099 - {Bool-73046} - (\(n'-73102 : integer) (d'-73103 : integer) -> + {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) -> ifThenElse - {Bool-73046} + {Bool-73122} (lessThanEqualsInteger - (multiplyInteger n-73100 d'-73103) - (multiplyInteger n'-73102 d-73101)) - True-73047 - False-73048)) + (multiplyInteger n-73176 d'-73179) + (multiplyInteger n'-73178 d-73177)) + True-73123 + False-73124)) in letrec - !euclid-73079 : integer -> integer -> integer - = \(x-73080 : integer) (y-73081 : integer) -> - Bool_match-73049 + !euclid-73155 : integer -> integer -> integer + = \(x-73156 : integer) (y-73157 : integer) -> + Bool_match-73125 (ifThenElse - {Bool-73046} - (equalsInteger 0 y-73081) - True-73047 - False-73048) - {all dead-73082. integer} - (/\dead-73083 -> x-73080) - (/\dead-73084 -> euclid-73079 y-73081 (modInteger x-73080 y-73081)) - {all dead-73085. dead-73085} + {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} in letrec - !unsafeRatio-73086 : integer -> integer -> Rational-73065 - = \(n-73087 : integer) (d-73088 : integer) -> - Bool_match-73049 + !unsafeRatio-73162 : integer -> integer -> Rational-73144 + = \(n-73163 : integer) (d-73164 : integer) -> + Bool_match-73125 (ifThenElse - {Bool-73046} - (equalsInteger 0 d-73088) - True-73047 - False-73048) - {all dead-73089. Rational-73065} - (/\dead-73090 -> error {Rational-73065}) - (/\dead-73091 -> - Bool_match-73049 + {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-73046} - (lessThanInteger d-73088 0) - True-73047 - False-73048) - {all dead-73092. Rational-73065} - (/\dead-73093 -> - unsafeRatio-73086 - (subtractInteger 0 n-73087) - (subtractInteger 0 d-73088)) - (/\dead-73094 -> + {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 -> let - !gcd'-73095 : integer = euclid-73079 n-73087 d-73088 + !gcd'-73171 : integer = euclid-73155 n-73163 d-73164 in - Rational-73066 - (quotientInteger n-73087 gcd'-73095) - (quotientInteger d-73088 gcd'-73095)) - {all dead-73096. dead-73096}) - {all dead-73097. dead-73097} - in - let - data Unit-73076 | Unit_match-73078 where - Unit-73077 : Unit-73076 + Rational-73145 + (quotientInteger n-73163 gcd'-73171) + (quotientInteger d-73164 gcd'-73171)) + {all dead-73172. dead-73172}) + {all dead-73173. dead-73173} in letrec - data ParamValue-73068 | ParamValue_match-73073 where - ParamAny-73069 : ParamValue-73068 - ParamInteger-73070 : - (\v-73074 -> - List-73026 (Tuple2-73031 PredKey-73050 (List-73026 v-73074))) + 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-73068 - ParamList-73071 : List-73026 ParamValue-73068 -> ParamValue-73068 - ParamRational-73072 : - (\v-73075 -> - List-73026 (Tuple2-73031 PredKey-73050 (List-73026 v-73075))) - Rational-73065 -> - ParamValue-73068 + 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 + in + let + data Unit-73126 | Unit_match-73128 where + Unit-73127 : Unit-73126 in letrec - !validateParamValue-73116 : ParamValue-73068 -> data -> Bool-73046 - = \(eta-73117 : ParamValue-73068) (eta-73118 : data) -> + !validateParamValue-73192 : ParamValue-73147 -> data -> Bool-73122 + = \(eta-73193 : ParamValue-73147) (eta-73194 : data) -> let - ~bl-73277 : list data = unListData eta-73118 - ~bl'-73278 : list data = tailList {data} bl-73277 + ~bl-73353 : list data = unListData eta-73194 + ~bl'-73354 : list data = tailList {data} bl-73353 in - ParamValue_match-73073 - eta-73117 - {all dead-73199. Bool-73046} - (/\dead-73200 -> True-73047) - (\(preds-73201 : - (\v-73202 -> - List-73026 - (Tuple2-73031 PredKey-73050 (List-73026 v-73202))) + 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-73203 -> - validatePreds-73196 + /\dead-73279 -> + validatePreds-73272 {integer} - (CConsOrd-73061 + (CConsOrd-73140 {integer} - (\(x-73204 : integer) (y-73205 : integer) -> + (\(x-73280 : integer) (y-73281 : integer) -> ifThenElse - {Bool-73046} - (equalsInteger x-73204 y-73205) - True-73047 - False-73048) - `$fOrdInteger_$ccompare`-73115 - (\(x-73206 : integer) (y-73207 : integer) -> + {Bool-73122} + (equalsInteger x-73280 y-73281) + True-73123 + False-73124) + `$fOrdInteger_$ccompare`-73191 + (\(x-73282 : integer) (y-73283 : integer) -> ifThenElse - {Bool-73046} - (lessThanInteger x-73206 y-73207) - True-73047 - False-73048) - (\(x-73208 : integer) (y-73209 : integer) -> + {Bool-73122} + (lessThanInteger x-73282 y-73283) + True-73123 + False-73124) + (\(x-73284 : integer) (y-73285 : integer) -> ifThenElse - {Bool-73046} - (lessThanEqualsInteger x-73208 y-73209) - True-73047 - False-73048) - (\(x-73210 : integer) (y-73211 : integer) -> + {Bool-73122} + (lessThanEqualsInteger x-73284 y-73285) + True-73123 + False-73124) + (\(x-73286 : integer) (y-73287 : integer) -> ifThenElse - {Bool-73046} - (lessThanEqualsInteger x-73210 y-73211) - False-73048 - True-73047) - (\(x-73212 : integer) (y-73213 : integer) -> + {Bool-73122} + (lessThanEqualsInteger x-73286 y-73287) + False-73124 + True-73123) + (\(x-73288 : integer) (y-73289 : integer) -> ifThenElse - {Bool-73046} - (lessThanInteger x-73212 y-73213) - False-73048 - True-73047) - (\(x-73214 : integer) (y-73215 : integer) -> - Bool_match-73049 + {Bool-73122} + (lessThanInteger x-73288 y-73289) + False-73124 + True-73123) + (\(x-73290 : integer) (y-73291 : integer) -> + Bool_match-73125 (ifThenElse - {Bool-73046} - (lessThanEqualsInteger x-73214 y-73215) - True-73047 - False-73048) - {all dead-73216. integer} - (/\dead-73217 -> y-73215) - (/\dead-73218 -> x-73214) - {all dead-73219. dead-73219}) - (\(x-73220 : integer) (y-73221 : integer) -> - Bool_match-73049 + {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 (ifThenElse - {Bool-73046} - (lessThanEqualsInteger x-73220 y-73221) - True-73047 - False-73048) - {all dead-73222. integer} - (/\dead-73223 -> x-73220) - (/\dead-73224 -> y-73221) - {all dead-73225. dead-73225})) - preds-73201 - (unIData eta-73118)) - (\(paramValues-73226 : List-73026 ParamValue-73068) -> - /\dead-73227 -> - validateParamValues-73119 - paramValues-73226 - (unListData eta-73118)) - (\(preds-73228 : - (\v-73229 -> - List-73026 - (Tuple2-73031 PredKey-73050 (List-73026 v-73229))) - Rational-73065) -> - /\dead-73230 -> - validatePreds-73196 - {Rational-73065} - (CConsOrd-73061 - {Rational-73065} - (\(ds-73231 : Rational-73065) - (ds-73232 : Rational-73065) -> - Rational_match-73067 - ds-73231 - {Bool-73046} - (\(n-73233 : integer) (d-73234 : integer) -> - Rational_match-73067 - ds-73232 - {Bool-73046} - (\(n'-73235 : integer) (d'-73236 : integer) -> - Bool_match-73049 + {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 (ifThenElse - {Bool-73046} - (equalsInteger n-73233 n'-73235) - True-73047 - False-73048) - {all dead-73237. Bool-73046} - (/\dead-73238 -> + {Bool-73122} + (equalsInteger n-73309 n'-73311) + True-73123 + False-73124) + {all dead-73313. Bool-73122} + (/\dead-73314 -> ifThenElse - {Bool-73046} - (equalsInteger d-73234 d'-73236) - True-73047 - False-73048) - (/\dead-73239 -> False-73048) - {all dead-73240. dead-73240}))) - (\(ds-73241 : Rational-73065) - (ds-73242 : Rational-73065) -> - Rational_match-73067 - ds-73241 - {Ordering-73055} - (\(n-73243 : integer) (d-73244 : integer) -> - Rational_match-73067 - ds-73242 - {Ordering-73055} - (\(n'-73245 : integer) (d'-73246 : integer) -> - `$fOrdInteger_$ccompare`-73115 - (multiplyInteger n-73243 d'-73246) - (multiplyInteger n'-73245 d-73244)))) - (\(ds-73247 : Rational-73065) - (ds-73248 : Rational-73065) -> - Rational_match-73067 - ds-73247 - {Bool-73046} - (\(n-73249 : integer) (d-73250 : integer) -> - Rational_match-73067 - ds-73248 - {Bool-73046} - (\(n'-73251 : integer) (d'-73252 : integer) -> + {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) -> ifThenElse - {Bool-73046} + {Bool-73122} (lessThanInteger - (multiplyInteger n-73249 d'-73252) - (multiplyInteger n'-73251 d-73250)) - True-73047 - False-73048))) - `$fOrdRational0_$c<=`-73104 - (\(ds-73253 : Rational-73065) - (ds-73254 : Rational-73065) -> - Rational_match-73067 - ds-73253 - {Bool-73046} - (\(n-73255 : integer) (d-73256 : integer) -> - Rational_match-73067 - ds-73254 - {Bool-73046} - (\(n'-73257 : integer) (d'-73258 : integer) -> + (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) -> ifThenElse - {Bool-73046} + {Bool-73122} (lessThanEqualsInteger - (multiplyInteger n-73255 d'-73258) - (multiplyInteger n'-73257 d-73256)) - False-73048 - True-73047))) - (\(ds-73259 : Rational-73065) - (ds-73260 : Rational-73065) -> - Rational_match-73067 - ds-73259 - {Bool-73046} - (\(n-73261 : integer) (d-73262 : integer) -> - Rational_match-73067 - ds-73260 - {Bool-73046} - (\(n'-73263 : integer) (d'-73264 : integer) -> + (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) -> ifThenElse - {Bool-73046} + {Bool-73122} (lessThanInteger - (multiplyInteger n-73261 d'-73264) - (multiplyInteger n'-73263 d-73262)) - False-73048 - True-73047))) - (\(x-73265 : Rational-73065) (y-73266 : Rational-73065) -> - Bool_match-73049 - (`$fOrdRational0_$c<=`-73104 x-73265 y-73266) - {all dead-73267. Rational-73065} - (/\dead-73268 -> y-73266) - (/\dead-73269 -> x-73265) - {all dead-73270. dead-73270}) - (\(x-73271 : Rational-73065) (y-73272 : Rational-73065) -> - Bool_match-73049 - (`$fOrdRational0_$c<=`-73104 x-73271 y-73272) - {all dead-73273. Rational-73065} - (/\dead-73274 -> x-73271) - (/\dead-73275 -> y-73272) - {all dead-73276. dead-73276})) - preds-73228 + (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 (ifThenElse - {Unit-73076 -> Rational-73065} - (nullList {data} (tailList {data} bl'-73278)) - (\(ds-73279 : Unit-73076) -> - unsafeRatio-73086 - (unIData (headList {data} bl-73277)) - (unIData (headList {data} bl'-73278))) - (\(ds-73280 : Unit-73076) -> error {Rational-73065}) - Unit-73077)) - {all dead-73281. dead-73281} - !validateParamValues-73119 : - List-73026 ParamValue-73068 -> list data -> Bool-73046 - = \(ds-73120 : List-73026 ParamValue-73068) -> - List_match-73029 - {ParamValue-73068} - ds-73120 - {list data -> Bool-73046} - (\(eta-73121 : list data) -> + {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-73046} - (nullList {data} eta-73121) - True-73047 - False-73048) - (\(paramValueHd-73122 : ParamValue-73068) - (paramValueTl-73123 : List-73026 ParamValue-73068) - (actualValueData-73124 : list data) -> - Bool_match-73049 - (validateParamValue-73116 - paramValueHd-73122 - (headList {data} actualValueData-73124)) - {all dead-73125. Bool-73046} - (/\dead-73126 -> - validateParamValues-73119 - paramValueTl-73123 - (tailList {data} actualValueData-73124)) - (/\dead-73127 -> False-73048) - {all dead-73128. dead-73128}) + {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}) in letrec - !runRules-73282 : - List-73026 (Tuple2-73031 integer ParamValue-73068) -> - List-73026 (Tuple2-73031 data data) -> - Bool-73046 - = \(ds-73283 : List-73026 (Tuple2-73031 integer ParamValue-73068)) - (cparams-73284 : List-73026 (Tuple2-73031 data data)) -> + !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)) -> let - !fail-73294 : unit -> Bool-73046 - = \(ds-73285 : unit) -> + !fail-73370 : unit -> Bool-73122 + = \(ds-73361 : unit) -> (let - a-73286 = Tuple2-73031 data data + a-73362 = Tuple2-73107 data data in - \(ds-73287 : List-73026 a-73286) -> - List_match-73029 - {a-73286} - ds-73287 - {all dead-73288. Bool-73046} - (/\dead-73289 -> True-73047) - (\(ipv-73290 : a-73286) - (ipv-73291 : List-73026 a-73286) -> - /\dead-73292 -> False-73048) - {all dead-73293. dead-73293}) - cparams-73284 + \(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 in - List_match-73029 - {Tuple2-73031 integer ParamValue-73068} - ds-73283 - {all dead-73295. Bool-73046} - (/\dead-73296 -> fail-73294 ()) - (\(ds-73297 : Tuple2-73031 integer ParamValue-73068) - (cfgRest-73298 : - List-73026 (Tuple2-73031 integer ParamValue-73068)) -> - /\dead-73299 -> - Tuple2_match-73033 + 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 {integer} - {ParamValue-73068} - ds-73297 - {Bool-73046} - (\(expectedPid-73300 : integer) - (paramValue-73301 : ParamValue-73068) -> - List_match-73029 - {Tuple2-73031 data data} - cparams-73284 - {all dead-73302. Bool-73046} - (/\dead-73303 -> fail-73294 ()) - (\(ds-73304 : Tuple2-73031 data data) - (cparamsRest-73305 : - List-73026 (Tuple2-73031 data data)) -> - /\dead-73306 -> - Tuple2_match-73033 + {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 {data} {data} - ds-73304 - {Bool-73046} - (\(ds-73307 : data) - (actualValueData-73308 : data) -> - Ordering_match-73059 - (`$fOrdInteger_$ccompare`-73115 - (unIData ds-73307) - expectedPid-73300) - {all dead-73309. Bool-73046} - (/\dead-73310 -> - Bool_match-73049 - (validateParamValue-73116 - paramValue-73301 - actualValueData-73308) - {all dead-73311. Bool-73046} - (/\dead-73312 -> - runRules-73282 - cfgRest-73298 - cparamsRest-73305) - (/\dead-73313 -> False-73048) - {all dead-73314. dead-73314}) - (/\dead-73315 -> - runRules-73282 - cfgRest-73298 - cparams-73284) - (/\dead-73316 -> False-73048) - {all dead-73317. dead-73317})) - {all dead-73318. dead-73318})) - {all dead-73319. dead-73319} + 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} in let - data (Maybe-73041 :: * -> *) a-73045 | Maybe_match-73044 where - Just-73042 : a-73045 -> Maybe-73041 a-73045 - Nothing-73043 : Maybe-73041 a-73045 + data (Maybe-73117 :: * -> *) a-73121 | Maybe_match-73120 where + Just-73118 : a-73121 -> Maybe-73117 a-73121 + Nothing-73119 : Maybe-73117 a-73121 in letrec - !go-73036 : list (pair data data) -> List-73026 (Tuple2-73031 data data) - = \(l-73037 : list (pair data data)) -> + !go-73112 : list (pair data data) -> List-73102 (Tuple2-73107 data data) + = \(l-73113 : list (pair data data)) -> chooseList {pair data data} - {unit -> List-73026 (Tuple2-73031 data data)} - l-73037 - (\(ds-73038 : unit) -> Nil-73027 {Tuple2-73031 data data}) - (\(ds-73039 : unit) -> - Cons-73028 - {Tuple2-73031 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} (let - !p-73040 : pair data data = headList {pair data data} l-73037 + !p-73116 : pair data data = headList {pair data data} l-73113 in - Tuple2-73032 + Tuple2-73108 {data} {data} - (fstPair {data} {data} p-73040) - (sndPair {data} {data} p-73040)) - (go-73036 (tailList {pair data data} l-73037))) + (fstPair {data} {data} p-73116) + (sndPair {data} {data} p-73116)) + (go-73112 (tailList {pair data data} l-73113))) () in let - !fun-74173 : List-73026 (Tuple2-73031 data data) -> Bool-73046 - = runRules-73282 + !fun-74249 : List-73102 (Tuple2-73107 data data) -> Bool-73122 + = runRules-73358 ((let - a-73320 = Tuple2-73031 integer ParamValue-73068 + a-73396 = Tuple2-73107 integer ParamValue-73147 in - \(g-73321 : - all b-73322. - (a-73320 -> b-73322 -> b-73322) -> b-73322 -> b-73322) -> - g-73321 - {List-73026 a-73320} - (\(ds-73323 : a-73320) (ds-73324 : List-73026 a-73320) -> - Cons-73028 {a-73320} ds-73323 ds-73324) - (Nil-73027 {a-73320})) - (/\a-73325 -> - \(c-73326 : - Tuple2-73031 integer ParamValue-73068 -> a-73325 -> a-73325) - (n-73327 : a-73325) -> - c-73326 - (Tuple2-73032 + \(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 {integer} - {ParamValue-73068} + {ParamValue-73147} 0 - (ParamInteger-73070 + (ParamInteger-73149 ((let - a-73328 - = Tuple2-73031 - PredKey-73050 - (List-73026 integer) + a-73404 + = Tuple2-73107 + PredKey-73129 + (List-73102 integer) in - \(g-73329 : - all b-73330. - (a-73328 -> b-73330 -> b-73330) -> - b-73330 -> - b-73330) -> - g-73329 - {List-73026 a-73328} - (\(ds-73331 : a-73328) - (ds-73332 : List-73026 a-73328) -> - Cons-73028 {a-73328} ds-73331 ds-73332) - (Nil-73027 {a-73328})) - (/\a-73333 -> - \(c-73334 : - Tuple2-73031 - PredKey-73050 - (List-73026 integer) -> - a-73333 -> - a-73333) - (n-73335 : a-73333) -> - c-73334 - (Tuple2-73032 - {PredKey-73050} - {List-73026 integer} - MinValue-73052 + \(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 ((let - a-73336 = List-73026 integer + a-73412 = List-73102 integer in - \(c-73337 : - integer -> a-73336 -> a-73336) - (n-73338 : a-73336) -> - c-73337 30 (c-73337 0 n-73338)) - (\(ds-73339 : integer) - (ds-73340 : List-73026 integer) -> - Cons-73028 + \(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-73339 - ds-73340) - (Nil-73027 {integer}))) - (c-73334 - (Tuple2-73032 - {PredKey-73050} - {List-73026 integer} - MaxValue-73051 + ds-73415 + ds-73416) + (Nil-73103 {integer}))) + (c-73410 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} + MaxValue-73130 ((let - a-73341 = List-73026 integer + a-73417 = List-73102 integer in - \(c-73342 : - integer -> a-73341 -> a-73341) - (n-73343 : a-73341) -> - c-73342 1000 n-73343) - (\(ds-73344 : integer) - (ds-73345 : - List-73026 integer) -> - Cons-73028 + \(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-73344 - ds-73345) - (Nil-73027 {integer}))) - n-73335))))) - (c-73326 - (Tuple2-73032 + ds-73420 + ds-73421) + (Nil-73103 {integer}))) + n-73411))))) + (c-73402 + (Tuple2-73108 {integer} - {ParamValue-73068} + {ParamValue-73147} 1 - (ParamInteger-73070 + (ParamInteger-73149 ((let - a-73346 - = Tuple2-73031 - PredKey-73050 - (List-73026 integer) + a-73422 + = Tuple2-73107 + PredKey-73129 + (List-73102 integer) in - \(g-73347 : - all b-73348. - (a-73346 -> b-73348 -> b-73348) -> - b-73348 -> - b-73348) -> - g-73347 - {List-73026 a-73346} - (\(ds-73349 : a-73346) - (ds-73350 : List-73026 a-73346) -> - Cons-73028 {a-73346} ds-73349 ds-73350) - (Nil-73027 {a-73346})) - (/\a-73351 -> - \(c-73352 : - Tuple2-73031 - PredKey-73050 - (List-73026 integer) -> - a-73351 -> - a-73351) - (n-73353 : a-73351) -> - c-73352 - (Tuple2-73032 - {PredKey-73050} - {List-73026 integer} - MinValue-73052 + \(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 ((let - a-73354 = List-73026 integer + a-73430 = List-73102 integer in - \(c-73355 : - integer -> a-73354 -> a-73354) - (n-73356 : a-73354) -> - c-73355 + \(c-73431 : + integer -> a-73430 -> a-73430) + (n-73432 : a-73430) -> + c-73431 100000 - (c-73355 0 n-73356)) - (\(ds-73357 : integer) - (ds-73358 : - List-73026 integer) -> - Cons-73028 + (c-73431 0 n-73432)) + (\(ds-73433 : integer) + (ds-73434 : + List-73102 integer) -> + Cons-73104 {integer} - ds-73357 - ds-73358) - (Nil-73027 {integer}))) - (c-73352 - (Tuple2-73032 - {PredKey-73050} - {List-73026 integer} - MaxValue-73051 + ds-73433 + ds-73434) + (Nil-73103 {integer}))) + (c-73428 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} + MaxValue-73130 ((let - a-73359 = List-73026 integer + a-73435 = List-73102 integer in - \(c-73360 : + \(c-73436 : integer -> - a-73359 -> - a-73359) - (n-73361 : a-73359) -> - c-73360 10000000 n-73361) - (\(ds-73362 : integer) - (ds-73363 : - List-73026 integer) -> - Cons-73028 + 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-73362 - ds-73363) - (Nil-73027 {integer}))) - n-73353))))) - (c-73326 - (Tuple2-73032 + ds-73438 + ds-73439) + (Nil-73103 {integer}))) + n-73429))))) + (c-73402 + (Tuple2-73108 {integer} - {ParamValue-73068} + {ParamValue-73147} 2 - (ParamInteger-73070 + (ParamInteger-73149 ((let - a-73364 - = Tuple2-73031 - PredKey-73050 - (List-73026 integer) + a-73440 + = Tuple2-73107 + PredKey-73129 + (List-73102 integer) in - \(g-73365 : - all b-73366. - (a-73364 -> b-73366 -> b-73366) -> - b-73366 -> - b-73366) -> - g-73365 - {List-73026 a-73364} - (\(ds-73367 : a-73364) - (ds-73368 : List-73026 a-73364) -> - Cons-73028 - {a-73364} - ds-73367 - ds-73368) - (Nil-73027 {a-73364})) - (/\a-73369 -> - \(c-73370 : - Tuple2-73031 - PredKey-73050 - (List-73026 integer) -> - a-73369 -> - a-73369) - (n-73371 : a-73369) -> - c-73370 - (Tuple2-73032 - {PredKey-73050} - {List-73026 integer} - MinValue-73052 + \(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 ((let - a-73372 = List-73026 integer + a-73448 = List-73102 integer in - \(c-73373 : + \(c-73449 : integer -> - a-73372 -> - a-73372) - (n-73374 : a-73372) -> - c-73373 24576 n-73374) - (\(ds-73375 : integer) - (ds-73376 : - List-73026 integer) -> - Cons-73028 + 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-73375 - ds-73376) - (Nil-73027 {integer}))) - (c-73370 - (Tuple2-73032 - {PredKey-73050} - {List-73026 integer} - MaxValue-73051 + ds-73451 + ds-73452) + (Nil-73103 {integer}))) + (c-73446 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} + MaxValue-73130 ((let - a-73377 - = List-73026 integer + a-73453 + = List-73102 integer in - \(c-73378 : + \(c-73454 : integer -> - a-73377 -> - a-73377) - (n-73379 : a-73377) -> - c-73378 122880 n-73379) - (\(ds-73380 : integer) - (ds-73381 : - List-73026 integer) -> - Cons-73028 + 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-73380 - ds-73381) - (Nil-73027 {integer}))) - n-73371))))) - (c-73326 - (Tuple2-73032 + ds-73456 + ds-73457) + (Nil-73103 {integer}))) + n-73447))))) + (c-73402 + (Tuple2-73108 {integer} - {ParamValue-73068} + {ParamValue-73147} 3 - (ParamInteger-73070 + (ParamInteger-73149 ((let - a-73382 - = Tuple2-73031 - PredKey-73050 - (List-73026 integer) + a-73458 + = Tuple2-73107 + PredKey-73129 + (List-73102 integer) in - \(g-73383 : - all b-73384. - (a-73382 -> b-73384 -> b-73384) -> - b-73384 -> - b-73384) -> - g-73383 - {List-73026 a-73382} - (\(ds-73385 : a-73382) - (ds-73386 : List-73026 a-73382) -> - Cons-73028 - {a-73382} - ds-73385 - ds-73386) - (Nil-73027 {a-73382})) - (/\a-73387 -> - \(c-73388 : - Tuple2-73031 - PredKey-73050 - (List-73026 integer) -> - a-73387 -> - a-73387) - (n-73389 : a-73387) -> - c-73388 - (Tuple2-73032 - {PredKey-73050} - {List-73026 integer} - MinValue-73052 + \(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 ((let - a-73390 - = List-73026 integer + a-73466 + = List-73102 integer in - \(c-73391 : + \(c-73467 : integer -> - a-73390 -> - a-73390) - (n-73392 : a-73390) -> - c-73391 0 n-73392) - (\(ds-73393 : integer) - (ds-73394 : - List-73026 integer) -> - Cons-73028 + 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-73393 - ds-73394) - (Nil-73027 {integer}))) - (c-73388 - (Tuple2-73032 - {PredKey-73050} - {List-73026 integer} - MaxValue-73051 + ds-73469 + ds-73470) + (Nil-73103 {integer}))) + (c-73464 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} + MaxValue-73130 ((let - a-73395 - = List-73026 integer + a-73471 + = List-73102 integer in - \(c-73396 : + \(c-73472 : integer -> - a-73395 -> - a-73395) - (n-73397 : a-73395) -> - c-73396 32768 n-73397) - (\(ds-73398 : integer) - (ds-73399 : - List-73026 + a-73471 -> + a-73471) + (n-73473 : a-73471) -> + c-73472 32768 n-73473) + (\(ds-73474 : integer) + (ds-73475 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-73398 - ds-73399) - (Nil-73027 {integer}))) - n-73389))))) - (c-73326 - (Tuple2-73032 + ds-73474 + ds-73475) + (Nil-73103 {integer}))) + n-73465))))) + (c-73402 + (Tuple2-73108 {integer} - {ParamValue-73068} + {ParamValue-73147} 4 - (ParamInteger-73070 + (ParamInteger-73149 ((let - a-73400 - = Tuple2-73031 - PredKey-73050 - (List-73026 integer) + a-73476 + = Tuple2-73107 + PredKey-73129 + (List-73102 integer) in - \(g-73401 : - all b-73402. - (a-73400 -> - b-73402 -> - b-73402) -> - b-73402 -> - b-73402) -> - g-73401 - {List-73026 a-73400} - (\(ds-73403 : a-73400) - (ds-73404 : - List-73026 a-73400) -> - Cons-73028 - {a-73400} - ds-73403 - ds-73404) - (Nil-73027 {a-73400})) - (/\a-73405 -> - \(c-73406 : - Tuple2-73031 - PredKey-73050 - (List-73026 integer) -> - a-73405 -> - a-73405) - (n-73407 : a-73405) -> - c-73406 - (Tuple2-73032 - {PredKey-73050} - {List-73026 integer} - MinValue-73052 + \(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 ((let - a-73408 - = List-73026 integer + a-73484 + = List-73102 integer in - \(c-73409 : + \(c-73485 : integer -> - a-73408 -> - a-73408) - (n-73410 : a-73408) -> - c-73409 0 n-73410) - (\(ds-73411 : integer) - (ds-73412 : - List-73026 + a-73484 -> + a-73484) + (n-73486 : a-73484) -> + c-73485 0 n-73486) + (\(ds-73487 : integer) + (ds-73488 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-73411 - ds-73412) - (Nil-73027 {integer}))) - (c-73406 - (Tuple2-73032 - {PredKey-73050} - {List-73026 integer} - MaxValue-73051 + ds-73487 + ds-73488) + (Nil-73103 {integer}))) + (c-73482 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} + MaxValue-73130 ((let - a-73413 - = List-73026 + a-73489 + = List-73102 integer in - \(c-73414 : + \(c-73490 : integer -> - a-73413 -> - a-73413) - (n-73415 : a-73413) -> - c-73414 5000 n-73415) - (\(ds-73416 : integer) - (ds-73417 : - List-73026 + a-73489 -> + a-73489) + (n-73491 : a-73489) -> + c-73490 5000 n-73491) + (\(ds-73492 : integer) + (ds-73493 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-73416 - ds-73417) - (Nil-73027 {integer}))) - n-73407))))) - (c-73326 - (Tuple2-73032 + ds-73492 + ds-73493) + (Nil-73103 {integer}))) + n-73483))))) + (c-73402 + (Tuple2-73108 {integer} - {ParamValue-73068} + {ParamValue-73147} 5 - (ParamInteger-73070 + (ParamInteger-73149 ((let - a-73418 - = Tuple2-73031 - PredKey-73050 - (List-73026 integer) + a-73494 + = Tuple2-73107 + PredKey-73129 + (List-73102 integer) in - \(g-73419 : - all b-73420. - (a-73418 -> - b-73420 -> - b-73420) -> - b-73420 -> - b-73420) -> - g-73419 - {List-73026 a-73418} - (\(ds-73421 : a-73418) - (ds-73422 : - List-73026 a-73418) -> - Cons-73028 - {a-73418} - ds-73421 - ds-73422) - (Nil-73027 {a-73418})) - (/\a-73423 -> - \(c-73424 : - Tuple2-73031 - PredKey-73050 - (List-73026 integer) -> - a-73423 -> - a-73423) - (n-73425 : a-73423) -> - c-73424 - (Tuple2-73032 - {PredKey-73050} - {List-73026 integer} - MinValue-73052 + \(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 ((let - a-73426 - = List-73026 + a-73502 + = List-73102 integer in - \(c-73427 : + \(c-73503 : integer -> - a-73426 -> - a-73426) - (n-73428 : a-73426) -> - c-73427 + a-73502 -> + a-73502) + (n-73504 : a-73502) -> + c-73503 1000000 - (c-73427 + (c-73503 0 - n-73428)) - (\(ds-73429 : integer) - (ds-73430 : - List-73026 + n-73504)) + (\(ds-73505 : integer) + (ds-73506 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-73429 - ds-73430) - (Nil-73027 {integer}))) - (c-73424 - (Tuple2-73032 - {PredKey-73050} - {List-73026 integer} - MaxValue-73051 + ds-73505 + ds-73506) + (Nil-73103 {integer}))) + (c-73500 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} + MaxValue-73130 ((let - a-73431 - = List-73026 + a-73507 + = List-73102 integer in - \(c-73432 : + \(c-73508 : integer -> - a-73431 -> - a-73431) - (n-73433 : - a-73431) -> - c-73432 + a-73507 -> + a-73507) + (n-73509 : + a-73507) -> + c-73508 5000000 - n-73433) - (\(ds-73434 : + n-73509) + (\(ds-73510 : integer) - (ds-73435 : - List-73026 + (ds-73511 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-73434 - ds-73435) - (Nil-73027 + ds-73510 + ds-73511) + (Nil-73103 {integer}))) - n-73425))))) - (c-73326 - (Tuple2-73032 + n-73501))))) + (c-73402 + (Tuple2-73108 {integer} - {ParamValue-73068} + {ParamValue-73147} 6 - (ParamInteger-73070 + (ParamInteger-73149 ((let - a-73436 - = Tuple2-73031 - PredKey-73050 - (List-73026 integer) + a-73512 + = Tuple2-73107 + PredKey-73129 + (List-73102 integer) in - \(g-73437 : - all b-73438. - (a-73436 -> - b-73438 -> - b-73438) -> - b-73438 -> - b-73438) -> - g-73437 - {List-73026 a-73436} - (\(ds-73439 : a-73436) - (ds-73440 : - List-73026 a-73436) -> - Cons-73028 - {a-73436} - ds-73439 - ds-73440) - (Nil-73027 {a-73436})) - (/\a-73441 -> - \(c-73442 : - Tuple2-73031 - PredKey-73050 - (List-73026 integer) -> - a-73441 -> - a-73441) - (n-73443 : a-73441) -> - c-73442 - (Tuple2-73032 - {PredKey-73050} - {List-73026 integer} - MinValue-73052 + \(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 ((let - a-73444 - = List-73026 + a-73520 + = List-73102 integer in - \(c-73445 : + \(c-73521 : integer -> - a-73444 -> - a-73444) - (n-73446 : - a-73444) -> - c-73445 + a-73520 -> + a-73520) + (n-73522 : + a-73520) -> + c-73521 250000000 - (c-73445 + (c-73521 0 - n-73446)) - (\(ds-73447 : + n-73522)) + (\(ds-73523 : integer) - (ds-73448 : - List-73026 + (ds-73524 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-73447 - ds-73448) - (Nil-73027 + ds-73523 + ds-73524) + (Nil-73103 {integer}))) - (c-73442 - (Tuple2-73032 - {PredKey-73050} - {List-73026 integer} - MaxValue-73051 + (c-73518 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} + MaxValue-73130 ((let - a-73449 - = List-73026 + a-73525 + = List-73102 integer in - \(c-73450 : + \(c-73526 : integer -> - a-73449 -> - a-73449) - (n-73451 : - a-73449) -> - c-73450 + a-73525 -> + a-73525) + (n-73527 : + a-73525) -> + c-73526 500000000 - n-73451) - (\(ds-73452 : + n-73527) + (\(ds-73528 : integer) - (ds-73453 : - List-73026 + (ds-73529 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-73452 - ds-73453) - (Nil-73027 + ds-73528 + ds-73529) + (Nil-73103 {integer}))) - n-73443))))) - (c-73326 - (Tuple2-73032 + n-73519))))) + (c-73402 + (Tuple2-73108 {integer} - {ParamValue-73068} + {ParamValue-73147} 7 - (ParamInteger-73070 + (ParamInteger-73149 ((let - a-73454 - = Tuple2-73031 - PredKey-73050 - (List-73026 integer) + a-73530 + = Tuple2-73107 + PredKey-73129 + (List-73102 integer) in - \(g-73455 : - all b-73456. - (a-73454 -> - b-73456 -> - b-73456) -> - b-73456 -> - b-73456) -> - g-73455 - {List-73026 a-73454} - (\(ds-73457 : a-73454) - (ds-73458 : - List-73026 - a-73454) -> - Cons-73028 - {a-73454} - ds-73457 - ds-73458) - (Nil-73027 {a-73454})) - (/\a-73459 -> - \(c-73460 : - Tuple2-73031 - PredKey-73050 - (List-73026 + \(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-73459 -> - a-73459) - (n-73461 : a-73459) -> - c-73460 - (Tuple2-73032 - {PredKey-73050} - {List-73026 integer} - MinValue-73052 + a-73535 -> + a-73535) + (n-73537 : a-73535) -> + c-73536 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} + MinValue-73131 ((let - a-73462 - = List-73026 + a-73538 + = List-73102 integer in - \(c-73463 : + \(c-73539 : integer -> - a-73462 -> - a-73462) - (n-73464 : - a-73462) -> - c-73463 + a-73538 -> + a-73538) + (n-73540 : + a-73538) -> + c-73539 0 - n-73464) - (\(ds-73465 : + n-73540) + (\(ds-73541 : integer) - (ds-73466 : - List-73026 + (ds-73542 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-73465 - ds-73466) - (Nil-73027 + ds-73541 + ds-73542) + (Nil-73103 {integer}))) - n-73461)))) - (c-73326 - (Tuple2-73032 + n-73537)))) + (c-73402 + (Tuple2-73108 {integer} - {ParamValue-73068} + {ParamValue-73147} 8 - (ParamInteger-73070 + (ParamInteger-73149 ((let - a-73467 - = Tuple2-73031 - PredKey-73050 - (List-73026 + a-73543 + = Tuple2-73107 + PredKey-73129 + (List-73102 integer) in - \(g-73468 : - all b-73469. - (a-73467 -> - b-73469 -> - b-73469) -> - b-73469 -> - b-73469) -> - g-73468 - {List-73026 a-73467} - (\(ds-73470 : a-73467) - (ds-73471 : - List-73026 - a-73467) -> - Cons-73028 - {a-73467} - ds-73470 - ds-73471) - (Nil-73027 {a-73467})) - (/\a-73472 -> - \(c-73473 : - Tuple2-73031 - PredKey-73050 - (List-73026 + \(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-73472 -> - a-73472) - (n-73474 : a-73472) -> - c-73473 - (Tuple2-73032 - {PredKey-73050} - {List-73026 + a-73548 -> + a-73548) + (n-73550 : a-73548) -> + c-73549 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} - MinValue-73052 + MinValue-73131 ((let - a-73475 - = List-73026 + a-73551 + = List-73102 integer in - \(c-73476 : + \(c-73552 : integer -> - a-73475 -> - a-73475) - (n-73477 : - a-73475) -> - c-73476 + a-73551 -> + a-73551) + (n-73553 : + a-73551) -> + c-73552 250 - (c-73476 + (c-73552 0 - n-73477)) - (\(ds-73478 : + n-73553)) + (\(ds-73554 : integer) - (ds-73479 : - List-73026 + (ds-73555 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-73478 - ds-73479) - (Nil-73027 + ds-73554 + ds-73555) + (Nil-73103 {integer}))) - (c-73473 - (Tuple2-73032 - {PredKey-73050} - {List-73026 + (c-73549 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} - MaxValue-73051 + MaxValue-73130 ((let - a-73480 - = List-73026 + a-73556 + = List-73102 integer in - \(c-73481 : + \(c-73557 : integer -> - a-73480 -> - a-73480) - (n-73482 : - a-73480) -> - c-73481 + a-73556 -> + a-73556) + (n-73558 : + a-73556) -> + c-73557 2000 - n-73482) - (\(ds-73483 : + n-73558) + (\(ds-73559 : integer) - (ds-73484 : - List-73026 + (ds-73560 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-73483 - ds-73484) - (Nil-73027 + ds-73559 + ds-73560) + (Nil-73103 {integer}))) - (c-73473 - (Tuple2-73032 - {PredKey-73050} - {List-73026 + (c-73549 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} - NotEqual-73053 + NotEqual-73132 ((let - a-73485 - = List-73026 + a-73561 + = List-73102 integer in - \(c-73486 : + \(c-73562 : integer -> - a-73485 -> - a-73485) - (n-73487 : - a-73485) -> - c-73486 + a-73561 -> + a-73561) + (n-73563 : + a-73561) -> + c-73562 0 - n-73487) - (\(ds-73488 : + n-73563) + (\(ds-73564 : integer) - (ds-73489 : - List-73026 + (ds-73565 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-73488 - ds-73489) - (Nil-73027 + ds-73564 + ds-73565) + (Nil-73103 {integer}))) - n-73474)))))) - (c-73326 - (Tuple2-73032 + n-73550)))))) + (c-73402 + (Tuple2-73108 {integer} - {ParamValue-73068} + {ParamValue-73147} 9 - (ParamRational-73072 + (ParamRational-73151 ((let - a-73490 - = Tuple2-73031 - PredKey-73050 - (List-73026 - Rational-73065) + a-73566 + = Tuple2-73107 + PredKey-73129 + (List-73102 + Rational-73144) in - \(g-73491 : - all b-73492. - (a-73490 -> - b-73492 -> - b-73492) -> - b-73492 -> - b-73492) -> - g-73491 - {List-73026 a-73490} - (\(ds-73493 : - a-73490) - (ds-73494 : - List-73026 - a-73490) -> - Cons-73028 - {a-73490} - ds-73493 - ds-73494) - (Nil-73027 - {a-73490})) - (/\a-73495 -> - \(c-73496 : - Tuple2-73031 - PredKey-73050 - (List-73026 - Rational-73065) -> - a-73495 -> - a-73495) - (n-73497 : - a-73495) -> - c-73496 - (Tuple2-73032 - {PredKey-73050} - {List-73026 - Rational-73065} - MinValue-73052 + \(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 ((let - a-73498 - = List-73026 - Rational-73065 + a-73574 + = List-73102 + Rational-73144 in - \(c-73499 : - Rational-73065 -> - a-73498 -> - a-73498) - (n-73500 : - a-73498) -> - c-73499 - (unsafeRatio-73086 + \(c-73575 : + Rational-73144 -> + a-73574 -> + a-73574) + (n-73576 : + a-73574) -> + c-73575 + (unsafeRatio-73162 1 10) - (c-73499 - (unsafeRatio-73086 + (c-73575 + (unsafeRatio-73162 0 1) - n-73500)) - (\(ds-73501 : - Rational-73065) - (ds-73502 : - List-73026 - Rational-73065) -> - Cons-73028 - {Rational-73065} - ds-73501 - ds-73502) - (Nil-73027 - {Rational-73065}))) - (c-73496 - (Tuple2-73032 - {PredKey-73050} - {List-73026 - Rational-73065} - MaxValue-73051 + 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 ((let - a-73503 - = List-73026 - Rational-73065 + a-73579 + = List-73102 + Rational-73144 in - \(c-73504 : - Rational-73065 -> - a-73503 -> - a-73503) - (n-73505 : - a-73503) -> - c-73504 - (unsafeRatio-73086 + \(c-73580 : + Rational-73144 -> + a-73579 -> + a-73579) + (n-73581 : + a-73579) -> + c-73580 + (unsafeRatio-73162 1 1) - n-73505) - (\(ds-73506 : - Rational-73065) - (ds-73507 : - List-73026 - Rational-73065) -> - Cons-73028 - {Rational-73065} - ds-73506 - ds-73507) - (Nil-73027 - {Rational-73065}))) - n-73497))))) - (c-73326 - (Tuple2-73032 + 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 {integer} - {ParamValue-73068} + {ParamValue-73147} 10 - (ParamRational-73072 + (ParamRational-73151 ((let - a-73508 - = Tuple2-73031 - PredKey-73050 - (List-73026 - Rational-73065) + a-73584 + = Tuple2-73107 + PredKey-73129 + (List-73102 + Rational-73144) in - \(g-73509 : - all b-73510. - (a-73508 -> - b-73510 -> - b-73510) -> - b-73510 -> - b-73510) -> - g-73509 - {List-73026 - a-73508} - (\(ds-73511 : - a-73508) - (ds-73512 : - List-73026 - a-73508) -> - Cons-73028 - {a-73508} - ds-73511 - ds-73512) - (Nil-73027 - {a-73508})) - (/\a-73513 -> - \(c-73514 : - Tuple2-73031 - PredKey-73050 - (List-73026 - Rational-73065) -> - a-73513 -> - a-73513) - (n-73515 : - a-73513) -> - c-73514 - (Tuple2-73032 - {PredKey-73050} - {List-73026 - Rational-73065} - MinValue-73052 + \(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 ((let - a-73516 - = List-73026 - Rational-73065 + a-73592 + = List-73102 + Rational-73144 in - \(c-73517 : - Rational-73065 -> - a-73516 -> - a-73516) - (n-73518 : - a-73516) -> - c-73517 - (unsafeRatio-73086 + \(c-73593 : + Rational-73144 -> + a-73592 -> + a-73592) + (n-73594 : + a-73592) -> + c-73593 + (unsafeRatio-73162 1 1000) - (c-73517 - (unsafeRatio-73086 + (c-73593 + (unsafeRatio-73162 0 1) - n-73518)) - (\(ds-73519 : - Rational-73065) - (ds-73520 : - List-73026 - Rational-73065) -> - Cons-73028 - {Rational-73065} - ds-73519 - ds-73520) - (Nil-73027 - {Rational-73065}))) - (c-73514 - (Tuple2-73032 - {PredKey-73050} - {List-73026 - Rational-73065} - MaxValue-73051 + 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 ((let - a-73521 - = List-73026 - Rational-73065 + a-73597 + = List-73102 + Rational-73144 in - \(c-73522 : - Rational-73065 -> - a-73521 -> - a-73521) - (n-73523 : - a-73521) -> - c-73522 - (unsafeRatio-73086 + \(c-73598 : + Rational-73144 -> + a-73597 -> + a-73597) + (n-73599 : + a-73597) -> + c-73598 + (unsafeRatio-73162 1 200) - n-73523) - (\(ds-73524 : - Rational-73065) - (ds-73525 : - List-73026 - Rational-73065) -> - Cons-73028 - {Rational-73065} - ds-73524 - ds-73525) - (Nil-73027 - {Rational-73065}))) - n-73515))))) - (c-73326 - (Tuple2-73032 + 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 {integer} - {ParamValue-73068} + {ParamValue-73147} 11 - (ParamRational-73072 + (ParamRational-73151 ((let - a-73526 - = Tuple2-73031 - PredKey-73050 - (List-73026 - Rational-73065) + a-73602 + = Tuple2-73107 + PredKey-73129 + (List-73102 + Rational-73144) in - \(g-73527 : - all b-73528. - (a-73526 -> - b-73528 -> - b-73528) -> - b-73528 -> - b-73528) -> - g-73527 - {List-73026 - a-73526} - (\(ds-73529 : - a-73526) - (ds-73530 : - List-73026 - a-73526) -> - Cons-73028 - {a-73526} - ds-73529 - ds-73530) - (Nil-73027 - {a-73526})) - (/\a-73531 -> - \(c-73532 : - Tuple2-73031 - PredKey-73050 - (List-73026 - Rational-73065) -> - a-73531 -> - a-73531) - (n-73533 : - a-73531) -> - c-73532 - (Tuple2-73032 - {PredKey-73050} - {List-73026 - Rational-73065} - MinValue-73052 + \(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 ((let - a-73534 - = List-73026 - Rational-73065 + a-73610 + = List-73102 + Rational-73144 in - \(c-73535 : - Rational-73065 -> - a-73534 -> - a-73534) - (n-73536 : - a-73534) -> - c-73535 - (unsafeRatio-73086 + \(c-73611 : + Rational-73144 -> + a-73610 -> + a-73610) + (n-73612 : + a-73610) -> + c-73611 + (unsafeRatio-73162 1 10) - (c-73535 - (unsafeRatio-73086 + (c-73611 + (unsafeRatio-73162 0 1) - n-73536)) - (\(ds-73537 : - Rational-73065) - (ds-73538 : - List-73026 - Rational-73065) -> - Cons-73028 - {Rational-73065} - ds-73537 - ds-73538) - (Nil-73027 - {Rational-73065}))) - (c-73532 - (Tuple2-73032 - {PredKey-73050} - {List-73026 - Rational-73065} - MaxValue-73051 + 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 ((let - a-73539 - = List-73026 - Rational-73065 + a-73615 + = List-73102 + Rational-73144 in - \(c-73540 : - Rational-73065 -> - a-73539 -> - a-73539) - (n-73541 : - a-73539) -> - c-73540 - (unsafeRatio-73086 + \(c-73616 : + Rational-73144 -> + a-73615 -> + a-73615) + (n-73617 : + a-73615) -> + c-73616 + (unsafeRatio-73162 3 10) - (c-73540 - (unsafeRatio-73086 + (c-73616 + (unsafeRatio-73162 1 1) - n-73541)) - (\(ds-73542 : - Rational-73065) - (ds-73543 : - List-73026 - Rational-73065) -> - Cons-73028 - {Rational-73065} - ds-73542 - ds-73543) - (Nil-73027 - {Rational-73065}))) - n-73533))))) - (c-73326 - (Tuple2-73032 + 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 {integer} - {ParamValue-73068} + {ParamValue-73147} 16 - (ParamInteger-73070 + (ParamInteger-73149 ((let - a-73544 - = Tuple2-73031 - PredKey-73050 - (List-73026 + a-73620 + = Tuple2-73107 + PredKey-73129 + (List-73102 integer) in - \(g-73545 : - all b-73546. - (a-73544 -> - b-73546 -> - b-73546) -> - b-73546 -> - b-73546) -> - g-73545 - {List-73026 - a-73544} - (\(ds-73547 : - a-73544) - (ds-73548 : - List-73026 - a-73544) -> - Cons-73028 - {a-73544} - ds-73547 - ds-73548) - (Nil-73027 - {a-73544})) - (/\a-73549 -> - \(c-73550 : - Tuple2-73031 - PredKey-73050 - (List-73026 + \(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 integer) -> - a-73549 -> - a-73549) - (n-73551 : - a-73549) -> - c-73550 - (Tuple2-73032 - {PredKey-73050} - {List-73026 + a-73625 -> + a-73625) + (n-73627 : + a-73625) -> + c-73626 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} - MinValue-73052 + MinValue-73131 ((let - a-73552 - = List-73026 + a-73628 + = List-73102 integer in - \(c-73553 : + \(c-73629 : integer -> - a-73552 -> - a-73552) - (n-73554 : - a-73552) -> - c-73553 + a-73628 -> + a-73628) + (n-73630 : + a-73628) -> + c-73629 0 - n-73554) - (\(ds-73555 : + n-73630) + (\(ds-73631 : integer) - (ds-73556 : - List-73026 + (ds-73632 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-73555 - ds-73556) - (Nil-73027 + ds-73631 + ds-73632) + (Nil-73103 {integer}))) - (c-73550 - (Tuple2-73032 - {PredKey-73050} - {List-73026 + (c-73626 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} - MaxValue-73051 + MaxValue-73130 ((let - a-73557 - = List-73026 + a-73633 + = List-73102 integer in - \(c-73558 : + \(c-73634 : integer -> - a-73557 -> - a-73557) - (n-73559 : - a-73557) -> - c-73558 + a-73633 -> + a-73633) + (n-73635 : + a-73633) -> + c-73634 500000000 - n-73559) - (\(ds-73560 : + n-73635) + (\(ds-73636 : integer) - (ds-73561 : - List-73026 + (ds-73637 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-73560 - ds-73561) - (Nil-73027 + ds-73636 + ds-73637) + (Nil-73103 {integer}))) - n-73551))))) - (c-73326 - (Tuple2-73032 + n-73627))))) + (c-73402 + (Tuple2-73108 {integer} - {ParamValue-73068} + {ParamValue-73147} 17 - (ParamInteger-73070 + (ParamInteger-73149 ((let - a-73562 - = Tuple2-73031 - PredKey-73050 - (List-73026 + a-73638 + = Tuple2-73107 + PredKey-73129 + (List-73102 integer) in - \(g-73563 : - all b-73564. - (a-73562 -> - b-73564 -> - b-73564) -> - b-73564 -> - b-73564) -> - g-73563 - {List-73026 - a-73562} - (\(ds-73565 : - a-73562) - (ds-73566 : - List-73026 - a-73562) -> - Cons-73028 - {a-73562} - ds-73565 - ds-73566) - (Nil-73027 - {a-73562})) - (/\a-73567 -> - \(c-73568 : - Tuple2-73031 - PredKey-73050 - (List-73026 + \(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 integer) -> - a-73567 -> - a-73567) - (n-73569 : - a-73567) -> - c-73568 - (Tuple2-73032 - {PredKey-73050} - {List-73026 + a-73643 -> + a-73643) + (n-73645 : + a-73643) -> + c-73644 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} - MinValue-73052 + MinValue-73131 ((let - a-73570 - = List-73026 + a-73646 + = List-73102 integer in - \(c-73571 : + \(c-73647 : integer -> - a-73570 -> - a-73570) - (n-73572 : - a-73570) -> - c-73571 + a-73646 -> + a-73646) + (n-73648 : + a-73646) -> + c-73647 3000 - (c-73571 + (c-73647 0 - n-73572)) - (\(ds-73573 : + n-73648)) + (\(ds-73649 : integer) - (ds-73574 : - List-73026 + (ds-73650 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-73573 - ds-73574) - (Nil-73027 + ds-73649 + ds-73650) + (Nil-73103 {integer}))) - (c-73568 - (Tuple2-73032 - {PredKey-73050} - {List-73026 + (c-73644 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} - MaxValue-73051 + MaxValue-73130 ((let - a-73575 - = List-73026 + a-73651 + = List-73102 integer in - \(c-73576 : + \(c-73652 : integer -> - a-73575 -> - a-73575) - (n-73577 : - a-73575) -> - c-73576 + a-73651 -> + a-73651) + (n-73653 : + a-73651) -> + c-73652 6500 - n-73577) - (\(ds-73578 : + n-73653) + (\(ds-73654 : integer) - (ds-73579 : - List-73026 + (ds-73655 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-73578 - ds-73579) - (Nil-73027 + ds-73654 + ds-73655) + (Nil-73103 {integer}))) - (c-73568 - (Tuple2-73032 - {PredKey-73050} - {List-73026 + (c-73644 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} - NotEqual-73053 + NotEqual-73132 ((let - a-73580 - = List-73026 + a-73656 + = List-73102 integer in - \(c-73581 : + \(c-73657 : integer -> - a-73580 -> - a-73580) - (n-73582 : - a-73580) -> - c-73581 + a-73656 -> + a-73656) + (n-73658 : + a-73656) -> + c-73657 0 - n-73582) - (\(ds-73583 : + n-73658) + (\(ds-73659 : integer) - (ds-73584 : - List-73026 + (ds-73660 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-73583 - ds-73584) - (Nil-73027 + ds-73659 + ds-73660) + (Nil-73103 {integer}))) - n-73569)))))) - (c-73326 - (Tuple2-73032 + n-73645)))))) + (c-73402 + (Tuple2-73108 {integer} - {ParamValue-73068} + {ParamValue-73147} 18 - ParamAny-73069) - (c-73326 - (Tuple2-73032 + ParamAny-73148) + (c-73402 + (Tuple2-73108 {integer} - {ParamValue-73068} + {ParamValue-73147} 19 - (ParamList-73071 + (ParamList-73150 ((let - a-73585 - = List-73026 - ParamValue-73068 + a-73661 + = List-73102 + ParamValue-73147 in - \(c-73586 : - ParamValue-73068 -> - a-73585 -> - a-73585) - (n-73587 : - a-73585) -> - c-73586 - (ParamRational-73072 + \(c-73662 : + ParamValue-73147 -> + a-73661 -> + a-73661) + (n-73663 : + a-73661) -> + c-73662 + (ParamRational-73151 ((let - a-73588 - = Tuple2-73031 - PredKey-73050 - (List-73026 - Rational-73065) + a-73664 + = Tuple2-73107 + PredKey-73129 + (List-73102 + Rational-73144) in - \(g-73589 : - all b-73590. - (a-73588 -> - b-73590 -> - b-73590) -> - b-73590 -> - b-73590) -> - g-73589 - {List-73026 - a-73588} - (\(ds-73591 : - a-73588) - (ds-73592 : - List-73026 - a-73588) -> - Cons-73028 - {a-73588} - ds-73591 - ds-73592) - (Nil-73027 - {a-73588})) - (/\a-73593 -> - \(c-73594 : - Tuple2-73031 - PredKey-73050 - (List-73026 - Rational-73065) -> - a-73593 -> - a-73593) - (n-73595 : - a-73593) -> - c-73594 - (Tuple2-73032 - {PredKey-73050} - {List-73026 - Rational-73065} - MinValue-73052 + \(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 ((let - a-73596 - = List-73026 - Rational-73065 + a-73672 + = List-73102 + Rational-73144 in - \(c-73597 : - Rational-73065 -> - a-73596 -> - a-73596) - (n-73598 : - a-73596) -> - c-73597 - (unsafeRatio-73086 + \(c-73673 : + Rational-73144 -> + a-73672 -> + a-73672) + (n-73674 : + a-73672) -> + c-73673 + (unsafeRatio-73162 1 25) - n-73598) - (\(ds-73599 : - Rational-73065) - (ds-73600 : - List-73026 - Rational-73065) -> - Cons-73028 - {Rational-73065} - ds-73599 - ds-73600) - (Nil-73027 - {Rational-73065}))) - (c-73594 - (Tuple2-73032 - {PredKey-73050} - {List-73026 - Rational-73065} - MaxValue-73051 + 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 ((let - a-73601 - = List-73026 - Rational-73065 + a-73677 + = List-73102 + Rational-73144 in - \(c-73602 : - Rational-73065 -> - a-73601 -> - a-73601) - (n-73603 : - a-73601) -> - c-73602 - (unsafeRatio-73086 + \(c-73678 : + Rational-73144 -> + a-73677 -> + a-73677) + (n-73679 : + a-73677) -> + c-73678 + (unsafeRatio-73162 1 5) - n-73603) - (\(ds-73604 : - Rational-73065) - (ds-73605 : - List-73026 - Rational-73065) -> - Cons-73028 - {Rational-73065} - ds-73604 - ds-73605) - (Nil-73027 - {Rational-73065}))) - n-73595)))) - (c-73586 - (ParamRational-73072 + 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 ((let - a-73606 - = Tuple2-73031 - PredKey-73050 - (List-73026 - Rational-73065) + a-73682 + = Tuple2-73107 + PredKey-73129 + (List-73102 + Rational-73144) in - \(g-73607 : - all b-73608. - (a-73606 -> - b-73608 -> - b-73608) -> - b-73608 -> - b-73608) -> - g-73607 - {List-73026 - a-73606} - (\(ds-73609 : - a-73606) - (ds-73610 : - List-73026 - a-73606) -> - Cons-73028 - {a-73606} - ds-73609 - ds-73610) - (Nil-73027 - {a-73606})) - (/\a-73611 -> - \(c-73612 : - Tuple2-73031 - PredKey-73050 - (List-73026 - Rational-73065) -> - a-73611 -> - a-73611) - (n-73613 : - a-73611) -> - c-73612 - (Tuple2-73032 - {PredKey-73050} - {List-73026 - Rational-73065} - MinValue-73052 + \(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 ((let - a-73614 - = List-73026 - Rational-73065 + a-73690 + = List-73102 + Rational-73144 in - \(c-73615 : - Rational-73065 -> - a-73614 -> - a-73614) - (n-73616 : - a-73614) -> - c-73615 - (unsafeRatio-73086 + \(c-73691 : + Rational-73144 -> + a-73690 -> + a-73690) + (n-73692 : + a-73690) -> + c-73691 + (unsafeRatio-73162 1 20000) - n-73616) - (\(ds-73617 : - Rational-73065) - (ds-73618 : - List-73026 - Rational-73065) -> - Cons-73028 - {Rational-73065} - ds-73617 - ds-73618) - (Nil-73027 - {Rational-73065}))) - (c-73612 - (Tuple2-73032 - {PredKey-73050} - {List-73026 - Rational-73065} - MaxValue-73051 + 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 ((let - a-73619 - = List-73026 - Rational-73065 + a-73695 + = List-73102 + Rational-73144 in - \(c-73620 : - Rational-73065 -> - a-73619 -> - a-73619) - (n-73621 : - a-73619) -> - c-73620 - (unsafeRatio-73086 + \(c-73696 : + Rational-73144 -> + a-73695 -> + a-73695) + (n-73697 : + a-73695) -> + c-73696 + (unsafeRatio-73162 1 5000) - n-73621) - (\(ds-73622 : - Rational-73065) - (ds-73623 : - List-73026 - Rational-73065) -> - Cons-73028 - {Rational-73065} - ds-73622 - ds-73623) - (Nil-73027 - {Rational-73065}))) - n-73613)))) - n-73587)) - (\(ds-73624 : - ParamValue-73068) - (ds-73625 : - List-73026 - ParamValue-73068) -> - Cons-73028 - {ParamValue-73068} - ds-73624 - ds-73625) - (Nil-73027 - {ParamValue-73068})))) - (c-73326 - (Tuple2-73032 + 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 {integer} - {ParamValue-73068} + {ParamValue-73147} 20 - (ParamList-73071 + (ParamList-73150 ((let - a-73626 - = List-73026 - ParamValue-73068 + a-73702 + = List-73102 + ParamValue-73147 in - \(c-73627 : - ParamValue-73068 -> - a-73626 -> - a-73626) - (n-73628 : - a-73626) -> - c-73627 - (ParamInteger-73070 + \(c-73703 : + ParamValue-73147 -> + a-73702 -> + a-73702) + (n-73704 : + a-73702) -> + c-73703 + (ParamInteger-73149 ((let - a-73629 - = Tuple2-73031 - PredKey-73050 - (List-73026 + a-73705 + = Tuple2-73107 + PredKey-73129 + (List-73102 integer) in - \(g-73630 : - all b-73631. - (a-73629 -> - b-73631 -> - b-73631) -> - b-73631 -> - b-73631) -> - g-73630 - {List-73026 - a-73629} - (\(ds-73632 : - a-73629) - (ds-73633 : - List-73026 - a-73629) -> - Cons-73028 - {a-73629} - ds-73632 - ds-73633) - (Nil-73027 - {a-73629})) - (/\a-73634 -> - \(c-73635 : - Tuple2-73031 - PredKey-73050 - (List-73026 + \(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 integer) -> - a-73634 -> - a-73634) - (n-73636 : - a-73634) -> - c-73635 - (Tuple2-73032 - {PredKey-73050} - {List-73026 + a-73710 -> + a-73710) + (n-73712 : + a-73710) -> + c-73711 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} - MinValue-73052 + MinValue-73131 ((let - a-73637 - = List-73026 + a-73713 + = List-73102 integer in - \(c-73638 : + \(c-73714 : integer -> - a-73637 -> - a-73637) - (n-73639 : - a-73637) -> - c-73638 + a-73713 -> + a-73713) + (n-73715 : + a-73713) -> + c-73714 0 - n-73639) - (\(ds-73640 : + n-73715) + (\(ds-73716 : integer) - (ds-73641 : - List-73026 + (ds-73717 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-73640 - ds-73641) - (Nil-73027 + ds-73716 + ds-73717) + (Nil-73103 {integer}))) - (c-73635 - (Tuple2-73032 - {PredKey-73050} - {List-73026 + (c-73711 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} - MaxValue-73051 + MaxValue-73130 ((let - a-73642 - = List-73026 + a-73718 + = List-73102 integer in - \(c-73643 : + \(c-73719 : integer -> - a-73642 -> - a-73642) - (n-73644 : - a-73642) -> - c-73643 + a-73718 -> + a-73718) + (n-73720 : + a-73718) -> + c-73719 40000000 - n-73644) - (\(ds-73645 : + n-73720) + (\(ds-73721 : integer) - (ds-73646 : - List-73026 + (ds-73722 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-73645 - ds-73646) - (Nil-73027 + ds-73721 + ds-73722) + (Nil-73103 {integer}))) - n-73636)))) - (c-73627 - (ParamInteger-73070 + n-73712)))) + (c-73703 + (ParamInteger-73149 ((let - a-73647 - = Tuple2-73031 - PredKey-73050 - (List-73026 + a-73723 + = Tuple2-73107 + PredKey-73129 + (List-73102 integer) in - \(g-73648 : - all b-73649. - (a-73647 -> - b-73649 -> - b-73649) -> - b-73649 -> - b-73649) -> - g-73648 - {List-73026 - a-73647} - (\(ds-73650 : - a-73647) - (ds-73651 : - List-73026 - a-73647) -> - Cons-73028 - {a-73647} - ds-73650 - ds-73651) - (Nil-73027 - {a-73647})) - (/\a-73652 -> - \(c-73653 : - Tuple2-73031 - PredKey-73050 - (List-73026 + \(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 integer) -> - a-73652 -> - a-73652) - (n-73654 : - a-73652) -> - c-73653 - (Tuple2-73032 - {PredKey-73050} - {List-73026 + a-73728 -> + a-73728) + (n-73730 : + a-73728) -> + c-73729 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} - MinValue-73052 + MinValue-73131 ((let - a-73655 - = List-73026 + a-73731 + = List-73102 integer in - \(c-73656 : + \(c-73732 : integer -> - a-73655 -> - a-73655) - (n-73657 : - a-73655) -> - c-73656 + a-73731 -> + a-73731) + (n-73733 : + a-73731) -> + c-73732 0 - n-73657) - (\(ds-73658 : + n-73733) + (\(ds-73734 : integer) - (ds-73659 : - List-73026 + (ds-73735 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-73658 - ds-73659) - (Nil-73027 + ds-73734 + ds-73735) + (Nil-73103 {integer}))) - (c-73653 - (Tuple2-73032 - {PredKey-73050} - {List-73026 + (c-73729 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} - MaxValue-73051 + MaxValue-73130 ((let - a-73660 - = List-73026 + a-73736 + = List-73102 integer in - \(c-73661 : + \(c-73737 : integer -> - a-73660 -> - a-73660) - (n-73662 : - a-73660) -> - c-73661 + a-73736 -> + a-73736) + (n-73738 : + a-73736) -> + c-73737 15000000000 - n-73662) - (\(ds-73663 : + n-73738) + (\(ds-73739 : integer) - (ds-73664 : - List-73026 + (ds-73740 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-73663 - ds-73664) - (Nil-73027 + ds-73739 + ds-73740) + (Nil-73103 {integer}))) - n-73654)))) - n-73628)) - (\(ds-73665 : - ParamValue-73068) - (ds-73666 : - List-73026 - ParamValue-73068) -> - Cons-73028 - {ParamValue-73068} - ds-73665 - ds-73666) - (Nil-73027 - {ParamValue-73068})))) - (c-73326 - (Tuple2-73032 + 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 {integer} - {ParamValue-73068} + {ParamValue-73147} 21 - (ParamList-73071 + (ParamList-73150 ((let - a-73667 - = List-73026 - ParamValue-73068 + a-73743 + = List-73102 + ParamValue-73147 in - \(c-73668 : - ParamValue-73068 -> - a-73667 -> - a-73667) - (n-73669 : - a-73667) -> - c-73668 - (ParamInteger-73070 + \(c-73744 : + ParamValue-73147 -> + a-73743 -> + a-73743) + (n-73745 : + a-73743) -> + c-73744 + (ParamInteger-73149 ((let - a-73670 - = Tuple2-73031 - PredKey-73050 - (List-73026 + a-73746 + = Tuple2-73107 + PredKey-73129 + (List-73102 integer) in - \(g-73671 : - all b-73672. - (a-73670 -> - b-73672 -> - b-73672) -> - b-73672 -> - b-73672) -> - g-73671 - {List-73026 - a-73670} - (\(ds-73673 : - a-73670) - (ds-73674 : - List-73026 - a-73670) -> - Cons-73028 - {a-73670} - ds-73673 - ds-73674) - (Nil-73027 - {a-73670})) - (/\a-73675 -> - \(c-73676 : - Tuple2-73031 - PredKey-73050 - (List-73026 + \(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 integer) -> - a-73675 -> - a-73675) - (n-73677 : - a-73675) -> - c-73676 - (Tuple2-73032 - {PredKey-73050} - {List-73026 + a-73751 -> + a-73751) + (n-73753 : + a-73751) -> + c-73752 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} - MinValue-73052 + MinValue-73131 ((let - a-73678 - = List-73026 + a-73754 + = List-73102 integer in - \(c-73679 : + \(c-73755 : integer -> - a-73678 -> - a-73678) - (n-73680 : - a-73678) -> - c-73679 + a-73754 -> + a-73754) + (n-73756 : + a-73754) -> + c-73755 0 - n-73680) - (\(ds-73681 : + n-73756) + (\(ds-73757 : integer) - (ds-73682 : - List-73026 + (ds-73758 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-73681 - ds-73682) - (Nil-73027 + ds-73757 + ds-73758) + (Nil-73103 {integer}))) - (c-73676 - (Tuple2-73032 - {PredKey-73050} - {List-73026 + (c-73752 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} - MaxValue-73051 + MaxValue-73130 ((let - a-73683 - = List-73026 + a-73759 + = List-73102 integer in - \(c-73684 : + \(c-73760 : integer -> - a-73683 -> - a-73683) - (n-73685 : - a-73683) -> - c-73684 + a-73759 -> + a-73759) + (n-73761 : + a-73759) -> + c-73760 120000000 - n-73685) - (\(ds-73686 : + n-73761) + (\(ds-73762 : integer) - (ds-73687 : - List-73026 + (ds-73763 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-73686 - ds-73687) - (Nil-73027 + ds-73762 + ds-73763) + (Nil-73103 {integer}))) - n-73677)))) - (c-73668 - (ParamInteger-73070 + n-73753)))) + (c-73744 + (ParamInteger-73149 ((let - a-73688 - = Tuple2-73031 - PredKey-73050 - (List-73026 + a-73764 + = Tuple2-73107 + PredKey-73129 + (List-73102 integer) in - \(g-73689 : - all b-73690. - (a-73688 -> - b-73690 -> - b-73690) -> - b-73690 -> - b-73690) -> - g-73689 - {List-73026 - a-73688} - (\(ds-73691 : - a-73688) - (ds-73692 : - List-73026 - a-73688) -> - Cons-73028 - {a-73688} - ds-73691 - ds-73692) - (Nil-73027 - {a-73688})) - (/\a-73693 -> - \(c-73694 : - Tuple2-73031 - PredKey-73050 - (List-73026 + \(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 integer) -> - a-73693 -> - a-73693) - (n-73695 : - a-73693) -> - c-73694 - (Tuple2-73032 - {PredKey-73050} - {List-73026 + a-73769 -> + a-73769) + (n-73771 : + a-73769) -> + c-73770 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} - MinValue-73052 + MinValue-73131 ((let - a-73696 - = List-73026 + a-73772 + = List-73102 integer in - \(c-73697 : + \(c-73773 : integer -> - a-73696 -> - a-73696) - (n-73698 : - a-73696) -> - c-73697 + a-73772 -> + a-73772) + (n-73774 : + a-73772) -> + c-73773 0 - n-73698) - (\(ds-73699 : + n-73774) + (\(ds-73775 : integer) - (ds-73700 : - List-73026 + (ds-73776 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-73699 - ds-73700) - (Nil-73027 + ds-73775 + ds-73776) + (Nil-73103 {integer}))) - (c-73694 - (Tuple2-73032 - {PredKey-73050} - {List-73026 + (c-73770 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} - MaxValue-73051 + MaxValue-73130 ((let - a-73701 - = List-73026 + a-73777 + = List-73102 integer in - \(c-73702 : + \(c-73778 : integer -> - a-73701 -> - a-73701) - (n-73703 : - a-73701) -> - c-73702 + a-73777 -> + a-73777) + (n-73779 : + a-73777) -> + c-73778 40000000000 - n-73703) - (\(ds-73704 : + n-73779) + (\(ds-73780 : integer) - (ds-73705 : - List-73026 + (ds-73781 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-73704 - ds-73705) - (Nil-73027 + ds-73780 + ds-73781) + (Nil-73103 {integer}))) - n-73695)))) - n-73669)) - (\(ds-73706 : - ParamValue-73068) - (ds-73707 : - List-73026 - ParamValue-73068) -> - Cons-73028 - {ParamValue-73068} - ds-73706 - ds-73707) - (Nil-73027 - {ParamValue-73068})))) - (c-73326 - (Tuple2-73032 + 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 {integer} - {ParamValue-73068} + {ParamValue-73147} 22 - (ParamInteger-73070 + (ParamInteger-73149 ((let - a-73708 - = Tuple2-73031 - PredKey-73050 - (List-73026 + a-73784 + = Tuple2-73107 + PredKey-73129 + (List-73102 integer) in - \(g-73709 : - all b-73710. - (a-73708 -> - b-73710 -> - b-73710) -> - b-73710 -> - b-73710) -> - g-73709 - {List-73026 - a-73708} - (\(ds-73711 : - a-73708) - (ds-73712 : - List-73026 - a-73708) -> - Cons-73028 - {a-73708} - ds-73711 - ds-73712) - (Nil-73027 - {a-73708})) - (/\a-73713 -> - \(c-73714 : - Tuple2-73031 - PredKey-73050 - (List-73026 + \(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 integer) -> - a-73713 -> - a-73713) - (n-73715 : - a-73713) -> - c-73714 - (Tuple2-73032 - {PredKey-73050} - {List-73026 + a-73789 -> + a-73789) + (n-73791 : + a-73789) -> + c-73790 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} - MinValue-73052 + MinValue-73131 ((let - a-73716 - = List-73026 + a-73792 + = List-73102 integer in - \(c-73717 : + \(c-73793 : integer -> - a-73716 -> - a-73716) - (n-73718 : - a-73716) -> - c-73717 + a-73792 -> + a-73792) + (n-73794 : + a-73792) -> + c-73793 0 - n-73718) - (\(ds-73719 : + n-73794) + (\(ds-73795 : integer) - (ds-73720 : - List-73026 + (ds-73796 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-73719 - ds-73720) - (Nil-73027 + ds-73795 + ds-73796) + (Nil-73103 {integer}))) - (c-73714 - (Tuple2-73032 - {PredKey-73050} - {List-73026 + (c-73790 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} - MaxValue-73051 + MaxValue-73130 ((let - a-73721 - = List-73026 + a-73797 + = List-73102 integer in - \(c-73722 : + \(c-73798 : integer -> - a-73721 -> - a-73721) - (n-73723 : - a-73721) -> - c-73722 + a-73797 -> + a-73797) + (n-73799 : + a-73797) -> + c-73798 12288 - n-73723) - (\(ds-73724 : + n-73799) + (\(ds-73800 : integer) - (ds-73725 : - List-73026 + (ds-73801 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-73724 - ds-73725) - (Nil-73027 + ds-73800 + ds-73801) + (Nil-73103 {integer}))) - n-73715))))) - (c-73326 - (Tuple2-73032 + n-73791))))) + (c-73402 + (Tuple2-73108 {integer} - {ParamValue-73068} + {ParamValue-73147} 23 - (ParamInteger-73070 + (ParamInteger-73149 ((let - a-73726 - = Tuple2-73031 - PredKey-73050 - (List-73026 + a-73802 + = Tuple2-73107 + PredKey-73129 + (List-73102 integer) in - \(g-73727 : - all b-73728. - (a-73726 -> - b-73728 -> - b-73728) -> - b-73728 -> - b-73728) -> - g-73727 - {List-73026 - a-73726} - (\(ds-73729 : - a-73726) - (ds-73730 : - List-73026 - a-73726) -> - Cons-73028 - {a-73726} - ds-73729 - ds-73730) - (Nil-73027 - {a-73726})) - (/\a-73731 -> - \(c-73732 : - Tuple2-73031 - PredKey-73050 - (List-73026 + \(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 integer) -> - a-73731 -> - a-73731) - (n-73733 : - a-73731) -> - c-73732 - (Tuple2-73032 - {PredKey-73050} - {List-73026 + a-73807 -> + a-73807) + (n-73809 : + a-73807) -> + c-73808 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} - MinValue-73052 + MinValue-73131 ((let - a-73734 - = List-73026 + a-73810 + = List-73102 integer in - \(c-73735 : + \(c-73811 : integer -> - a-73734 -> - a-73734) - (n-73736 : - a-73734) -> - c-73735 + a-73810 -> + a-73810) + (n-73812 : + a-73810) -> + c-73811 100 - (c-73735 + (c-73811 0 - n-73736)) - (\(ds-73737 : + n-73812)) + (\(ds-73813 : integer) - (ds-73738 : - List-73026 + (ds-73814 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-73737 - ds-73738) - (Nil-73027 + ds-73813 + ds-73814) + (Nil-73103 {integer}))) - (c-73732 - (Tuple2-73032 - {PredKey-73050} - {List-73026 + (c-73808 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} - MaxValue-73051 + MaxValue-73130 ((let - a-73739 - = List-73026 + a-73815 + = List-73102 integer in - \(c-73740 : + \(c-73816 : integer -> - a-73739 -> - a-73739) - (n-73741 : - a-73739) -> - c-73740 + a-73815 -> + a-73815) + (n-73817 : + a-73815) -> + c-73816 200 - n-73741) - (\(ds-73742 : + n-73817) + (\(ds-73818 : integer) - (ds-73743 : - List-73026 + (ds-73819 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-73742 - ds-73743) - (Nil-73027 + ds-73818 + ds-73819) + (Nil-73103 {integer}))) - (c-73732 - (Tuple2-73032 - {PredKey-73050} - {List-73026 + (c-73808 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} - NotEqual-73053 + NotEqual-73132 ((let - a-73744 - = List-73026 + a-73820 + = List-73102 integer in - \(c-73745 : + \(c-73821 : integer -> - a-73744 -> - a-73744) - (n-73746 : - a-73744) -> - c-73745 + a-73820 -> + a-73820) + (n-73822 : + a-73820) -> + c-73821 0 - n-73746) - (\(ds-73747 : + n-73822) + (\(ds-73823 : integer) - (ds-73748 : - List-73026 + (ds-73824 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-73747 - ds-73748) - (Nil-73027 + ds-73823 + ds-73824) + (Nil-73103 {integer}))) - n-73733)))))) - (c-73326 - (Tuple2-73032 + n-73809)))))) + (c-73402 + (Tuple2-73108 {integer} - {ParamValue-73068} + {ParamValue-73147} 24 - (ParamInteger-73070 + (ParamInteger-73149 ((let - a-73749 - = Tuple2-73031 - PredKey-73050 - (List-73026 + a-73825 + = Tuple2-73107 + PredKey-73129 + (List-73102 integer) in - \(g-73750 : - all b-73751. - (a-73749 -> - b-73751 -> - b-73751) -> - b-73751 -> - b-73751) -> - g-73750 - {List-73026 - a-73749} - (\(ds-73752 : - a-73749) - (ds-73753 : - List-73026 - a-73749) -> - Cons-73028 - {a-73749} - ds-73752 - ds-73753) - (Nil-73027 - {a-73749})) - (/\a-73754 -> - \(c-73755 : - Tuple2-73031 - PredKey-73050 - (List-73026 + \(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 integer) -> - a-73754 -> - a-73754) - (n-73756 : - a-73754) -> - c-73755 - (Tuple2-73032 - {PredKey-73050} - {List-73026 + a-73830 -> + a-73830) + (n-73832 : + a-73830) -> + c-73831 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} - MinValue-73052 + MinValue-73131 ((let - a-73757 - = List-73026 + a-73833 + = List-73102 integer in - \(c-73758 : + \(c-73834 : integer -> - a-73757 -> - a-73757) - (n-73759 : - a-73757) -> - c-73758 + a-73833 -> + a-73833) + (n-73835 : + a-73833) -> + c-73834 1 - n-73759) - (\(ds-73760 : + n-73835) + (\(ds-73836 : integer) - (ds-73761 : - List-73026 + (ds-73837 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-73760 - ds-73761) - (Nil-73027 + ds-73836 + ds-73837) + (Nil-73103 {integer}))) - n-73756)))) - (c-73326 - (Tuple2-73032 + n-73832)))) + (c-73402 + (Tuple2-73108 {integer} - {ParamValue-73068} + {ParamValue-73147} 25 - (ParamList-73071 + (ParamList-73150 ((let - a-73762 - = List-73026 - ParamValue-73068 + a-73838 + = List-73102 + ParamValue-73147 in - \(c-73763 : - ParamValue-73068 -> - a-73762 -> - a-73762) - (n-73764 : - a-73762) -> - c-73763 - (ParamRational-73072 + \(c-73839 : + ParamValue-73147 -> + a-73838 -> + a-73838) + (n-73840 : + a-73838) -> + c-73839 + (ParamRational-73151 ((let - a-73765 - = Tuple2-73031 - PredKey-73050 - (List-73026 - Rational-73065) + a-73841 + = Tuple2-73107 + PredKey-73129 + (List-73102 + Rational-73144) in - \(g-73766 : - all b-73767. - (a-73765 -> - b-73767 -> - b-73767) -> - b-73767 -> - b-73767) -> - g-73766 - {List-73026 - a-73765} - (\(ds-73768 : - a-73765) - (ds-73769 : - List-73026 - a-73765) -> - Cons-73028 - {a-73765} - ds-73768 - ds-73769) - (Nil-73027 - {a-73765})) - (/\a-73770 -> - \(c-73771 : - Tuple2-73031 - PredKey-73050 - (List-73026 - Rational-73065) -> - a-73770 -> - a-73770) - (n-73772 : - a-73770) -> - c-73771 - (Tuple2-73032 - {PredKey-73050} - {List-73026 - Rational-73065} - MinValue-73052 + \(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 ((let - a-73773 - = List-73026 - Rational-73065 + a-73849 + = List-73102 + Rational-73144 in - \(c-73774 : - Rational-73065 -> - a-73773 -> - a-73773) - (n-73775 : - a-73773) -> - c-73774 - (unsafeRatio-73086 + \(c-73850 : + Rational-73144 -> + a-73849 -> + a-73849) + (n-73851 : + a-73849) -> + c-73850 + (unsafeRatio-73162 1 2) - (c-73774 - (unsafeRatio-73086 + (c-73850 + (unsafeRatio-73162 51 100) - n-73775)) - (\(ds-73776 : - Rational-73065) - (ds-73777 : - List-73026 - Rational-73065) -> - Cons-73028 - {Rational-73065} - ds-73776 - ds-73777) - (Nil-73027 - {Rational-73065}))) - (c-73771 - (Tuple2-73032 - {PredKey-73050} - {List-73026 - Rational-73065} - MaxValue-73051 + 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 ((let - a-73778 - = List-73026 - Rational-73065 + a-73854 + = List-73102 + Rational-73144 in - \(c-73779 : - Rational-73065 -> - a-73778 -> - a-73778) - (n-73780 : - a-73778) -> - c-73779 - (unsafeRatio-73086 + \(c-73855 : + Rational-73144 -> + a-73854 -> + a-73854) + (n-73856 : + a-73854) -> + c-73855 + (unsafeRatio-73162 1 1) - (c-73779 - (unsafeRatio-73086 + (c-73855 + (unsafeRatio-73162 3 4) - n-73780)) - (\(ds-73781 : - Rational-73065) - (ds-73782 : - List-73026 - Rational-73065) -> - Cons-73028 - {Rational-73065} - ds-73781 - ds-73782) - (Nil-73027 - {Rational-73065}))) - n-73772)))) - (c-73763 - (ParamRational-73072 + 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 ((let - a-73783 - = Tuple2-73031 - PredKey-73050 - (List-73026 - Rational-73065) + a-73859 + = Tuple2-73107 + PredKey-73129 + (List-73102 + Rational-73144) in - \(g-73784 : - all b-73785. - (a-73783 -> - b-73785 -> - b-73785) -> - b-73785 -> - b-73785) -> - g-73784 - {List-73026 - a-73783} - (\(ds-73786 : - a-73783) - (ds-73787 : - List-73026 - a-73783) -> - Cons-73028 - {a-73783} - ds-73786 - ds-73787) - (Nil-73027 - {a-73783})) - (/\a-73788 -> - \(c-73789 : - Tuple2-73031 - PredKey-73050 - (List-73026 - Rational-73065) -> - a-73788 -> - a-73788) - (n-73790 : - a-73788) -> - c-73789 - (Tuple2-73032 - {PredKey-73050} - {List-73026 - Rational-73065} - MinValue-73052 + \(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 ((let - a-73791 - = List-73026 - Rational-73065 + a-73867 + = List-73102 + Rational-73144 in - \(c-73792 : - Rational-73065 -> - a-73791 -> - a-73791) - (n-73793 : - a-73791) -> - c-73792 - (unsafeRatio-73086 + \(c-73868 : + Rational-73144 -> + a-73867 -> + a-73867) + (n-73869 : + a-73867) -> + c-73868 + (unsafeRatio-73162 1 2) - (c-73792 - (unsafeRatio-73086 + (c-73868 + (unsafeRatio-73162 13 20) - n-73793)) - (\(ds-73794 : - Rational-73065) - (ds-73795 : - List-73026 - Rational-73065) -> - Cons-73028 - {Rational-73065} - ds-73794 - ds-73795) - (Nil-73027 - {Rational-73065}))) - (c-73789 - (Tuple2-73032 - {PredKey-73050} - {List-73026 - Rational-73065} - MaxValue-73051 + 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 ((let - a-73796 - = List-73026 - Rational-73065 + a-73872 + = List-73102 + Rational-73144 in - \(c-73797 : - Rational-73065 -> - a-73796 -> - a-73796) - (n-73798 : - a-73796) -> - c-73797 - (unsafeRatio-73086 + \(c-73873 : + Rational-73144 -> + a-73872 -> + a-73872) + (n-73874 : + a-73872) -> + c-73873 + (unsafeRatio-73162 1 1) - (c-73797 - (unsafeRatio-73086 + (c-73873 + (unsafeRatio-73162 9 10) - n-73798)) - (\(ds-73799 : - Rational-73065) - (ds-73800 : - List-73026 - Rational-73065) -> - Cons-73028 - {Rational-73065} - ds-73799 - ds-73800) - (Nil-73027 - {Rational-73065}))) - n-73790)))) - (c-73763 - (ParamRational-73072 + 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 ((let - a-73801 - = Tuple2-73031 - PredKey-73050 - (List-73026 - Rational-73065) + a-73877 + = Tuple2-73107 + PredKey-73129 + (List-73102 + Rational-73144) in - \(g-73802 : - all b-73803. - (a-73801 -> - b-73803 -> - b-73803) -> - b-73803 -> - b-73803) -> - g-73802 - {List-73026 - a-73801} - (\(ds-73804 : - a-73801) - (ds-73805 : - List-73026 - a-73801) -> - Cons-73028 - {a-73801} - ds-73804 - ds-73805) - (Nil-73027 - {a-73801})) - (/\a-73806 -> - \(c-73807 : - Tuple2-73031 - PredKey-73050 - (List-73026 - Rational-73065) -> - a-73806 -> - a-73806) - (n-73808 : - a-73806) -> - c-73807 - (Tuple2-73032 - {PredKey-73050} - {List-73026 - Rational-73065} - MinValue-73052 + \(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 ((let - a-73809 - = List-73026 - Rational-73065 + a-73885 + = List-73102 + Rational-73144 in - \(c-73810 : - Rational-73065 -> - a-73809 -> - a-73809) - (n-73811 : - a-73809) -> - c-73810 - (unsafeRatio-73086 + \(c-73886 : + Rational-73144 -> + a-73885 -> + a-73885) + (n-73887 : + a-73885) -> + c-73886 + (unsafeRatio-73162 1 2) - (c-73810 - (unsafeRatio-73086 + (c-73886 + (unsafeRatio-73162 13 20) - n-73811)) - (\(ds-73812 : - Rational-73065) - (ds-73813 : - List-73026 - Rational-73065) -> - Cons-73028 - {Rational-73065} - ds-73812 - ds-73813) - (Nil-73027 - {Rational-73065}))) - (c-73807 - (Tuple2-73032 - {PredKey-73050} - {List-73026 - Rational-73065} - MaxValue-73051 + 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 ((let - a-73814 - = List-73026 - Rational-73065 + a-73890 + = List-73102 + Rational-73144 in - \(c-73815 : - Rational-73065 -> - a-73814 -> - a-73814) - (n-73816 : - a-73814) -> - c-73815 - (unsafeRatio-73086 + \(c-73891 : + Rational-73144 -> + a-73890 -> + a-73890) + (n-73892 : + a-73890) -> + c-73891 + (unsafeRatio-73162 1 1) - (c-73815 - (unsafeRatio-73086 + (c-73891 + (unsafeRatio-73162 9 10) - n-73816)) - (\(ds-73817 : - Rational-73065) - (ds-73818 : - List-73026 - Rational-73065) -> - Cons-73028 - {Rational-73065} - ds-73817 - ds-73818) - (Nil-73027 - {Rational-73065}))) - n-73808)))) - (c-73763 - (ParamRational-73072 + 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 ((let - a-73819 - = Tuple2-73031 - PredKey-73050 - (List-73026 - Rational-73065) + a-73895 + = Tuple2-73107 + PredKey-73129 + (List-73102 + Rational-73144) in - \(g-73820 : - all b-73821. - (a-73819 -> - b-73821 -> - b-73821) -> - b-73821 -> - b-73821) -> - g-73820 - {List-73026 - a-73819} - (\(ds-73822 : - a-73819) - (ds-73823 : - List-73026 - a-73819) -> - Cons-73028 - {a-73819} - ds-73822 - ds-73823) - (Nil-73027 - {a-73819})) - (/\a-73824 -> - \(c-73825 : - Tuple2-73031 - PredKey-73050 - (List-73026 - Rational-73065) -> - a-73824 -> - a-73824) - (n-73826 : - a-73824) -> - c-73825 - (Tuple2-73032 - {PredKey-73050} - {List-73026 - Rational-73065} - MinValue-73052 + \(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 ((let - a-73827 - = List-73026 - Rational-73065 + a-73903 + = List-73102 + Rational-73144 in - \(c-73828 : - Rational-73065 -> - a-73827 -> - a-73827) - (n-73829 : - a-73827) -> - c-73828 - (unsafeRatio-73086 + \(c-73904 : + Rational-73144 -> + a-73903 -> + a-73903) + (n-73905 : + a-73903) -> + c-73904 + (unsafeRatio-73162 1 2) - (c-73828 - (unsafeRatio-73086 + (c-73904 + (unsafeRatio-73162 51 100) - n-73829)) - (\(ds-73830 : - Rational-73065) - (ds-73831 : - List-73026 - Rational-73065) -> - Cons-73028 - {Rational-73065} - ds-73830 - ds-73831) - (Nil-73027 - {Rational-73065}))) - (c-73825 - (Tuple2-73032 - {PredKey-73050} - {List-73026 - Rational-73065} - MaxValue-73051 + 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 ((let - a-73832 - = List-73026 - Rational-73065 + a-73908 + = List-73102 + Rational-73144 in - \(c-73833 : - Rational-73065 -> - a-73832 -> - a-73832) - (n-73834 : - a-73832) -> - c-73833 - (unsafeRatio-73086 + \(c-73909 : + Rational-73144 -> + a-73908 -> + a-73908) + (n-73910 : + a-73908) -> + c-73909 + (unsafeRatio-73162 1 1) - (c-73833 - (unsafeRatio-73086 + (c-73909 + (unsafeRatio-73162 4 5) - n-73834)) - (\(ds-73835 : - Rational-73065) - (ds-73836 : - List-73026 - Rational-73065) -> - Cons-73028 - {Rational-73065} - ds-73835 - ds-73836) - (Nil-73027 - {Rational-73065}))) - n-73826)))) - (c-73763 - (ParamRational-73072 + 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 ((let - a-73837 - = Tuple2-73031 - PredKey-73050 - (List-73026 - Rational-73065) + a-73913 + = Tuple2-73107 + PredKey-73129 + (List-73102 + Rational-73144) in - \(g-73838 : - all b-73839. - (a-73837 -> - b-73839 -> - b-73839) -> - b-73839 -> - b-73839) -> - g-73838 - {List-73026 - a-73837} - (\(ds-73840 : - a-73837) - (ds-73841 : - List-73026 - a-73837) -> - Cons-73028 - {a-73837} - ds-73840 - ds-73841) - (Nil-73027 - {a-73837})) - (/\a-73842 -> - \(c-73843 : - Tuple2-73031 - PredKey-73050 - (List-73026 - Rational-73065) -> - a-73842 -> - a-73842) - (n-73844 : - a-73842) -> - c-73843 - (Tuple2-73032 - {PredKey-73050} - {List-73026 - Rational-73065} - MinValue-73052 + \(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 ((let - a-73845 - = List-73026 - Rational-73065 + a-73921 + = List-73102 + Rational-73144 in - \(c-73846 : - Rational-73065 -> - a-73845 -> - a-73845) - (n-73847 : - a-73845) -> - c-73846 - (unsafeRatio-73086 + \(c-73922 : + Rational-73144 -> + a-73921 -> + a-73921) + (n-73923 : + a-73921) -> + c-73922 + (unsafeRatio-73162 1 2) - n-73847) - (\(ds-73848 : - Rational-73065) - (ds-73849 : - List-73026 - Rational-73065) -> - Cons-73028 - {Rational-73065} - ds-73848 - ds-73849) - (Nil-73027 - {Rational-73065}))) - (c-73843 - (Tuple2-73032 - {PredKey-73050} - {List-73026 - Rational-73065} - MaxValue-73051 + 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 ((let - a-73850 - = List-73026 - Rational-73065 + a-73926 + = List-73102 + Rational-73144 in - \(c-73851 : - Rational-73065 -> - a-73850 -> - a-73850) - (n-73852 : - a-73850) -> - c-73851 - (unsafeRatio-73086 + \(c-73927 : + Rational-73144 -> + a-73926 -> + a-73926) + (n-73928 : + a-73926) -> + c-73927 + (unsafeRatio-73162 1 1) - n-73852) - (\(ds-73853 : - Rational-73065) - (ds-73854 : - List-73026 - Rational-73065) -> - Cons-73028 - {Rational-73065} - ds-73853 - ds-73854) - (Nil-73027 - {Rational-73065}))) - n-73844)))) - n-73764))))) - (\(ds-73855 : - ParamValue-73068) - (ds-73856 : - List-73026 - ParamValue-73068) -> - Cons-73028 - {ParamValue-73068} - ds-73855 - ds-73856) - (Nil-73027 - {ParamValue-73068})))) - (c-73326 - (Tuple2-73032 + 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 {integer} - {ParamValue-73068} + {ParamValue-73147} 26 - (ParamList-73071 + (ParamList-73150 ((let - a-73857 - = List-73026 - ParamValue-73068 + a-73933 + = List-73102 + ParamValue-73147 in - \(c-73858 : - ParamValue-73068 -> - a-73857 -> - a-73857) - (n-73859 : - a-73857) -> - c-73858 - (ParamRational-73072 + \(c-73934 : + ParamValue-73147 -> + a-73933 -> + a-73933) + (n-73935 : + a-73933) -> + c-73934 + (ParamRational-73151 ((let - a-73860 - = Tuple2-73031 - PredKey-73050 - (List-73026 - Rational-73065) + a-73936 + = Tuple2-73107 + PredKey-73129 + (List-73102 + Rational-73144) in - \(g-73861 : - all b-73862. - (a-73860 -> - b-73862 -> - b-73862) -> - b-73862 -> - b-73862) -> - g-73861 - {List-73026 - a-73860} - (\(ds-73863 : - a-73860) - (ds-73864 : - List-73026 - a-73860) -> - Cons-73028 - {a-73860} - ds-73863 - ds-73864) - (Nil-73027 - {a-73860})) - (/\a-73865 -> - \(c-73866 : - Tuple2-73031 - PredKey-73050 - (List-73026 - Rational-73065) -> - a-73865 -> - a-73865) - (n-73867 : - a-73865) -> - c-73866 - (Tuple2-73032 - {PredKey-73050} - {List-73026 - Rational-73065} - MinValue-73052 + \(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 ((let - a-73868 - = List-73026 - Rational-73065 + a-73944 + = List-73102 + Rational-73144 in - \(c-73869 : - Rational-73065 -> - a-73868 -> - a-73868) - (n-73870 : - a-73868) -> - c-73869 - (unsafeRatio-73086 + \(c-73945 : + Rational-73144 -> + a-73944 -> + a-73944) + (n-73946 : + a-73944) -> + c-73945 + (unsafeRatio-73162 1 2) - (c-73869 - (unsafeRatio-73086 + (c-73945 + (unsafeRatio-73162 51 100) - n-73870)) - (\(ds-73871 : - Rational-73065) - (ds-73872 : - List-73026 - Rational-73065) -> - Cons-73028 - {Rational-73065} - ds-73871 - ds-73872) - (Nil-73027 - {Rational-73065}))) - (c-73866 - (Tuple2-73032 - {PredKey-73050} - {List-73026 - Rational-73065} - MaxValue-73051 + 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 ((let - a-73873 - = List-73026 - Rational-73065 + a-73949 + = List-73102 + Rational-73144 in - \(c-73874 : - Rational-73065 -> - a-73873 -> - a-73873) - (n-73875 : - a-73873) -> - c-73874 - (unsafeRatio-73086 + \(c-73950 : + Rational-73144 -> + a-73949 -> + a-73949) + (n-73951 : + a-73949) -> + c-73950 + (unsafeRatio-73162 1 1) - (c-73874 - (unsafeRatio-73086 + (c-73950 + (unsafeRatio-73162 3 4) - n-73875)) - (\(ds-73876 : - Rational-73065) - (ds-73877 : - List-73026 - Rational-73065) -> - Cons-73028 - {Rational-73065} - ds-73876 - ds-73877) - (Nil-73027 - {Rational-73065}))) - n-73867)))) - (c-73858 - (ParamRational-73072 + 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 ((let - a-73878 - = Tuple2-73031 - PredKey-73050 - (List-73026 - Rational-73065) + a-73954 + = Tuple2-73107 + PredKey-73129 + (List-73102 + Rational-73144) in - \(g-73879 : - all b-73880. - (a-73878 -> - b-73880 -> - b-73880) -> - b-73880 -> - b-73880) -> - g-73879 - {List-73026 - a-73878} - (\(ds-73881 : - a-73878) - (ds-73882 : - List-73026 - a-73878) -> - Cons-73028 - {a-73878} - ds-73881 - ds-73882) - (Nil-73027 - {a-73878})) - (/\a-73883 -> - \(c-73884 : - Tuple2-73031 - PredKey-73050 - (List-73026 - Rational-73065) -> - a-73883 -> - a-73883) - (n-73885 : - a-73883) -> - c-73884 - (Tuple2-73032 - {PredKey-73050} - {List-73026 - Rational-73065} - MinValue-73052 + \(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 ((let - a-73886 - = List-73026 - Rational-73065 + a-73962 + = List-73102 + Rational-73144 in - \(c-73887 : - Rational-73065 -> - a-73886 -> - a-73886) - (n-73888 : - a-73886) -> - c-73887 - (unsafeRatio-73086 + \(c-73963 : + Rational-73144 -> + a-73962 -> + a-73962) + (n-73964 : + a-73962) -> + c-73963 + (unsafeRatio-73162 1 2) - (c-73887 - (unsafeRatio-73086 + (c-73963 + (unsafeRatio-73162 13 20) - n-73888)) - (\(ds-73889 : - Rational-73065) - (ds-73890 : - List-73026 - Rational-73065) -> - Cons-73028 - {Rational-73065} - ds-73889 - ds-73890) - (Nil-73027 - {Rational-73065}))) - (c-73884 - (Tuple2-73032 - {PredKey-73050} - {List-73026 - Rational-73065} - MaxValue-73051 + 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 ((let - a-73891 - = List-73026 - Rational-73065 + a-73967 + = List-73102 + Rational-73144 in - \(c-73892 : - Rational-73065 -> - a-73891 -> - a-73891) - (n-73893 : - a-73891) -> - c-73892 - (unsafeRatio-73086 + \(c-73968 : + Rational-73144 -> + a-73967 -> + a-73967) + (n-73969 : + a-73967) -> + c-73968 + (unsafeRatio-73162 1 1) - (c-73892 - (unsafeRatio-73086 + (c-73968 + (unsafeRatio-73162 9 10) - n-73893)) - (\(ds-73894 : - Rational-73065) - (ds-73895 : - List-73026 - Rational-73065) -> - Cons-73028 - {Rational-73065} - ds-73894 - ds-73895) - (Nil-73027 - {Rational-73065}))) - n-73885)))) - (c-73858 - (ParamRational-73072 + 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 ((let - a-73896 - = Tuple2-73031 - PredKey-73050 - (List-73026 - Rational-73065) + a-73972 + = Tuple2-73107 + PredKey-73129 + (List-73102 + Rational-73144) in - \(g-73897 : - all b-73898. - (a-73896 -> - b-73898 -> - b-73898) -> - b-73898 -> - b-73898) -> - g-73897 - {List-73026 - a-73896} - (\(ds-73899 : - a-73896) - (ds-73900 : - List-73026 - a-73896) -> - Cons-73028 - {a-73896} - ds-73899 - ds-73900) - (Nil-73027 - {a-73896})) - (/\a-73901 -> - \(c-73902 : - Tuple2-73031 - PredKey-73050 - (List-73026 - Rational-73065) -> - a-73901 -> - a-73901) - (n-73903 : - a-73901) -> - c-73902 - (Tuple2-73032 - {PredKey-73050} - {List-73026 - Rational-73065} - MinValue-73052 + \(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 ((let - a-73904 - = List-73026 - Rational-73065 + a-73980 + = List-73102 + Rational-73144 in - \(c-73905 : - Rational-73065 -> - a-73904 -> - a-73904) - (n-73906 : - a-73904) -> - c-73905 - (unsafeRatio-73086 + \(c-73981 : + Rational-73144 -> + a-73980 -> + a-73980) + (n-73982 : + a-73980) -> + c-73981 + (unsafeRatio-73162 1 2) - (c-73905 - (unsafeRatio-73086 + (c-73981 + (unsafeRatio-73162 13 20) - n-73906)) - (\(ds-73907 : - Rational-73065) - (ds-73908 : - List-73026 - Rational-73065) -> - Cons-73028 - {Rational-73065} - ds-73907 - ds-73908) - (Nil-73027 - {Rational-73065}))) - (c-73902 - (Tuple2-73032 - {PredKey-73050} - {List-73026 - Rational-73065} - MaxValue-73051 + 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 ((let - a-73909 - = List-73026 - Rational-73065 + a-73985 + = List-73102 + Rational-73144 in - \(c-73910 : - Rational-73065 -> - a-73909 -> - a-73909) - (n-73911 : - a-73909) -> - c-73910 - (unsafeRatio-73086 + \(c-73986 : + Rational-73144 -> + a-73985 -> + a-73985) + (n-73987 : + a-73985) -> + c-73986 + (unsafeRatio-73162 1 1) - (c-73910 - (unsafeRatio-73086 + (c-73986 + (unsafeRatio-73162 9 10) - n-73911)) - (\(ds-73912 : - Rational-73065) - (ds-73913 : - List-73026 - Rational-73065) -> - Cons-73028 - {Rational-73065} - ds-73912 - ds-73913) - (Nil-73027 - {Rational-73065}))) - n-73903)))) - (c-73858 - (ParamRational-73072 + 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 ((let - a-73914 - = Tuple2-73031 - PredKey-73050 - (List-73026 - Rational-73065) + a-73990 + = Tuple2-73107 + PredKey-73129 + (List-73102 + Rational-73144) in - \(g-73915 : - all b-73916. - (a-73914 -> - b-73916 -> - b-73916) -> - b-73916 -> - b-73916) -> - g-73915 - {List-73026 - a-73914} - (\(ds-73917 : - a-73914) - (ds-73918 : - List-73026 - a-73914) -> - Cons-73028 - {a-73914} - ds-73917 - ds-73918) - (Nil-73027 - {a-73914})) - (/\a-73919 -> - \(c-73920 : - Tuple2-73031 - PredKey-73050 - (List-73026 - Rational-73065) -> - a-73919 -> - a-73919) - (n-73921 : - a-73919) -> - c-73920 - (Tuple2-73032 - {PredKey-73050} - {List-73026 - Rational-73065} - MinValue-73052 + \(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 ((let - a-73922 - = List-73026 - Rational-73065 + a-73998 + = List-73102 + Rational-73144 in - \(c-73923 : - Rational-73065 -> - a-73922 -> - a-73922) - (n-73924 : - a-73922) -> - c-73923 - (unsafeRatio-73086 + \(c-73999 : + Rational-73144 -> + a-73998 -> + a-73998) + (n-74000 : + a-73998) -> + c-73999 + (unsafeRatio-73162 1 2) - (c-73923 - (unsafeRatio-73086 + (c-73999 + (unsafeRatio-73162 13 20) - n-73924)) - (\(ds-73925 : - Rational-73065) - (ds-73926 : - List-73026 - Rational-73065) -> - Cons-73028 - {Rational-73065} - ds-73925 - ds-73926) - (Nil-73027 - {Rational-73065}))) - (c-73920 - (Tuple2-73032 - {PredKey-73050} - {List-73026 - Rational-73065} - MaxValue-73051 + 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 ((let - a-73927 - = List-73026 - Rational-73065 + a-74003 + = List-73102 + Rational-73144 in - \(c-73928 : - Rational-73065 -> - a-73927 -> - a-73927) - (n-73929 : - a-73927) -> - c-73928 - (unsafeRatio-73086 + \(c-74004 : + Rational-73144 -> + a-74003 -> + a-74003) + (n-74005 : + a-74003) -> + c-74004 + (unsafeRatio-73162 1 1) - (c-73928 - (unsafeRatio-73086 + (c-74004 + (unsafeRatio-73162 9 10) - n-73929)) - (\(ds-73930 : - Rational-73065) - (ds-73931 : - List-73026 - Rational-73065) -> - Cons-73028 - {Rational-73065} - ds-73930 - ds-73931) - (Nil-73027 - {Rational-73065}))) - n-73921)))) - (c-73858 - (ParamRational-73072 + 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 ((let - a-73932 - = Tuple2-73031 - PredKey-73050 - (List-73026 - Rational-73065) + a-74008 + = Tuple2-73107 + PredKey-73129 + (List-73102 + Rational-73144) in - \(g-73933 : - all b-73934. - (a-73932 -> - b-73934 -> - b-73934) -> - b-73934 -> - b-73934) -> - g-73933 - {List-73026 - a-73932} - (\(ds-73935 : - a-73932) - (ds-73936 : - List-73026 - a-73932) -> - Cons-73028 - {a-73932} - ds-73935 - ds-73936) - (Nil-73027 - {a-73932})) - (/\a-73937 -> - \(c-73938 : - Tuple2-73031 - PredKey-73050 - (List-73026 - Rational-73065) -> - a-73937 -> - a-73937) - (n-73939 : - a-73937) -> - c-73938 - (Tuple2-73032 - {PredKey-73050} - {List-73026 - Rational-73065} - MinValue-73052 + \(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 ((let - a-73940 - = List-73026 - Rational-73065 + a-74016 + = List-73102 + Rational-73144 in - \(c-73941 : - Rational-73065 -> - a-73940 -> - a-73940) - (n-73942 : - a-73940) -> - c-73941 - (unsafeRatio-73086 + \(c-74017 : + Rational-73144 -> + a-74016 -> + a-74016) + (n-74018 : + a-74016) -> + c-74017 + (unsafeRatio-73162 1 2) - (c-73941 - (unsafeRatio-73086 + (c-74017 + (unsafeRatio-73162 51 100) - n-73942)) - (\(ds-73943 : - Rational-73065) - (ds-73944 : - List-73026 - Rational-73065) -> - Cons-73028 - {Rational-73065} - ds-73943 - ds-73944) - (Nil-73027 - {Rational-73065}))) - (c-73938 - (Tuple2-73032 - {PredKey-73050} - {List-73026 - Rational-73065} - MaxValue-73051 + 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 ((let - a-73945 - = List-73026 - Rational-73065 + a-74021 + = List-73102 + Rational-73144 in - \(c-73946 : - Rational-73065 -> - a-73945 -> - a-73945) - (n-73947 : - a-73945) -> - c-73946 - (unsafeRatio-73086 + \(c-74022 : + Rational-73144 -> + a-74021 -> + a-74021) + (n-74023 : + a-74021) -> + c-74022 + (unsafeRatio-73162 1 1) - (c-73946 - (unsafeRatio-73086 + (c-74022 + (unsafeRatio-73162 4 5) - n-73947)) - (\(ds-73948 : - Rational-73065) - (ds-73949 : - List-73026 - Rational-73065) -> - Cons-73028 - {Rational-73065} - ds-73948 - ds-73949) - (Nil-73027 - {Rational-73065}))) - n-73939)))) - (c-73858 - (ParamRational-73072 + 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 ((let - a-73950 - = Tuple2-73031 - PredKey-73050 - (List-73026 - Rational-73065) + a-74026 + = Tuple2-73107 + PredKey-73129 + (List-73102 + Rational-73144) in - \(g-73951 : - all b-73952. - (a-73950 -> - b-73952 -> - b-73952) -> - b-73952 -> - b-73952) -> - g-73951 - {List-73026 - a-73950} - (\(ds-73953 : - a-73950) - (ds-73954 : - List-73026 - a-73950) -> - Cons-73028 - {a-73950} - ds-73953 - ds-73954) - (Nil-73027 - {a-73950})) - (/\a-73955 -> - \(c-73956 : - Tuple2-73031 - PredKey-73050 - (List-73026 - Rational-73065) -> - a-73955 -> - a-73955) - (n-73957 : - a-73955) -> - c-73956 - (Tuple2-73032 - {PredKey-73050} - {List-73026 - Rational-73065} - MinValue-73052 + \(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 ((let - a-73958 - = List-73026 - Rational-73065 + a-74034 + = List-73102 + Rational-73144 in - \(c-73959 : - Rational-73065 -> - a-73958 -> - a-73958) - (n-73960 : - a-73958) -> - c-73959 - (unsafeRatio-73086 + \(c-74035 : + Rational-73144 -> + a-74034 -> + a-74034) + (n-74036 : + a-74034) -> + c-74035 + (unsafeRatio-73162 1 2) - (c-73959 - (unsafeRatio-73086 + (c-74035 + (unsafeRatio-73162 51 100) - n-73960)) - (\(ds-73961 : - Rational-73065) - (ds-73962 : - List-73026 - Rational-73065) -> - Cons-73028 - {Rational-73065} - ds-73961 - ds-73962) - (Nil-73027 - {Rational-73065}))) - (c-73956 - (Tuple2-73032 - {PredKey-73050} - {List-73026 - Rational-73065} - MaxValue-73051 + 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 ((let - a-73963 - = List-73026 - Rational-73065 + a-74039 + = List-73102 + Rational-73144 in - \(c-73964 : - Rational-73065 -> - a-73963 -> - a-73963) - (n-73965 : - a-73963) -> - c-73964 - (unsafeRatio-73086 + \(c-74040 : + Rational-73144 -> + a-74039 -> + a-74039) + (n-74041 : + a-74039) -> + c-74040 + (unsafeRatio-73162 1 1) - (c-73964 - (unsafeRatio-73086 + (c-74040 + (unsafeRatio-73162 3 4) - n-73965)) - (\(ds-73966 : - Rational-73065) - (ds-73967 : - List-73026 - Rational-73065) -> - Cons-73028 - {Rational-73065} - ds-73966 - ds-73967) - (Nil-73027 - {Rational-73065}))) - n-73957)))) - (c-73858 - (ParamRational-73072 + 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 ((let - a-73968 - = Tuple2-73031 - PredKey-73050 - (List-73026 - Rational-73065) + a-74044 + = Tuple2-73107 + PredKey-73129 + (List-73102 + Rational-73144) in - \(g-73969 : - all b-73970. - (a-73968 -> - b-73970 -> - b-73970) -> - b-73970 -> - b-73970) -> - g-73969 - {List-73026 - a-73968} - (\(ds-73971 : - a-73968) - (ds-73972 : - List-73026 - a-73968) -> - Cons-73028 - {a-73968} - ds-73971 - ds-73972) - (Nil-73027 - {a-73968})) - (/\a-73973 -> - \(c-73974 : - Tuple2-73031 - PredKey-73050 - (List-73026 - Rational-73065) -> - a-73973 -> - a-73973) - (n-73975 : - a-73973) -> - c-73974 - (Tuple2-73032 - {PredKey-73050} - {List-73026 - Rational-73065} - MinValue-73052 + \(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 ((let - a-73976 - = List-73026 - Rational-73065 + a-74052 + = List-73102 + Rational-73144 in - \(c-73977 : - Rational-73065 -> - a-73976 -> - a-73976) - (n-73978 : - a-73976) -> - c-73977 - (unsafeRatio-73086 + \(c-74053 : + Rational-73144 -> + a-74052 -> + a-74052) + (n-74054 : + a-74052) -> + c-74053 + (unsafeRatio-73162 1 2) - (c-73977 - (unsafeRatio-73086 + (c-74053 + (unsafeRatio-73162 51 100) - n-73978)) - (\(ds-73979 : - Rational-73065) - (ds-73980 : - List-73026 - Rational-73065) -> - Cons-73028 - {Rational-73065} - ds-73979 - ds-73980) - (Nil-73027 - {Rational-73065}))) - (c-73974 - (Tuple2-73032 - {PredKey-73050} - {List-73026 - Rational-73065} - MaxValue-73051 + 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 ((let - a-73981 - = List-73026 - Rational-73065 + a-74057 + = List-73102 + Rational-73144 in - \(c-73982 : - Rational-73065 -> - a-73981 -> - a-73981) - (n-73983 : - a-73981) -> - c-73982 - (unsafeRatio-73086 + \(c-74058 : + Rational-73144 -> + a-74057 -> + a-74057) + (n-74059 : + a-74057) -> + c-74058 + (unsafeRatio-73162 1 1) - (c-73982 - (unsafeRatio-73086 + (c-74058 + (unsafeRatio-73162 3 4) - n-73983)) - (\(ds-73984 : - Rational-73065) - (ds-73985 : - List-73026 - Rational-73065) -> - Cons-73028 - {Rational-73065} - ds-73984 - ds-73985) - (Nil-73027 - {Rational-73065}))) - n-73975)))) - (c-73858 - (ParamRational-73072 + 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 ((let - a-73986 - = Tuple2-73031 - PredKey-73050 - (List-73026 - Rational-73065) + a-74062 + = Tuple2-73107 + PredKey-73129 + (List-73102 + Rational-73144) in - \(g-73987 : - all b-73988. - (a-73986 -> - b-73988 -> - b-73988) -> - b-73988 -> - b-73988) -> - g-73987 - {List-73026 - a-73986} - (\(ds-73989 : - a-73986) - (ds-73990 : - List-73026 - a-73986) -> - Cons-73028 - {a-73986} - ds-73989 - ds-73990) - (Nil-73027 - {a-73986})) - (/\a-73991 -> - \(c-73992 : - Tuple2-73031 - PredKey-73050 - (List-73026 - Rational-73065) -> - a-73991 -> - a-73991) - (n-73993 : - a-73991) -> - c-73992 - (Tuple2-73032 - {PredKey-73050} - {List-73026 - Rational-73065} - MinValue-73052 + \(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 ((let - a-73994 - = List-73026 - Rational-73065 + a-74070 + = List-73102 + Rational-73144 in - \(c-73995 : - Rational-73065 -> - a-73994 -> - a-73994) - (n-73996 : - a-73994) -> - c-73995 - (unsafeRatio-73086 + \(c-74071 : + Rational-73144 -> + a-74070 -> + a-74070) + (n-74072 : + a-74070) -> + c-74071 + (unsafeRatio-73162 1 2) - (c-73995 - (unsafeRatio-73086 + (c-74071 + (unsafeRatio-73162 51 100) - n-73996)) - (\(ds-73997 : - Rational-73065) - (ds-73998 : - List-73026 - Rational-73065) -> - Cons-73028 - {Rational-73065} - ds-73997 - ds-73998) - (Nil-73027 - {Rational-73065}))) - (c-73992 - (Tuple2-73032 - {PredKey-73050} - {List-73026 - Rational-73065} - MaxValue-73051 + 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 ((let - a-73999 - = List-73026 - Rational-73065 + a-74075 + = List-73102 + Rational-73144 in - \(c-74000 : - Rational-73065 -> - a-73999 -> - a-73999) - (n-74001 : - a-73999) -> - c-74000 - (unsafeRatio-73086 + \(c-74076 : + Rational-73144 -> + a-74075 -> + a-74075) + (n-74077 : + a-74075) -> + c-74076 + (unsafeRatio-73162 1 1) - (c-74000 - (unsafeRatio-73086 + (c-74076 + (unsafeRatio-73162 3 4) - n-74001)) - (\(ds-74002 : - Rational-73065) - (ds-74003 : - List-73026 - Rational-73065) -> - Cons-73028 - {Rational-73065} - ds-74002 - ds-74003) - (Nil-73027 - {Rational-73065}))) - n-73993)))) - (c-73858 - (ParamRational-73072 + 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 ((let - a-74004 - = Tuple2-73031 - PredKey-73050 - (List-73026 - Rational-73065) + a-74080 + = Tuple2-73107 + PredKey-73129 + (List-73102 + Rational-73144) in - \(g-74005 : - all b-74006. - (a-74004 -> - b-74006 -> - b-74006) -> - b-74006 -> - b-74006) -> - g-74005 - {List-73026 - a-74004} - (\(ds-74007 : - a-74004) - (ds-74008 : - List-73026 - a-74004) -> - Cons-73028 - {a-74004} - ds-74007 - ds-74008) - (Nil-73027 - {a-74004})) - (/\a-74009 -> - \(c-74010 : - Tuple2-73031 - PredKey-73050 - (List-73026 - Rational-73065) -> - a-74009 -> - a-74009) - (n-74011 : - a-74009) -> - c-74010 - (Tuple2-73032 - {PredKey-73050} - {List-73026 - Rational-73065} - MinValue-73052 + \(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 ((let - a-74012 - = List-73026 - Rational-73065 + a-74088 + = List-73102 + Rational-73144 in - \(c-74013 : - Rational-73065 -> - a-74012 -> - a-74012) - (n-74014 : - a-74012) -> - c-74013 - (unsafeRatio-73086 + \(c-74089 : + Rational-73144 -> + a-74088 -> + a-74088) + (n-74090 : + a-74088) -> + c-74089 + (unsafeRatio-73162 1 2) - (c-74013 - (unsafeRatio-73086 + (c-74089 + (unsafeRatio-73162 3 4) - n-74014)) - (\(ds-74015 : - Rational-73065) - (ds-74016 : - List-73026 - Rational-73065) -> - Cons-73028 - {Rational-73065} - ds-74015 - ds-74016) - (Nil-73027 - {Rational-73065}))) - (c-74010 - (Tuple2-73032 - {PredKey-73050} - {List-73026 - Rational-73065} - MaxValue-73051 + 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 ((let - a-74017 - = List-73026 - Rational-73065 + a-74093 + = List-73102 + Rational-73144 in - \(c-74018 : - Rational-73065 -> - a-74017 -> - a-74017) - (n-74019 : - a-74017) -> - c-74018 - (unsafeRatio-73086 + \(c-74094 : + Rational-73144 -> + a-74093 -> + a-74093) + (n-74095 : + a-74093) -> + c-74094 + (unsafeRatio-73162 1 1) - (c-74018 - (unsafeRatio-73086 + (c-74094 + (unsafeRatio-73162 9 10) - n-74019)) - (\(ds-74020 : - Rational-73065) - (ds-74021 : - List-73026 - Rational-73065) -> - Cons-73028 - {Rational-73065} - ds-74020 - ds-74021) - (Nil-73027 - {Rational-73065}))) - n-74011)))) - (c-73858 - (ParamRational-73072 + 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 ((let - a-74022 - = Tuple2-73031 - PredKey-73050 - (List-73026 - Rational-73065) + a-74098 + = Tuple2-73107 + PredKey-73129 + (List-73102 + Rational-73144) in - \(g-74023 : - all b-74024. - (a-74022 -> - b-74024 -> - b-74024) -> - b-74024 -> - b-74024) -> - g-74023 - {List-73026 - a-74022} - (\(ds-74025 : - a-74022) - (ds-74026 : - List-73026 - a-74022) -> - Cons-73028 - {a-74022} - ds-74025 - ds-74026) - (Nil-73027 - {a-74022})) - (/\a-74027 -> - \(c-74028 : - Tuple2-73031 - PredKey-73050 - (List-73026 - Rational-73065) -> - a-74027 -> - a-74027) - (n-74029 : - a-74027) -> - c-74028 - (Tuple2-73032 - {PredKey-73050} - {List-73026 - Rational-73065} - MinValue-73052 + \(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 ((let - a-74030 - = List-73026 - Rational-73065 + a-74106 + = List-73102 + Rational-73144 in - \(c-74031 : - Rational-73065 -> - a-74030 -> - a-74030) - (n-74032 : - a-74030) -> - c-74031 - (unsafeRatio-73086 + \(c-74107 : + Rational-73144 -> + a-74106 -> + a-74106) + (n-74108 : + a-74106) -> + c-74107 + (unsafeRatio-73162 1 2) - n-74032) - (\(ds-74033 : - Rational-73065) - (ds-74034 : - List-73026 - Rational-73065) -> - Cons-73028 - {Rational-73065} - ds-74033 - ds-74034) - (Nil-73027 - {Rational-73065}))) - (c-74028 - (Tuple2-73032 - {PredKey-73050} - {List-73026 - Rational-73065} - MaxValue-73051 + 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 ((let - a-74035 - = List-73026 - Rational-73065 + a-74111 + = List-73102 + Rational-73144 in - \(c-74036 : - Rational-73065 -> - a-74035 -> - a-74035) - (n-74037 : - a-74035) -> - c-74036 - (unsafeRatio-73086 + \(c-74112 : + Rational-73144 -> + a-74111 -> + a-74111) + (n-74113 : + a-74111) -> + c-74112 + (unsafeRatio-73162 1 1) - n-74037) - (\(ds-74038 : - Rational-73065) - (ds-74039 : - List-73026 - Rational-73065) -> - Cons-73028 - {Rational-73065} - ds-74038 - ds-74039) - (Nil-73027 - {Rational-73065}))) - n-74029)))) - n-73859)))))))))) - (\(ds-74040 : - ParamValue-73068) - (ds-74041 : - List-73026 - ParamValue-73068) -> - Cons-73028 - {ParamValue-73068} - ds-74040 - ds-74041) - (Nil-73027 - {ParamValue-73068})))) - (c-73326 - (Tuple2-73032 + 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 {integer} - {ParamValue-73068} + {ParamValue-73147} 27 - (ParamInteger-73070 + (ParamInteger-73149 ((let - a-74042 - = Tuple2-73031 - PredKey-73050 - (List-73026 + a-74118 + = Tuple2-73107 + PredKey-73129 + (List-73102 integer) in - \(g-74043 : - all b-74044. - (a-74042 -> - b-74044 -> - b-74044) -> - b-74044 -> - b-74044) -> - g-74043 - {List-73026 - a-74042} - (\(ds-74045 : - a-74042) - (ds-74046 : - List-73026 - a-74042) -> - Cons-73028 - {a-74042} - ds-74045 - ds-74046) - (Nil-73027 - {a-74042})) - (/\a-74047 -> - \(c-74048 : - Tuple2-73031 - PredKey-73050 - (List-73026 + \(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 integer) -> - a-74047 -> - a-74047) - (n-74049 : - a-74047) -> - c-74048 - (Tuple2-73032 - {PredKey-73050} - {List-73026 + a-74123 -> + a-74123) + (n-74125 : + a-74123) -> + c-74124 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} - MinValue-73052 + MinValue-73131 ((let - a-74050 - = List-73026 + a-74126 + = List-73102 integer in - \(c-74051 : + \(c-74127 : integer -> - a-74050 -> - a-74050) - (n-74052 : - a-74050) -> - c-74051 + a-74126 -> + a-74126) + (n-74128 : + a-74126) -> + c-74127 0 - (c-74051 + (c-74127 3 - n-74052)) - (\(ds-74053 : + n-74128)) + (\(ds-74129 : integer) - (ds-74054 : - List-73026 + (ds-74130 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-74053 - ds-74054) - (Nil-73027 + ds-74129 + ds-74130) + (Nil-73103 {integer}))) - (c-74048 - (Tuple2-73032 - {PredKey-73050} - {List-73026 + (c-74124 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} - MaxValue-73051 + MaxValue-73130 ((let - a-74055 - = List-73026 + a-74131 + = List-73102 integer in - \(c-74056 : + \(c-74132 : integer -> - a-74055 -> - a-74055) - (n-74057 : - a-74055) -> - c-74056 + a-74131 -> + a-74131) + (n-74133 : + a-74131) -> + c-74132 10 - n-74057) - (\(ds-74058 : + n-74133) + (\(ds-74134 : integer) - (ds-74059 : - List-73026 + (ds-74135 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-74058 - ds-74059) - (Nil-73027 + ds-74134 + ds-74135) + (Nil-73103 {integer}))) - n-74049))))) - (c-73326 - (Tuple2-73032 + n-74125))))) + (c-73402 + (Tuple2-73108 {integer} - {ParamValue-73068} + {ParamValue-73147} 28 - (ParamInteger-73070 + (ParamInteger-73149 ((let - a-74060 - = Tuple2-73031 - PredKey-73050 - (List-73026 + a-74136 + = Tuple2-73107 + PredKey-73129 + (List-73102 integer) in - \(g-74061 : - all b-74062. - (a-74060 -> - b-74062 -> - b-74062) -> - b-74062 -> - b-74062) -> - g-74061 - {List-73026 - a-74060} - (\(ds-74063 : - a-74060) - (ds-74064 : - List-73026 - a-74060) -> - Cons-73028 - {a-74060} - ds-74063 - ds-74064) - (Nil-73027 - {a-74060})) - (/\a-74065 -> - \(c-74066 : - Tuple2-73031 - PredKey-73050 - (List-73026 + \(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 integer) -> - a-74065 -> - a-74065) - (n-74067 : - a-74065) -> - c-74066 - (Tuple2-73032 - {PredKey-73050} - {List-73026 + a-74141 -> + a-74141) + (n-74143 : + a-74141) -> + c-74142 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} - MinValue-73052 + MinValue-73131 ((let - a-74068 - = List-73026 + a-74144 + = List-73102 integer in - \(c-74069 : + \(c-74145 : integer -> - a-74068 -> - a-74068) - (n-74070 : - a-74068) -> - c-74069 + a-74144 -> + a-74144) + (n-74146 : + a-74144) -> + c-74145 0 - (c-74069 + (c-74145 18 - n-74070)) - (\(ds-74071 : + n-74146)) + (\(ds-74147 : integer) - (ds-74072 : - List-73026 + (ds-74148 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-74071 - ds-74072) - (Nil-73027 + ds-74147 + ds-74148) + (Nil-73103 {integer}))) - (c-74066 - (Tuple2-73032 - {PredKey-73050} - {List-73026 + (c-74142 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} - MaxValue-73051 + MaxValue-73130 ((let - a-74073 - = List-73026 + a-74149 + = List-73102 integer in - \(c-74074 : + \(c-74150 : integer -> - a-74073 -> - a-74073) - (n-74075 : - a-74073) -> - c-74074 + a-74149 -> + a-74149) + (n-74151 : + a-74149) -> + c-74150 293 - n-74075) - (\(ds-74076 : + n-74151) + (\(ds-74152 : integer) - (ds-74077 : - List-73026 + (ds-74153 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-74076 - ds-74077) - (Nil-73027 + ds-74152 + ds-74153) + (Nil-73103 {integer}))) - (c-74066 - (Tuple2-73032 - {PredKey-73050} - {List-73026 + (c-74142 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} - NotEqual-73053 + NotEqual-73132 ((let - a-74078 - = List-73026 + a-74154 + = List-73102 integer in - \(c-74079 : + \(c-74155 : integer -> - a-74078 -> - a-74078) - (n-74080 : - a-74078) -> - c-74079 + a-74154 -> + a-74154) + (n-74156 : + a-74154) -> + c-74155 0 - n-74080) - (\(ds-74081 : + n-74156) + (\(ds-74157 : integer) - (ds-74082 : - List-73026 + (ds-74158 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-74081 - ds-74082) - (Nil-73027 + ds-74157 + ds-74158) + (Nil-73103 {integer}))) - n-74067)))))) - (c-73326 - (Tuple2-73032 + n-74143)))))) + (c-73402 + (Tuple2-73108 {integer} - {ParamValue-73068} + {ParamValue-73147} 29 - (ParamInteger-73070 + (ParamInteger-73149 ((let - a-74083 - = Tuple2-73031 - PredKey-73050 - (List-73026 + a-74159 + = Tuple2-73107 + PredKey-73129 + (List-73102 integer) in - \(g-74084 : - all b-74085. - (a-74083 -> - b-74085 -> - b-74085) -> - b-74085 -> - b-74085) -> - g-74084 - {List-73026 - a-74083} - (\(ds-74086 : - a-74083) - (ds-74087 : - List-73026 - a-74083) -> - Cons-73028 - {a-74083} - ds-74086 - ds-74087) - (Nil-73027 - {a-74083})) - (/\a-74088 -> - \(c-74089 : - Tuple2-73031 - PredKey-73050 - (List-73026 + \(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 integer) -> - a-74088 -> - a-74088) - (n-74090 : - a-74088) -> - c-74089 - (Tuple2-73032 - {PredKey-73050} - {List-73026 + a-74164 -> + a-74164) + (n-74166 : + a-74164) -> + c-74165 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} - MinValue-73052 + MinValue-73131 ((let - a-74091 - = List-73026 + a-74167 + = List-73102 integer in - \(c-74092 : + \(c-74168 : integer -> - a-74091 -> - a-74091) - (n-74093 : - a-74091) -> - c-74092 + a-74167 -> + a-74167) + (n-74169 : + a-74167) -> + c-74168 1 - n-74093) - (\(ds-74094 : + n-74169) + (\(ds-74170 : integer) - (ds-74095 : - List-73026 + (ds-74171 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-74094 - ds-74095) - (Nil-73027 + ds-74170 + ds-74171) + (Nil-73103 {integer}))) - (c-74089 - (Tuple2-73032 - {PredKey-73050} - {List-73026 + (c-74165 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} - MaxValue-73051 + MaxValue-73130 ((let - a-74096 - = List-73026 + a-74172 + = List-73102 integer in - \(c-74097 : + \(c-74173 : integer -> - a-74096 -> - a-74096) - (n-74098 : - a-74096) -> - c-74097 + a-74172 -> + a-74172) + (n-74174 : + a-74172) -> + c-74173 15 - n-74098) - (\(ds-74099 : + n-74174) + (\(ds-74175 : integer) - (ds-74100 : - List-73026 + (ds-74176 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-74099 - ds-74100) - (Nil-73027 + ds-74175 + ds-74176) + (Nil-73103 {integer}))) - n-74090))))) - (c-73326 - (Tuple2-73032 + n-74166))))) + (c-73402 + (Tuple2-73108 {integer} - {ParamValue-73068} + {ParamValue-73147} 30 - (ParamInteger-73070 + (ParamInteger-73149 ((let - a-74101 - = Tuple2-73031 - PredKey-73050 - (List-73026 + a-74177 + = Tuple2-73107 + PredKey-73129 + (List-73102 integer) in - \(g-74102 : - all b-74103. - (a-74101 -> - b-74103 -> - b-74103) -> - b-74103 -> - b-74103) -> - g-74102 - {List-73026 - a-74101} - (\(ds-74104 : - a-74101) - (ds-74105 : - List-73026 - a-74101) -> - Cons-73028 - {a-74101} - ds-74104 - ds-74105) - (Nil-73027 - {a-74101})) - (/\a-74106 -> - \(c-74107 : - Tuple2-73031 - PredKey-73050 - (List-73026 + \(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 integer) -> - a-74106 -> - a-74106) - (n-74108 : - a-74106) -> - c-74107 - (Tuple2-73032 - {PredKey-73050} - {List-73026 + a-74182 -> + a-74182) + (n-74184 : + a-74182) -> + c-74183 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} - MinValue-73052 + MinValue-73131 ((let - a-74109 - = List-73026 + a-74185 + = List-73102 integer in - \(c-74110 : + \(c-74186 : integer -> - a-74109 -> - a-74109) - (n-74111 : - a-74109) -> - c-74110 + a-74185 -> + a-74185) + (n-74187 : + a-74185) -> + c-74186 0 - (c-74110 + (c-74186 1000000 - n-74111)) - (\(ds-74112 : + n-74187)) + (\(ds-74188 : integer) - (ds-74113 : - List-73026 + (ds-74189 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-74112 - ds-74113) - (Nil-73027 + ds-74188 + ds-74189) + (Nil-73103 {integer}))) - (c-74107 - (Tuple2-73032 - {PredKey-73050} - {List-73026 + (c-74183 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} - MaxValue-73051 + MaxValue-73130 ((let - a-74114 - = List-73026 + a-74190 + = List-73102 integer in - \(c-74115 : + \(c-74191 : integer -> - a-74114 -> - a-74114) - (n-74116 : - a-74114) -> - c-74115 + a-74190 -> + a-74190) + (n-74192 : + a-74190) -> + c-74191 10000000000000 - n-74116) - (\(ds-74117 : + n-74192) + (\(ds-74193 : integer) - (ds-74118 : - List-73026 + (ds-74194 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-74117 - ds-74118) - (Nil-73027 + ds-74193 + ds-74194) + (Nil-73103 {integer}))) - n-74108))))) - (c-73326 - (Tuple2-73032 + n-74184))))) + (c-73402 + (Tuple2-73108 {integer} - {ParamValue-73068} + {ParamValue-73147} 31 - (ParamInteger-73070 + (ParamInteger-73149 ((let - a-74119 - = Tuple2-73031 - PredKey-73050 - (List-73026 + a-74195 + = Tuple2-73107 + PredKey-73129 + (List-73102 integer) in - \(g-74120 : - all b-74121. - (a-74119 -> - b-74121 -> - b-74121) -> - b-74121 -> - b-74121) -> - g-74120 - {List-73026 - a-74119} - (\(ds-74122 : - a-74119) - (ds-74123 : - List-73026 - a-74119) -> - Cons-73028 - {a-74119} - ds-74122 - ds-74123) - (Nil-73027 - {a-74119})) - (/\a-74124 -> - \(c-74125 : - Tuple2-73031 - PredKey-73050 - (List-73026 + \(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 integer) -> - a-74124 -> - a-74124) - (n-74126 : - a-74124) -> - c-74125 - (Tuple2-73032 - {PredKey-73050} - {List-73026 + a-74200 -> + a-74200) + (n-74202 : + a-74200) -> + c-74201 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} - MinValue-73052 + MinValue-73131 ((let - a-74127 - = List-73026 + a-74203 + = List-73102 integer in - \(c-74128 : + \(c-74204 : integer -> - a-74127 -> - a-74127) - (n-74129 : - a-74127) -> - c-74128 + a-74203 -> + a-74203) + (n-74205 : + a-74203) -> + c-74204 0 - (c-74128 + (c-74204 1000000 - n-74129)) - (\(ds-74130 : + n-74205)) + (\(ds-74206 : integer) - (ds-74131 : - List-73026 + (ds-74207 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-74130 - ds-74131) - (Nil-73027 + ds-74206 + ds-74207) + (Nil-73103 {integer}))) - (c-74125 - (Tuple2-73032 - {PredKey-73050} - {List-73026 + (c-74201 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} - MaxValue-73051 + MaxValue-73130 ((let - a-74132 - = List-73026 + a-74208 + = List-73102 integer in - \(c-74133 : + \(c-74209 : integer -> - a-74132 -> - a-74132) - (n-74134 : - a-74132) -> - c-74133 + a-74208 -> + a-74208) + (n-74210 : + a-74208) -> + c-74209 100000000000 - n-74134) - (\(ds-74135 : + n-74210) + (\(ds-74211 : integer) - (ds-74136 : - List-73026 + (ds-74212 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-74135 - ds-74136) - (Nil-73027 + ds-74211 + ds-74212) + (Nil-73103 {integer}))) - n-74126))))) - (c-73326 - (Tuple2-73032 + n-74202))))) + (c-73402 + (Tuple2-73108 {integer} - {ParamValue-73068} + {ParamValue-73147} 32 - (ParamInteger-73070 + (ParamInteger-73149 ((let - a-74137 - = Tuple2-73031 - PredKey-73050 - (List-73026 + a-74213 + = Tuple2-73107 + PredKey-73129 + (List-73102 integer) in - \(g-74138 : - all b-74139. - (a-74137 -> - b-74139 -> - b-74139) -> - b-74139 -> - b-74139) -> - g-74138 - {List-73026 - a-74137} - (\(ds-74140 : - a-74137) - (ds-74141 : - List-73026 - a-74137) -> - Cons-73028 - {a-74137} - ds-74140 - ds-74141) - (Nil-73027 - {a-74137})) - (/\a-74142 -> - \(c-74143 : - Tuple2-73031 - PredKey-73050 - (List-73026 + \(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 integer) -> - a-74142 -> - a-74142) - (n-74144 : - a-74142) -> - c-74143 - (Tuple2-73032 - {PredKey-73050} - {List-73026 + a-74218 -> + a-74218) + (n-74220 : + a-74218) -> + c-74219 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} - MinValue-73052 + MinValue-73131 ((let - a-74145 - = List-73026 + a-74221 + = List-73102 integer in - \(c-74146 : + \(c-74222 : integer -> - a-74145 -> - a-74145) - (n-74147 : - a-74145) -> - c-74146 + a-74221 -> + a-74221) + (n-74223 : + a-74221) -> + c-74222 13 - (c-74146 + (c-74222 0 - n-74147)) - (\(ds-74148 : + n-74223)) + (\(ds-74224 : integer) - (ds-74149 : - List-73026 + (ds-74225 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-74148 - ds-74149) - (Nil-73027 + ds-74224 + ds-74225) + (Nil-73103 {integer}))) - (c-74143 - (Tuple2-73032 - {PredKey-73050} - {List-73026 + (c-74219 + (Tuple2-73108 + {PredKey-73129} + {List-73102 integer} - MaxValue-73051 + MaxValue-73130 ((let - a-74150 - = List-73026 + a-74226 + = List-73102 integer in - \(c-74151 : + \(c-74227 : integer -> - a-74150 -> - a-74150) - (n-74152 : - a-74150) -> - c-74151 + a-74226 -> + a-74226) + (n-74228 : + a-74226) -> + c-74227 37 - n-74152) - (\(ds-74153 : + n-74228) + (\(ds-74229 : integer) - (ds-74154 : - List-73026 + (ds-74230 : + List-73102 integer) -> - Cons-73028 + Cons-73104 {integer} - ds-74153 - ds-74154) - (Nil-73027 + ds-74229 + ds-74230) + (Nil-73103 {integer}))) - n-74144))))) - (c-73326 - (Tuple2-73032 + n-74220))))) + (c-73402 + (Tuple2-73108 {integer} - {ParamValue-73068} + {ParamValue-73147} 33 - (ParamInteger-73070 + (ParamRational-73151 ((let - a-74155 - = Tuple2-73031 - PredKey-73050 - (List-73026 - integer) + a-74231 + = Tuple2-73107 + PredKey-73129 + (List-73102 + Rational-73144) in - \(g-74156 : - all b-74157. - (a-74155 -> - b-74157 -> - b-74157) -> - b-74157 -> - b-74157) -> - g-74156 - {List-73026 - a-74155} - (\(ds-74158 : - a-74155) - (ds-74159 : - List-73026 - a-74155) -> - Cons-73028 - {a-74155} - ds-74158 - ds-74159) - (Nil-73027 - {a-74155})) - (/\a-74160 -> - \(c-74161 : - Tuple2-73031 - PredKey-73050 - (List-73026 - integer) -> - a-74160 -> - a-74160) - (n-74162 : - a-74160) -> - c-74161 - (Tuple2-73032 - {PredKey-73050} - {List-73026 - integer} - MinValue-73052 + \(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 ((let - a-74163 - = List-73026 - integer + a-74239 + = List-73102 + Rational-73144 in - \(c-74164 : - integer -> - a-74163 -> - a-74163) - (n-74165 : - a-74163) -> - c-74164 - 0 - n-74165) - (\(ds-74166 : - integer) - (ds-74167 : - List-73026 - integer) -> - Cons-73028 - {integer} - ds-74166 - ds-74167) - (Nil-73027 - {integer}))) - (c-74161 - (Tuple2-73032 - {PredKey-73050} - {List-73026 - integer} - MaxValue-73051 + \(c-74240 : + Rational-73144 -> + a-74239 -> + a-74239) + (n-74241 : + a-74239) -> + c-74240 + (unsafeRatio-73162 + 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 ((let - a-74168 - = List-73026 - integer + a-74244 + = List-73102 + Rational-73144 in - \(c-74169 : - integer -> - a-74168 -> - a-74168) - (n-74170 : - a-74168) -> - c-74169 - 1000 - n-74170) - (\(ds-74171 : - integer) - (ds-74172 : - List-73026 - integer) -> - Cons-73028 - {integer} - ds-74171 - ds-74172) - (Nil-73027 - {integer}))) - n-74162))))) - n-73327))))))))))))))))))))))))))))))) + \(c-74245 : + Rational-73144 -> + a-74244 -> + a-74244) + (n-74246 : + a-74244) -> + c-74245 + (unsafeRatio-73162 + 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))))))))))))))))))))))))))))))) in - \(ds-74174 : data) -> - Maybe_match-73044 - {List-73026 (Tuple2-73031 data data)} + \(ds-74250 : data) -> + Maybe_match-73120 + {List-73102 (Tuple2-73107 data data)} (let - !ds-74181 : data + !ds-74257 : data = headList {data} (tailList @@ -5722,7 +5726,7 @@ program {list data} (unConstrData (let - !ds-74175 : data + !ds-74251 : data = headList {data} (tailList @@ -5732,69 +5736,69 @@ program (sndPair {integer} {list data} - (unConstrData ds-74174)))) - ~si-74176 : pair integer (list data) - = unConstrData ds-74175 + (unConstrData ds-74250)))) + ~si-74252 : pair integer (list data) + = unConstrData ds-74251 in - Bool_match-73049 + Bool_match-73125 (ifThenElse - {Bool-73046} + {Bool-73122} (equalsInteger 5 - (fstPair {integer} {list data} si-74176)) - True-73047 - False-73048) - {all dead-74177. data} - (/\dead-74178 -> + (fstPair {integer} {list data} si-74252)) + True-73123 + False-73124) + {all dead-74253. data} + (/\dead-74254 -> headList {data} (tailList {data} - (sndPair {integer} {list data} si-74176))) - (/\dead-74179 -> error {data}) - {all dead-74180. dead-74180}))))) - ~ds-74182 : pair integer (list data) = unConstrData ds-74181 - !x-74183 : integer = fstPair {integer} {list data} ds-74182 + (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 in - Bool_match-73049 + Bool_match-73125 (ifThenElse - {Bool-73046} - (equalsInteger 0 x-74183) - True-73047 - False-73048) - {all dead-74184. Maybe-73041 (List-73026 (Tuple2-73031 data data))} - (/\dead-74185 -> - Just-73042 - {List-73026 (Tuple2-73031 data data)} - (go-73036 + {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 (unMapData (headList {data} (tailList {data} - (sndPair {integer} {list data} ds-74182)))))) - (/\dead-74186 -> - Bool_match-73049 + (sndPair {integer} {list data} ds-74258)))))) + (/\dead-74262 -> + Bool_match-73125 (ifThenElse - {Bool-73046} - (equalsInteger 2 x-74183) - True-73047 - False-73048) - {all dead-74187. Maybe-73041 (List-73026 (Tuple2-73031 data data))} - (/\dead-74188 -> - Nothing-73043 {List-73026 (Tuple2-73031 data data)}) - (/\dead-74189 -> - error {Maybe-73041 (List-73026 (Tuple2-73031 data data))}) - {all dead-74190. dead-74190}) - {all dead-74191. dead-74191}) - {all dead-74192. unit} - (\(cparams-74193 : List-73026 (Tuple2-73031 data data)) -> - /\dead-74194 -> - Bool_match-73049 - (fun-74173 cparams-74193) - {all dead-74195. unit} - (/\dead-74196 -> ()) - (/\dead-74197 -> error {unit}) - {all dead-74198. dead-74198}) - (/\dead-74199 -> ()) - {all dead-74200. dead-74200}) + {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 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 f13a8433773..444862379d0 100644 --- a/cardano-constitution/test/Cardano/Constitution/Validator/GoldenTests/sorted.uplc.golden +++ b/cardano-constitution/test/Cardano/Constitution/Validator/GoldenTests/sorted.uplc.golden @@ -42,839 +42,848 @@ program (\cse!0 -> (\cse!0 -> (\cse!0 -> - (\cse!0 -> - (\cse!0 -> - (\fun!0 - ds!0 -> - force - (case - ((\cse!0 -> - (\x!0 -> - force - (force - (force - ifThenElse - (equalsInteger - 0 - x!1) - (delay - (delay - (constr 0 - [ (go!38 - (unMapData + (\fun!0 + ds!0 -> + force + (case + ((\cse!0 -> + (\x!0 -> + force + (force + (force + ifThenElse + (equalsInteger + 0 + x!1) + (delay + (delay + (constr 0 + [ (go!36 + (unMapData + (force + headList + (force + tailList (force - headList (force - tailList - (force - (force - sndPair) - cse!2))))) ]))) - (delay - (delay + sndPair) + cse!2))))) ]))) + (delay + (delay + (force + (force (force - (force - (force - ifThenElse - (equalsInteger - 2 - x!1) - (delay - (delay - (constr 1 - [ ]))) - (delay - (delay - error)))))))))) - (force - (force - fstPair) - cse!1)) - (unConstrData + ifThenElse + (equalsInteger + 2 + x!1) + (delay + (delay + (constr 1 + [ ]))) + (delay + (delay + error)))))))))) + (force + (force + fstPair) + cse!1)) + (unConstrData + (force + headList + (force + tailList (force - headList + tailList (force - tailList (force - tailList - (force - (force - sndPair) - (unConstrData - ((\cse!0 -> - force - (force + sndPair) + (unConstrData + ((\cse!0 -> + force + (force + (force + ifThenElse + (equalsInteger + 5 (force - ifThenElse - (equalsInteger - 5 + (force + fstPair) + cse!1)) + (delay + (delay + (force + headList (force + tailList (force - fstPair) - cse!1)) - (delay - (delay - (force - headList (force - tailList - (force - (force - sndPair) - cse!1))))) - (delay - (delay - error))))) - (unConstrData + sndPair) + cse!1))))) + (delay + (delay + error))))) + (unConstrData + (force + headList + (force + tailList (force - headList + tailList (force - tailList (force - tailList - (force - (force - sndPair) - (unConstrData - ds!1)))))))))))))) - [ (\cparams!0 -> - delay - (force - (case - (fun!3 - cparams!1) - [ (delay - ()) - , (delay - error) ]))) - , (delay - ()) ])) - (runRules!35 - (constr 1 - [ (constr 0 - [ 0 - , (constr 1 - [ (constr 1 - [ (constr 0 - [ (constr 1 - [ ]) - , (constr 1 - [ 30 - , cse!29 ]) ]) - , cse!13 ]) ]) ]) - , (constr 1 - [ (constr 0 - [ 1 - , (constr 1 - [ (constr 1 - [ (constr 0 - [ (constr 1 - [ ]) - , (constr 1 - [ 100000 - , cse!29 ]) ]) - , (constr 1 - [ (constr 0 - [ (constr 0 - [ ]) - , (constr 1 - [ 10000000 - , (constr 0 - [ ]) ]) ]) - , (constr 0 - [ ]) ]) ]) ]) ]) - , (constr 1 - [ (constr 0 - [ 2 - , (constr 1 - [ (constr 1 - [ (constr 0 - [ (constr 1 - [ ]) - , (constr 1 - [ 24576 - , (constr 0 - [ ]) ]) ]) - , (constr 1 - [ (constr 0 - [ (constr 0 - [ ]) - , (constr 1 - [ 122880 - , (constr 0 - [ ]) ]) ]) - , (constr 0 - [ ]) ]) ]) ]) ]) - , (constr 1 - [ (constr 0 - [ 3 - , (constr 1 - [ (constr 1 - [ cse!20 - , (constr 1 - [ (constr 0 - [ (constr 0 - [ ]) - , (constr 1 - [ 32768 - , (constr 0 - [ ]) ]) ]) - , (constr 0 - [ ]) ]) ]) ]) ]) - , (constr 1 - [ (constr 0 - [ 4 - , (constr 1 - [ (constr 1 - [ cse!20 - , (constr 1 - [ (constr 0 - [ (constr 0 - [ ]) - , (constr 1 - [ 5000 - , (constr 0 - [ ]) ]) ]) - , (constr 0 - [ ]) ]) ]) ]) ]) - , (constr 1 - [ (constr 0 - [ 5 - , (constr 1 - [ (constr 1 - [ (constr 0 - [ (constr 1 - [ ]) - , (constr 1 - [ 1000000 - , cse!29 ]) ]) - , (constr 1 - [ (constr 0 - [ (constr 0 - [ ]) - , (constr 1 - [ 5000000 - , (constr 0 - [ ]) ]) ]) - , (constr 0 - [ ]) ]) ]) ]) ]) - , (constr 1 - [ (constr 0 - [ 6 - , (constr 1 - [ (constr 1 - [ (constr 0 - [ (constr 1 - [ ]) - , (constr 1 - [ 250000000 - , cse!29 ]) ]) - , cse!12 ]) ]) ]) - , (constr 1 - [ (constr 0 - [ 7 - , (constr 1 - [ (constr 1 - [ cse!20 - , (constr 0 - [ ]) ]) ]) ]) - , (constr 1 - [ (constr 0 - [ 8 - , (constr 1 - [ (constr 1 - [ (constr 0 - [ (constr 1 - [ ]) - , (constr 1 - [ 250 - , cse!29 ]) ]) - , (constr 1 - [ (constr 0 - [ (constr 0 - [ ]) - , (constr 1 - [ 2000 - , (constr 0 - [ ]) ]) ]) - , cse!10 ]) ]) ]) ]) - , (constr 1 - [ (constr 0 - [ 9 - , (constr 3 - [ (constr 1 - [ cse!7 - , cse!8 ]) ]) ]) - , (constr 1 - [ (constr 0 - [ 10 - , (constr 3 - [ (constr 1 - [ (constr 0 - [ (constr 1 - [ ]) - , (constr 1 - [ (cse!33 - 1000) - , cse!15 ]) ]) - , (constr 1 - [ (constr 0 - [ (constr 0 - [ ]) - , (constr 1 - [ (cse!33 - 200) - , (constr 0 - [ ]) ]) ]) - , (constr 0 - [ ]) ]) ]) ]) ]) - , (constr 1 - [ (constr 0 - [ 11 - , (constr 3 - [ (constr 1 - [ cse!7 - , (constr 1 - [ (constr 0 - [ (constr 0 - [ ]) - , (constr 1 - [ (cse!26 - 10) - , cse!14 ]) ]) - , (constr 0 - [ ]) ]) ]) ]) ]) - , (constr 1 - [ (constr 0 - [ 16 - , (constr 1 - [ (constr 1 - [ cse!20 - , cse!12 ]) ]) ]) - , (constr 1 - [ (constr 0 - [ 17 - , (constr 1 - [ (constr 1 - [ (constr 0 - [ (constr 1 - [ ]) - , (constr 1 - [ 3000 - , cse!29 ]) ]) - , (constr 1 - [ (constr 0 - [ (constr 0 - [ ]) - , (constr 1 - [ 6500 - , (constr 0 - [ ]) ]) ]) - , cse!10 ]) ]) ]) ]) - , (constr 1 - [ (constr 0 - [ 18 - , (constr 0 - [ ]) ]) - , (constr 1 - [ (constr 0 - [ 19 - , (constr 2 - [ (constr 1 - [ (constr 3 - [ (constr 1 - [ (constr 0 - [ (constr 1 - [ ]) - , (constr 1 - [ (cse!33 - 25) - , (constr 0 - [ ]) ]) ]) - , (constr 1 - [ (constr 0 - [ (constr 0 - [ ]) - , (constr 1 - [ (cse!33 - 5) - , (constr 0 - [ ]) ]) ]) - , (constr 0 - [ ]) ]) ]) ]) - , (constr 1 - [ (constr 3 - [ (constr 1 - [ (constr 0 - [ (constr 1 - [ ]) - , (constr 1 - [ (cse!33 - 20000) - , (constr 0 - [ ]) ]) ]) - , (constr 1 - [ (constr 0 - [ (constr 0 - [ ]) - , (constr 1 - [ (cse!33 - 5000) - , (constr 0 - [ ]) ]) ]) - , (constr 0 - [ ]) ]) ]) ]) - , (constr 0 - [ ]) ]) ]) ]) ]) - , (constr 1 - [ (constr 0 - [ 20 - , (constr 2 - [ (constr 1 - [ (constr 1 - [ (constr 1 - [ cse!20 - , (constr 1 - [ (constr 0 - [ (constr 0 - [ ]) - , (constr 1 - [ 40000000 - , (constr 0 - [ ]) ]) ]) - , (constr 0 - [ ]) ]) ]) ]) - , (constr 1 - [ (constr 1 - [ (constr 1 - [ cse!20 - , (constr 1 - [ (constr 0 - [ (constr 0 - [ ]) - , (constr 1 - [ 15000000000 - , (constr 0 - [ ]) ]) ]) - , (constr 0 - [ ]) ]) ]) ]) - , (constr 0 - [ ]) ]) ]) ]) ]) - , (constr 1 - [ (constr 0 - [ 21 - , (constr 2 - [ (constr 1 - [ (constr 1 - [ (constr 1 - [ cse!20 - , (constr 1 - [ (constr 0 - [ (constr 0 - [ ]) - , (constr 1 - [ 120000000 - , (constr 0 - [ ]) ]) ]) - , (constr 0 - [ ]) ]) ]) ]) - , (constr 1 - [ (constr 1 - [ (constr 1 - [ cse!20 - , (constr 1 - [ (constr 0 - [ (constr 0 - [ ]) - , (constr 1 - [ 40000000000 - , (constr 0 - [ ]) ]) ]) - , (constr 0 - [ ]) ]) ]) ]) - , (constr 0 - [ ]) ]) ]) ]) ]) - , (constr 1 - [ (constr 0 - [ 22 - , (constr 1 - [ (constr 1 - [ cse!20 - , (constr 1 - [ (constr 0 - [ (constr 0 - [ ]) - , (constr 1 - [ 12288 - , (constr 0 - [ ]) ]) ]) - , (constr 0 - [ ]) ]) ]) ]) ]) - , (constr 1 - [ (constr 0 - [ 23 - , (constr 1 - [ (constr 1 - [ (constr 0 - [ (constr 1 - [ ]) - , (constr 1 - [ 100 - , cse!29 ]) ]) - , (constr 1 - [ (constr 0 - [ (constr 0 - [ ]) - , (constr 1 - [ 200 - , (constr 0 - [ ]) ]) ]) - , cse!10 ]) ]) ]) ]) - , (constr 1 - [ (constr 0 - [ 24 - , (constr 1 - [ (constr 1 - [ cse!23 - , (constr 0 - [ ]) ]) ]) ]) - , (constr 1 - [ (constr 0 - [ 25 - , (constr 2 - [ (constr 1 - [ cse!3 - , (constr 1 - [ cse!1 - , (constr 1 - [ cse!1 - , (constr 1 - [ cse!2 - , cse!4 ]) ]) ]) ]) ]) ]) - , (constr 1 - [ (constr 0 - [ 26 - , (constr 2 - [ (constr 1 - [ cse!3 - , (constr 1 - [ cse!1 - , (constr 1 - [ cse!1 - , (constr 1 - [ cse!1 - , (constr 1 - [ cse!2 - , (constr 1 - [ cse!3 - , (constr 1 - [ cse!3 - , (constr 1 - [ cse!3 - , (constr 1 - [ (constr 3 - [ (constr 1 - [ (constr 0 - [ (constr 1 - [ ]) - , (constr 1 - [ cse!17 - , cse!11 ]) ]) - , cse!5 ]) ]) - , cse!4 ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) - , (constr 1 - [ (constr 0 - [ 27 - , (constr 1 - [ (constr 1 - [ (constr 0 - [ (constr 1 - [ ]) - , (constr 1 - [ 0 - , (constr 1 - [ 3 - , (constr 0 - [ ]) ]) ]) ]) - , (constr 1 - [ (constr 0 - [ (constr 0 - [ ]) - , (constr 1 - [ 10 - , (constr 0 - [ ]) ]) ]) - , (constr 0 - [ ]) ]) ]) ]) ]) - , (constr 1 - [ (constr 0 - [ 28 - , (constr 1 - [ (constr 1 - [ (constr 0 - [ (constr 1 - [ ]) - , (constr 1 - [ 0 - , (constr 1 - [ 18 - , (constr 0 - [ ]) ]) ]) ]) - , (constr 1 - [ (constr 0 - [ (constr 0 - [ ]) - , (constr 1 - [ 293 - , (constr 0 - [ ]) ]) ]) - , cse!10 ]) ]) ]) ]) - , (constr 1 - [ (constr 0 - [ 29 - , (constr 1 - [ (constr 1 - [ cse!23 - , (constr 1 - [ (constr 0 - [ (constr 0 - [ ]) - , (constr 1 - [ 15 - , (constr 0 - [ ]) ]) ]) - , (constr 0 - [ ]) ]) ]) ]) ]) - , (constr 1 - [ (constr 0 - [ 30 - , (constr 1 - [ (constr 1 - [ cse!9 - , (constr 1 - [ (constr 0 - [ (constr 0 - [ ]) - , (constr 1 - [ 10000000000000 - , (constr 0 - [ ]) ]) ]) - , (constr 0 - [ ]) ]) ]) ]) ]) - , (constr 1 - [ (constr 0 - [ 31 - , (constr 1 - [ (constr 1 - [ cse!9 - , (constr 1 - [ (constr 0 - [ (constr 0 - [ ]) - , (constr 1 - [ 100000000000 - , (constr 0 - [ ]) ]) ]) - , (constr 0 - [ ]) ]) ]) ]) ]) - , (constr 1 - [ (constr 0 - [ 32 - , (constr 1 - [ (constr 1 - [ (constr 0 - [ (constr 1 - [ ]) - , (constr 1 - [ 13 - , cse!29 ]) ]) - , (constr 1 - [ (constr 0 - [ (constr 0 - [ ]) - , (constr 1 - [ 37 - , (constr 0 - [ ]) ]) ]) - , (constr 0 - [ ]) ]) ]) ]) ]) - , (constr 1 - [ (constr 0 - [ 33 - , (constr 1 - [ (constr 1 - [ cse!20 - , cse!13 ]) ]) ]) - , (constr 0 - [ ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]))) - (constr 3 - [ (constr 1 - [ (constr 0 + sndPair) + (unConstrData + ds!1)))))))))))))) + [ (\cparams!0 -> + delay + (force + (case + (fun!3 + cparams!1) + [ (delay + ()) + , (delay + error) ]))) + , (delay + ()) ])) + (runRules!33 + (constr 1 + [ (constr 0 + [ 0 + , (constr 1 [ (constr 1 - [ ]) - , (constr 1 - [ cse!16 + [ (constr 0 + [ (constr 1 + [ ]) + , (constr 1 + [ 30 + , cse!30 ]) ]) , (constr 1 - [ cse!17 + [ (constr 0 + [ (constr 0 + [ ]) + , (constr 1 + [ 1000 + , (constr 0 + [ ]) ]) ]) , (constr 0 - [ ]) ]) ]) ]) - , cse!4 ]) ])) - (constr 3 - [ (constr 1 - [ cse!4 - , (constr 1 - [ (constr 0 - [ (constr 0 - [ ]) - , (constr 1 - [ cse!22 - , (constr 1 - [ cse!19 - , (constr 0 - [ ]) ]) ]) ]) - , (constr 0 - [ ]) ]) ]) ])) + [ ]) ]) ]) ]) ]) + , (constr 1 + [ (constr 0 + [ 1 + , (constr 1 + [ (constr 1 + [ (constr 0 + [ (constr 1 + [ ]) + , (constr 1 + [ 100000 + , cse!30 ]) ]) + , (constr 1 + [ (constr 0 + [ (constr 0 + [ ]) + , (constr 1 + [ 10000000 + , (constr 0 + [ ]) ]) ]) + , (constr 0 + [ ]) ]) ]) ]) ]) + , (constr 1 + [ (constr 0 + [ 2 + , (constr 1 + [ (constr 1 + [ (constr 0 + [ (constr 1 + [ ]) + , (constr 1 + [ 24576 + , (constr 0 + [ ]) ]) ]) + , (constr 1 + [ (constr 0 + [ (constr 0 + [ ]) + , (constr 1 + [ 122880 + , (constr 0 + [ ]) ]) ]) + , (constr 0 + [ ]) ]) ]) ]) ]) + , (constr 1 + [ (constr 0 + [ 3 + , (constr 1 + [ (constr 1 + [ cse!19 + , (constr 1 + [ (constr 0 + [ (constr 0 + [ ]) + , (constr 1 + [ 32768 + , (constr 0 + [ ]) ]) ]) + , (constr 0 + [ ]) ]) ]) ]) ]) + , (constr 1 + [ (constr 0 + [ 4 + , (constr 1 + [ (constr 1 + [ cse!19 + , (constr 1 + [ (constr 0 + [ (constr 0 + [ ]) + , (constr 1 + [ 5000 + , (constr 0 + [ ]) ]) ]) + , (constr 0 + [ ]) ]) ]) ]) ]) + , (constr 1 + [ (constr 0 + [ 5 + , (constr 1 + [ (constr 1 + [ (constr 0 + [ (constr 1 + [ ]) + , (constr 1 + [ 1000000 + , cse!30 ]) ]) + , (constr 1 + [ (constr 0 + [ (constr 0 + [ ]) + , (constr 1 + [ 5000000 + , (constr 0 + [ ]) ]) ]) + , (constr 0 + [ ]) ]) ]) ]) ]) + , (constr 1 + [ (constr 0 + [ 6 + , (constr 1 + [ (constr 1 + [ (constr 0 + [ (constr 1 + [ ]) + , (constr 1 + [ 250000000 + , cse!30 ]) ]) + , cse!12 ]) ]) ]) + , (constr 1 + [ (constr 0 + [ 7 + , (constr 1 + [ (constr 1 + [ cse!19 + , (constr 0 + [ ]) ]) ]) ]) + , (constr 1 + [ (constr 0 + [ 8 + , (constr 1 + [ (constr 1 + [ (constr 0 + [ (constr 1 + [ ]) + , (constr 1 + [ 250 + , cse!30 ]) ]) + , (constr 1 + [ (constr 0 + [ (constr 0 + [ ]) + , (constr 1 + [ 2000 + , (constr 0 + [ ]) ]) ]) + , cse!10 ]) ]) ]) ]) + , (constr 1 + [ (constr 0 + [ 9 + , (constr 3 + [ (constr 1 + [ cse!7 + , cse!8 ]) ]) ]) + , (constr 1 + [ (constr 0 + [ 10 + , (constr 3 + [ (constr 1 + [ (constr 0 + [ (constr 1 + [ ]) + , (constr 1 + [ (cse!28 + 1000) + , cse!13 ]) ]) + , (constr 1 + [ (constr 0 + [ (constr 0 + [ ]) + , (constr 1 + [ (cse!28 + 200) + , (constr 0 + [ ]) ]) ]) + , (constr 0 + [ ]) ]) ]) ]) ]) + , (constr 1 + [ (constr 0 + [ 11 + , (constr 3 + [ (constr 1 + [ cse!7 + , (constr 1 + [ (constr 0 + [ (constr 0 + [ ]) + , (constr 1 + [ (cse!25 + 10) + , cse!14 ]) ]) + , (constr 0 + [ ]) ]) ]) ]) ]) + , (constr 1 + [ (constr 0 + [ 16 + , (constr 1 + [ (constr 1 + [ cse!19 + , cse!12 ]) ]) ]) + , (constr 1 + [ (constr 0 + [ 17 + , (constr 1 + [ (constr 1 + [ (constr 0 + [ (constr 1 + [ ]) + , (constr 1 + [ 3000 + , cse!30 ]) ]) + , (constr 1 + [ (constr 0 + [ (constr 0 + [ ]) + , (constr 1 + [ 6500 + , (constr 0 + [ ]) ]) ]) + , cse!10 ]) ]) ]) ]) + , (constr 1 + [ (constr 0 + [ 18 + , (constr 0 + [ ]) ]) + , (constr 1 + [ (constr 0 + [ 19 + , (constr 2 + [ (constr 1 + [ (constr 3 + [ (constr 1 + [ (constr 0 + [ (constr 1 + [ ]) + , (constr 1 + [ (cse!28 + 25) + , (constr 0 + [ ]) ]) ]) + , (constr 1 + [ (constr 0 + [ (constr 0 + [ ]) + , (constr 1 + [ (cse!28 + 5) + , (constr 0 + [ ]) ]) ]) + , (constr 0 + [ ]) ]) ]) ]) + , (constr 1 + [ (constr 3 + [ (constr 1 + [ (constr 0 + [ (constr 1 + [ ]) + , (constr 1 + [ (cse!28 + 20000) + , (constr 0 + [ ]) ]) ]) + , (constr 1 + [ (constr 0 + [ (constr 0 + [ ]) + , (constr 1 + [ (cse!28 + 5000) + , (constr 0 + [ ]) ]) ]) + , (constr 0 + [ ]) ]) ]) ]) + , (constr 0 + [ ]) ]) ]) ]) ]) + , (constr 1 + [ (constr 0 + [ 20 + , (constr 2 + [ (constr 1 + [ (constr 1 + [ (constr 1 + [ cse!19 + , (constr 1 + [ (constr 0 + [ (constr 0 + [ ]) + , (constr 1 + [ 40000000 + , (constr 0 + [ ]) ]) ]) + , (constr 0 + [ ]) ]) ]) ]) + , (constr 1 + [ (constr 1 + [ (constr 1 + [ cse!19 + , (constr 1 + [ (constr 0 + [ (constr 0 + [ ]) + , (constr 1 + [ 15000000000 + , (constr 0 + [ ]) ]) ]) + , (constr 0 + [ ]) ]) ]) ]) + , (constr 0 + [ ]) ]) ]) ]) ]) + , (constr 1 + [ (constr 0 + [ 21 + , (constr 2 + [ (constr 1 + [ (constr 1 + [ (constr 1 + [ cse!19 + , (constr 1 + [ (constr 0 + [ (constr 0 + [ ]) + , (constr 1 + [ 120000000 + , (constr 0 + [ ]) ]) ]) + , (constr 0 + [ ]) ]) ]) ]) + , (constr 1 + [ (constr 1 + [ (constr 1 + [ cse!19 + , (constr 1 + [ (constr 0 + [ (constr 0 + [ ]) + , (constr 1 + [ 40000000000 + , (constr 0 + [ ]) ]) ]) + , (constr 0 + [ ]) ]) ]) ]) + , (constr 0 + [ ]) ]) ]) ]) ]) + , (constr 1 + [ (constr 0 + [ 22 + , (constr 1 + [ (constr 1 + [ cse!19 + , (constr 1 + [ (constr 0 + [ (constr 0 + [ ]) + , (constr 1 + [ 12288 + , (constr 0 + [ ]) ]) ]) + , (constr 0 + [ ]) ]) ]) ]) ]) + , (constr 1 + [ (constr 0 + [ 23 + , (constr 1 + [ (constr 1 + [ (constr 0 + [ (constr 1 + [ ]) + , (constr 1 + [ 100 + , cse!30 ]) ]) + , (constr 1 + [ (constr 0 + [ (constr 0 + [ ]) + , (constr 1 + [ 200 + , (constr 0 + [ ]) ]) ]) + , cse!10 ]) ]) ]) ]) + , (constr 1 + [ (constr 0 + [ 24 + , (constr 1 + [ (constr 1 + [ cse!20 + , (constr 0 + [ ]) ]) ]) ]) + , (constr 1 + [ (constr 0 + [ 25 + , (constr 2 + [ (constr 1 + [ cse!3 + , (constr 1 + [ cse!2 + , (constr 1 + [ cse!2 + , (constr 1 + [ cse!1 + , cse!4 ]) ]) ]) ]) ]) ]) + , (constr 1 + [ (constr 0 + [ 26 + , (constr 2 + [ (constr 1 + [ cse!3 + , (constr 1 + [ cse!2 + , (constr 1 + [ cse!2 + , (constr 1 + [ cse!2 + , (constr 1 + [ cse!1 + , (constr 1 + [ cse!3 + , (constr 1 + [ cse!3 + , (constr 1 + [ cse!3 + , (constr 1 + [ (constr 3 + [ (constr 1 + [ (constr 0 + [ (constr 1 + [ ]) + , (constr 1 + [ cse!21 + , cse!11 ]) ]) + , cse!5 ]) ]) + , cse!4 ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) + , (constr 1 + [ (constr 0 + [ 27 + , (constr 1 + [ (constr 1 + [ (constr 0 + [ (constr 1 + [ ]) + , (constr 1 + [ 0 + , (constr 1 + [ 3 + , (constr 0 + [ ]) ]) ]) ]) + , (constr 1 + [ (constr 0 + [ (constr 0 + [ ]) + , (constr 1 + [ 10 + , (constr 0 + [ ]) ]) ]) + , (constr 0 + [ ]) ]) ]) ]) ]) + , (constr 1 + [ (constr 0 + [ 28 + , (constr 1 + [ (constr 1 + [ (constr 0 + [ (constr 1 + [ ]) + , (constr 1 + [ 0 + , (constr 1 + [ 18 + , (constr 0 + [ ]) ]) ]) ]) + , (constr 1 + [ (constr 0 + [ (constr 0 + [ ]) + , (constr 1 + [ 293 + , (constr 0 + [ ]) ]) ]) + , cse!10 ]) ]) ]) ]) + , (constr 1 + [ (constr 0 + [ 29 + , (constr 1 + [ (constr 1 + [ cse!20 + , (constr 1 + [ (constr 0 + [ (constr 0 + [ ]) + , (constr 1 + [ 15 + , (constr 0 + [ ]) ]) ]) + , (constr 0 + [ ]) ]) ]) ]) ]) + , (constr 1 + [ (constr 0 + [ 30 + , (constr 1 + [ (constr 1 + [ cse!9 + , (constr 1 + [ (constr 0 + [ (constr 0 + [ ]) + , (constr 1 + [ 10000000000000 + , (constr 0 + [ ]) ]) ]) + , (constr 0 + [ ]) ]) ]) ]) ]) + , (constr 1 + [ (constr 0 + [ 31 + , (constr 1 + [ (constr 1 + [ cse!9 + , (constr 1 + [ (constr 0 + [ (constr 0 + [ ]) + , (constr 1 + [ 100000000000 + , (constr 0 + [ ]) ]) ]) + , (constr 0 + [ ]) ]) ]) ]) ]) + , (constr 1 + [ (constr 0 + [ 32 + , (constr 1 + [ (constr 1 + [ (constr 0 + [ (constr 1 + [ ]) + , (constr 1 + [ 13 + , cse!30 ]) ]) + , (constr 1 + [ (constr 0 + [ (constr 0 + [ ]) + , (constr 1 + [ 37 + , (constr 0 + [ ]) ]) ]) + , (constr 0 + [ ]) ]) ]) ]) ]) + , (constr 1 + [ (constr 0 + [ 33 + , (constr 3 + [ (constr 1 + [ (constr 0 + [ (constr 1 + [ ]) + , cse!13 ]) + , (constr 1 + [ (constr 0 + [ (constr 0 + [ ]) + , (constr 1 + [ (unsafeRatio!37 + 1000 + 1) + , (constr 0 + [ ]) ]) ]) + , (constr 0 + [ ]) ]) ]) ]) ]) + , (constr 0 + [ ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]))) (constr 3 [ (constr 1 - [ cse!3 + [ cse!5 , (constr 1 [ (constr 0 [ (constr 0 [ ]) , (constr 1 - [ cse!21 - , cse!8 ]) ]) + [ cse!17 + , (constr 1 + [ cse!22 + , (constr 0 + [ ]) ]) ]) ]) , (constr 0 [ ]) ]) ]) ])) - (constr 1 - [ (constr 3 - [ (constr 1 - [ (constr 0 - [ (constr 1 - [ ]) + (constr 3 + [ (constr 1 + [ (constr 0 + [ (constr 1 + [ ]) + , (constr 1 + [ cse!19 , (constr 1 - [ cse!13 + [ cse!14 , (constr 0 - [ ]) ]) ]) - , cse!4 ]) ]) - , (constr 0 - [ ]) ])) - (constr 1 - [ (constr 0 - [ (constr 0 - [ ]) + [ ]) ]) ]) ]) + , cse!3 ]) ])) + (constr 3 + [ (constr 1 + [ cse!3 , (constr 1 - [ cse!19 - , (constr 1 - [ cse!11 - , (constr 0 - [ ]) ]) ]) ]) - , (constr 0 - [ ]) ])) - (constr 0 - [ (constr 1 - [ ]) - , (constr 1 - [ cse!11 - , (constr 1 - [ cse!13 - , (constr 0 - [ ]) ]) ]) ])) - (constr 0 - [ (constr 1 - [ ]) - , (constr 1 - [ (cse!26 - 10) - , cse!8 ]) ])) - (constr 1 - [ (constr 0 - [ (constr 0 - [ ]) - , cse!6 ]) - , (constr 0 - [ ]) ])) + [ (constr 0 + [ (constr 0 + [ ]) + , (constr 1 + [ cse!15 + , cse!8 ]) ]) + , (constr 0 + [ ]) ]) ]) ])) + (constr 1 + [ (constr 3 + [ (constr 1 + [ (constr 0 + [ (constr 1 + [ ]) + , (constr 1 + [ cse!17 + , (constr 0 + [ ]) ]) ]) + , cse!4 ]) ]) + , (constr 0 + [ ]) ])) + (constr 1 + [ (constr 0 + [ (constr 0 + [ ]) + , (constr 1 + [ cse!13 + , (constr 1 + [ cse!12 + , (constr 0 + [ ]) ]) ]) ]) + , (constr 0 + [ ]) ])) + (constr 0 + [ (constr 1 + [ ]) + , (constr 1 + [ cse!15 + , (constr 1 + [ cse!9 + , (constr 0 + [ ]) ]) ]) ])) (constr 0 [ (constr 1 [ ]) , (constr 1 - [ 0 - , (constr 1 - [ 1000000 - , (constr 0 - [ ]) ]) ]) ])) + [ (cse!21 + 10) + , cse!6 ]) ])) (constr 1 [ (constr 0 - [ (constr 2 + [ (constr 0 [ ]) - , cse!19 ]) + , cse!6 ]) , (constr 0 [ ]) ])) - (constr 1 - [ cse!14 - , (constr 0 - [ ]) ])) + (constr 0 + [ (constr 1 + [ ]) + , (constr 1 + [ 0 + , (constr 1 + [ 1000000 + , (constr 0 + [ ]) ]) ]) ])) (constr 1 [ (constr 0 - [ (constr 0 + [ (constr 2 [ ]) - , (constr 1 - [ 500000000 - , (constr 0 - [ ]) ]) ]) + , cse!20 ]) , (constr 0 [ ]) ])) (constr 1 - [ (constr 0 - [ (constr 0 - [ ]) - , (constr 1 - [ 1000 - , (constr 0 - [ ]) ]) ]) + [ (cse!14 + 4) , (constr 0 [ ]) ])) (constr 1 - [ cse!10 + [ (constr 0 + [ (constr 0 + [ ]) + , (constr 1 + [ 500000000 + , (constr 0 + [ ]) ]) ]) , (constr 0 [ ]) ])) (constr 1 - [ cse!7 + [ cse!9 , (constr 0 [ ]) ])) - (cse!12 - 10)) - (cse!16 - 2)) - (cse!9 + (constr 1 + [ cse!4 + , (constr 0 + [ ]) ])) + (cse!14 + 100)) + (cse!10 20)) - (cse!13 - 100)) - (constr 0 - [ (constr 1 - [ ]) - , cse!9 ])) - (cse!10 - 5)) - (cse!8 - 1)) - (constr 0 - [ (constr 1 - []) - , (constr 1 - [ 1 - , (constr 0 - [ ]) ]) ])) - (cse!9 1)) - (cse!1 4)) - (unsafeRatio!13 3)) - (unsafeRatio!12 13)) - (unsafeRatio!11 9)) - (constr 1 [0, (constr 0 [])])) - (unsafeRatio!9 0)) - (unsafeRatio!8 4)) - (unsafeRatio!7 51)) - (unsafeRatio!6 1)) + (cse!10 + 10)) + (cse!10 + 1)) + (constr 0 + [ (constr 1 + [ ]) + , cse!11 ])) + (constr 0 + [ (constr 1 + [ ]) + , (constr 1 + [ 1 + , (constr 0 + [ ]) ]) ])) + (cse!7 2)) + (cse!2 1)) + (cse!8 5)) + (unsafeRatio!13 0)) + (unsafeRatio!12 3)) + (unsafeRatio!11 13)) + (unsafeRatio!10 9)) + (unsafeRatio!9 1)) + (unsafeRatio!8 51)) + (constr 1 [0, (constr 0 [])])) + (unsafeRatio!6 4)) (fix1!10 (\go!0 l!0 -> force (force chooseList) @@ -1394,4 +1403,4 @@ program (multiplyInteger n'!2 d!3)) (constr 0 []) (constr 1 [])) ]) ])) - (\f!0 -> (\s!0 -> s!1 s!1) (\s!0 -> f!2 (\x!0 -> s!2 s!2 x!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 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 ecb474cd53e..5c66ebbcb8e 100644 --- a/cardano-constitution/test/Cardano/Constitution/Validator/GoldenTests/unsorted.pir.golden +++ b/cardano-constitution/test/Cardano/Constitution/Validator/GoldenTests/unsorted.pir.golden @@ -1,5666 +1,5675 @@ program 1.1.0 (let - data Ordering-71617 | Ordering_match-71621 where - EQ-71618 : Ordering-71617 - GT-71619 : Ordering-71617 - LT-71620 : Ordering-71617 - data Bool-71608 | Bool_match-71611 where - True-71609 : Bool-71608 - False-71610 : Bool-71608 - data (Ord-71622 :: * -> *) a-71625 | Ord_match-71624 where - CConsOrd-71623 : - (\a-71626 -> a-71626 -> a-71626 -> Bool-71608) a-71625 -> - (a-71625 -> a-71625 -> Ordering-71617) -> - (a-71625 -> a-71625 -> Bool-71608) -> - (a-71625 -> a-71625 -> Bool-71608) -> - (a-71625 -> a-71625 -> Bool-71608) -> - (a-71625 -> a-71625 -> Bool-71608) -> - (a-71625 -> a-71625 -> a-71625) -> - (a-71625 -> a-71625 -> a-71625) -> - Ord-71622 a-71625 - data PredKey-71612 | PredKey_match-71616 where - MaxValue-71613 : PredKey-71612 - MinValue-71614 : PredKey-71612 - NotEqual-71615 : PredKey-71612 - data (Tuple2-71593 :: * -> * -> *) a-71596 - b-71597 | Tuple2_match-71595 where - Tuple2-71594 : a-71596 -> b-71597 -> Tuple2-71593 a-71596 b-71597 + 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 in letrec - data (List-71588 :: * -> *) a-71592 | List_match-71591 where - Nil-71589 : List-71588 a-71592 - Cons-71590 : a-71592 -> List-71588 a-71592 -> List-71588 a-71592 + 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 in let - !validatePreds-71758 : - all a-71759. - Ord-71622 a-71759 -> - (\v-71760 -> - List-71588 (Tuple2-71593 PredKey-71612 (List-71588 v-71760))) - a-71759 -> - a-71759 -> - Bool-71608 - = /\a-71691 -> - \(`$dOrd`-71692 : Ord-71622 a-71691) - (ds-71693 : - (\v-71694 -> - List-71588 (Tuple2-71593 PredKey-71612 (List-71588 v-71694))) - a-71691) - (ds-71695 : a-71691) -> + !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) -> letrec - !go-71696 : - List-71588 (Tuple2-71593 PredKey-71612 (List-71588 a-71691)) -> - Bool-71608 - = \(ds-71697 : - List-71588 - (Tuple2-71593 PredKey-71612 (List-71588 a-71691))) -> - List_match-71591 - {Tuple2-71593 PredKey-71612 (List-71588 a-71691)} - ds-71697 - {all dead-71698. Bool-71608} - (/\dead-71699 -> True-71609) - (\(x-71700 : - Tuple2-71593 PredKey-71612 (List-71588 a-71691)) - (xs-71701 : - List-71588 - (Tuple2-71593 - PredKey-71612 - (List-71588 a-71691))) -> - /\dead-71702 -> - Tuple2_match-71595 - {PredKey-71612} - {List-71588 a-71691} - x-71700 - {Bool-71608} - (\(predKey-71703 : PredKey-71612) - (expectedPredValues-71704 : - List-71588 a-71691) -> + !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) -> let - !meaning-71744 : - a-71691 -> a-71691 -> Bool-71608 - = PredKey_match-71616 - predKey-71703 - {all dead-71705. - a-71691 -> a-71691 -> Bool-71608} - (/\dead-71706 -> - Ord_match-71624 - {a-71691} - `$dOrd`-71692 - {a-71691 -> a-71691 -> Bool-71608} - (\(v-71707 : - (\a-71708 -> - a-71708 -> - a-71708 -> - Bool-71608) - a-71691) - (v-71709 : - a-71691 -> - a-71691 -> - Ordering-71617) - (v-71710 : - a-71691 -> - a-71691 -> - Bool-71608) - (v-71711 : - a-71691 -> - a-71691 -> - Bool-71608) - (v-71712 : - a-71691 -> - a-71691 -> - Bool-71608) - (v-71713 : - a-71691 -> - a-71691 -> - Bool-71608) - (v-71714 : - a-71691 -> a-71691 -> a-71691) - (v-71715 : - a-71691 -> - a-71691 -> - a-71691) -> - v-71713)) - (/\dead-71716 -> - Ord_match-71624 - {a-71691} - `$dOrd`-71692 - {a-71691 -> a-71691 -> Bool-71608} - (\(v-71717 : - (\a-71718 -> - a-71718 -> - a-71718 -> - Bool-71608) - a-71691) - (v-71719 : - a-71691 -> - a-71691 -> - Ordering-71617) - (v-71720 : - a-71691 -> - a-71691 -> - Bool-71608) - (v-71721 : - a-71691 -> - a-71691 -> - Bool-71608) - (v-71722 : - a-71691 -> - a-71691 -> - Bool-71608) - (v-71723 : - a-71691 -> - a-71691 -> - Bool-71608) - (v-71724 : - a-71691 -> a-71691 -> a-71691) - (v-71725 : - a-71691 -> - a-71691 -> - a-71691) -> - v-71721)) - (/\dead-71726 -> - \(x-71727 : a-71691) - (y-71728 : a-71691) -> - Bool_match-71611 - (Ord_match-71624 - {a-71691} - `$dOrd`-71692 - {(\a-71729 -> - a-71729 -> - a-71729 -> - Bool-71608) - a-71691} - (\(v-71730 : - (\a-71731 -> - a-71731 -> - a-71731 -> - Bool-71608) - a-71691) - (v-71732 : - a-71691 -> - a-71691 -> - Ordering-71617) - (v-71733 : - a-71691 -> - a-71691 -> - Bool-71608) - (v-71734 : - a-71691 -> - a-71691 -> - Bool-71608) - (v-71735 : - a-71691 -> - a-71691 -> - Bool-71608) - (v-71736 : - a-71691 -> - a-71691 -> - Bool-71608) - (v-71737 : - a-71691 -> - a-71691 -> - a-71691) - (v-71738 : - a-71691 -> - a-71691 -> - a-71691) -> - v-71730) - x-71727 - y-71728) - {all dead-71739. Bool-71608} - (/\dead-71740 -> False-71610) - (/\dead-71741 -> True-71609) - {all dead-71742. dead-71742}) - {all dead-71743. dead-71743} + !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} in letrec - !go-71745 : List-71588 a-71691 -> Bool-71608 - = \(ds-71746 : List-71588 a-71691) -> - List_match-71591 - {a-71691} - ds-71746 - {all dead-71747. Bool-71608} - (/\dead-71748 -> go-71696 xs-71701) - (\(x-71749 : a-71691) - (xs-71750 : List-71588 a-71691) -> - /\dead-71751 -> - Bool_match-71611 - (meaning-71744 - x-71749 - ds-71695) - {all dead-71752. Bool-71608} - (/\dead-71753 -> - go-71745 xs-71750) - (/\dead-71754 -> False-71610) - {all dead-71755. dead-71755}) - {all dead-71756. dead-71756} + !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} in - go-71745 expectedPredValues-71704)) - {all dead-71757. dead-71757} + go-71768 expectedPredValues-71727)) + {all dead-71780. dead-71780} in - go-71696 ds-71693 - !`$fOrdInteger_$ccompare`-71677 : integer -> integer -> Ordering-71617 - = \(eta-71667 : integer) (eta-71668 : integer) -> - Bool_match-71611 + 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-71608} - (equalsInteger eta-71667 eta-71668) - True-71609 - False-71610) - {all dead-71669. Ordering-71617} - (/\dead-71670 -> EQ-71618) - (/\dead-71671 -> - Bool_match-71611 + {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-71608} - (lessThanEqualsInteger eta-71667 eta-71668) - True-71609 - False-71610) - {all dead-71672. Ordering-71617} - (/\dead-71673 -> LT-71620) - (/\dead-71674 -> GT-71619) - {all dead-71675. dead-71675}) - {all dead-71676. dead-71676} - data Rational-71627 | Rational_match-71629 where - Rational-71628 : integer -> integer -> Rational-71627 - !`$fOrdRational0_$c<=`-71666 : - Rational-71627 -> Rational-71627 -> Bool-71608 - = \(ds-71660 : Rational-71627) (ds-71661 : Rational-71627) -> - Rational_match-71629 - ds-71660 - {Bool-71608} - (\(n-71662 : integer) (d-71663 : integer) -> - Rational_match-71629 - ds-71661 - {Bool-71608} - (\(n'-71664 : integer) (d'-71665 : integer) -> + {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) -> ifThenElse - {Bool-71608} + {Bool-71628} (lessThanEqualsInteger - (multiplyInteger n-71662 d'-71665) - (multiplyInteger n'-71664 d-71663)) - True-71609 - False-71610)) + (multiplyInteger n-71682 d'-71685) + (multiplyInteger n'-71684 d-71683)) + True-71629 + False-71630)) in letrec - !euclid-71641 : integer -> integer -> integer - = \(x-71642 : integer) (y-71643 : integer) -> - Bool_match-71611 + !euclid-71661 : integer -> integer -> integer + = \(x-71662 : integer) (y-71663 : integer) -> + Bool_match-71631 (ifThenElse - {Bool-71608} - (equalsInteger 0 y-71643) - True-71609 - False-71610) - {all dead-71644. integer} - (/\dead-71645 -> x-71642) - (/\dead-71646 -> euclid-71641 y-71643 (modInteger x-71642 y-71643)) - {all dead-71647. dead-71647} + {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} in letrec - !unsafeRatio-71648 : integer -> integer -> Rational-71627 - = \(n-71649 : integer) (d-71650 : integer) -> - Bool_match-71611 + !unsafeRatio-71668 : integer -> integer -> Rational-71650 + = \(n-71669 : integer) (d-71670 : integer) -> + Bool_match-71631 (ifThenElse - {Bool-71608} - (equalsInteger 0 d-71650) - True-71609 - False-71610) - {all dead-71651. Rational-71627} - (/\dead-71652 -> error {Rational-71627}) - (/\dead-71653 -> - Bool_match-71611 + {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-71608} - (lessThanInteger d-71650 0) - True-71609 - False-71610) - {all dead-71654. Rational-71627} - (/\dead-71655 -> - unsafeRatio-71648 - (subtractInteger 0 n-71649) - (subtractInteger 0 d-71650)) - (/\dead-71656 -> + {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 -> let - !gcd'-71657 : integer = euclid-71641 n-71649 d-71650 + !gcd'-71677 : integer = euclid-71661 n-71669 d-71670 in - Rational-71628 - (quotientInteger n-71649 gcd'-71657) - (quotientInteger d-71650 gcd'-71657)) - {all dead-71658. dead-71658}) - {all dead-71659. dead-71659} - in - let - data Unit-71638 | Unit_match-71640 where - Unit-71639 : Unit-71638 + Rational-71651 + (quotientInteger n-71669 gcd'-71677) + (quotientInteger d-71670 gcd'-71677)) + {all dead-71678. dead-71678}) + {all dead-71679. dead-71679} in letrec - data ParamValue-71630 | ParamValue_match-71635 where - ParamAny-71631 : ParamValue-71630 - ParamInteger-71632 : - (\v-71636 -> - List-71588 (Tuple2-71593 PredKey-71612 (List-71588 v-71636))) + 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-71630 - ParamList-71633 : List-71588 ParamValue-71630 -> ParamValue-71630 - ParamRational-71634 : - (\v-71637 -> - List-71588 (Tuple2-71593 PredKey-71612 (List-71588 v-71637))) - Rational-71627 -> - ParamValue-71630 + 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 + in + let + data Unit-71632 | Unit_match-71634 where + Unit-71633 : Unit-71632 in letrec - !validateParamValue-71678 : ParamValue-71630 -> data -> Bool-71608 - = \(eta-71679 : ParamValue-71630) (eta-71680 : data) -> + !validateParamValue-71701 : ParamValue-71653 -> data -> Bool-71628 + = \(eta-71702 : ParamValue-71653) (eta-71703 : data) -> let - ~bl-71839 : list data = unListData eta-71680 - ~bl'-71840 : list data = tailList {data} bl-71839 + ~bl-71860 : list data = unListData eta-71703 + ~bl'-71861 : list data = tailList {data} bl-71860 in - ParamValue_match-71635 - eta-71679 - {all dead-71761. Bool-71608} - (/\dead-71762 -> True-71609) - (\(preds-71763 : - (\v-71764 -> - List-71588 - (Tuple2-71593 PredKey-71612 (List-71588 v-71764))) + 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-71765 -> - validatePreds-71758 + /\dead-71788 -> + validatePreds-71781 {integer} - (CConsOrd-71623 + (CConsOrd-71646 {integer} - (\(x-71766 : integer) (y-71767 : integer) -> + equalsInteger-71700 + `$fOrdInteger_$ccompare`-71697 + (\(x-71789 : integer) (y-71790 : integer) -> ifThenElse - {Bool-71608} - (equalsInteger x-71766 y-71767) - True-71609 - False-71610) - `$fOrdInteger_$ccompare`-71677 - (\(x-71768 : integer) (y-71769 : integer) -> + {Bool-71628} + (lessThanInteger x-71789 y-71790) + True-71629 + False-71630) + (\(x-71791 : integer) (y-71792 : integer) -> ifThenElse - {Bool-71608} - (lessThanInteger x-71768 y-71769) - True-71609 - False-71610) - (\(x-71770 : integer) (y-71771 : integer) -> + {Bool-71628} + (lessThanEqualsInteger x-71791 y-71792) + True-71629 + False-71630) + (\(x-71793 : integer) (y-71794 : integer) -> ifThenElse - {Bool-71608} - (lessThanEqualsInteger x-71770 y-71771) - True-71609 - False-71610) - (\(x-71772 : integer) (y-71773 : integer) -> + {Bool-71628} + (lessThanEqualsInteger x-71793 y-71794) + False-71630 + True-71629) + (\(x-71795 : integer) (y-71796 : integer) -> ifThenElse - {Bool-71608} - (lessThanEqualsInteger x-71772 y-71773) - False-71610 - True-71609) - (\(x-71774 : integer) (y-71775 : integer) -> - ifThenElse - {Bool-71608} - (lessThanInteger x-71774 y-71775) - False-71610 - True-71609) - (\(x-71776 : integer) (y-71777 : integer) -> - Bool_match-71611 + {Bool-71628} + (lessThanInteger x-71795 y-71796) + False-71630 + True-71629) + (\(x-71797 : integer) (y-71798 : integer) -> + Bool_match-71631 (ifThenElse - {Bool-71608} - (lessThanEqualsInteger x-71776 y-71777) - True-71609 - False-71610) - {all dead-71778. integer} - (/\dead-71779 -> y-71777) - (/\dead-71780 -> x-71776) - {all dead-71781. dead-71781}) - (\(x-71782 : integer) (y-71783 : integer) -> - Bool_match-71611 + {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 (ifThenElse - {Bool-71608} - (lessThanEqualsInteger x-71782 y-71783) - True-71609 - False-71610) - {all dead-71784. integer} - (/\dead-71785 -> x-71782) - (/\dead-71786 -> y-71783) - {all dead-71787. dead-71787})) - preds-71763 - (unIData eta-71680)) - (\(paramValues-71788 : List-71588 ParamValue-71630) -> - /\dead-71789 -> - validateParamValues-71681 - paramValues-71788 - (unListData eta-71680)) - (\(preds-71790 : - (\v-71791 -> - List-71588 - (Tuple2-71593 PredKey-71612 (List-71588 v-71791))) - Rational-71627) -> - /\dead-71792 -> - validatePreds-71758 - {Rational-71627} - (CConsOrd-71623 - {Rational-71627} - (\(ds-71793 : Rational-71627) - (ds-71794 : Rational-71627) -> - Rational_match-71629 - ds-71793 - {Bool-71608} - (\(n-71795 : integer) (d-71796 : integer) -> - Rational_match-71629 - ds-71794 - {Bool-71608} - (\(n'-71797 : integer) (d'-71798 : integer) -> - Bool_match-71611 + {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 (ifThenElse - {Bool-71608} - (equalsInteger n-71795 n'-71797) - True-71609 - False-71610) - {all dead-71799. Bool-71608} - (/\dead-71800 -> + {Bool-71628} + (equalsInteger n-71816 n'-71818) + True-71629 + False-71630) + {all dead-71820. Bool-71628} + (/\dead-71821 -> ifThenElse - {Bool-71608} - (equalsInteger d-71796 d'-71798) - True-71609 - False-71610) - (/\dead-71801 -> False-71610) - {all dead-71802. dead-71802}))) - (\(ds-71803 : Rational-71627) - (ds-71804 : Rational-71627) -> - Rational_match-71629 - ds-71803 - {Ordering-71617} - (\(n-71805 : integer) (d-71806 : integer) -> - Rational_match-71629 - ds-71804 - {Ordering-71617} - (\(n'-71807 : integer) (d'-71808 : integer) -> - `$fOrdInteger_$ccompare`-71677 - (multiplyInteger n-71805 d'-71808) - (multiplyInteger n'-71807 d-71806)))) - (\(ds-71809 : Rational-71627) - (ds-71810 : Rational-71627) -> - Rational_match-71629 - ds-71809 - {Bool-71608} - (\(n-71811 : integer) (d-71812 : integer) -> - Rational_match-71629 - ds-71810 - {Bool-71608} - (\(n'-71813 : integer) (d'-71814 : integer) -> + {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) -> ifThenElse - {Bool-71608} + {Bool-71628} (lessThanInteger - (multiplyInteger n-71811 d'-71814) - (multiplyInteger n'-71813 d-71812)) - True-71609 - False-71610))) - `$fOrdRational0_$c<=`-71666 - (\(ds-71815 : Rational-71627) - (ds-71816 : Rational-71627) -> - Rational_match-71629 - ds-71815 - {Bool-71608} - (\(n-71817 : integer) (d-71818 : integer) -> - Rational_match-71629 - ds-71816 - {Bool-71608} - (\(n'-71819 : integer) (d'-71820 : integer) -> + (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) -> ifThenElse - {Bool-71608} + {Bool-71628} (lessThanEqualsInteger - (multiplyInteger n-71817 d'-71820) - (multiplyInteger n'-71819 d-71818)) - False-71610 - True-71609))) - (\(ds-71821 : Rational-71627) - (ds-71822 : Rational-71627) -> - Rational_match-71629 - ds-71821 - {Bool-71608} - (\(n-71823 : integer) (d-71824 : integer) -> - Rational_match-71629 - ds-71822 - {Bool-71608} - (\(n'-71825 : integer) (d'-71826 : integer) -> + (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) -> ifThenElse - {Bool-71608} + {Bool-71628} (lessThanInteger - (multiplyInteger n-71823 d'-71826) - (multiplyInteger n'-71825 d-71824)) - False-71610 - True-71609))) - (\(x-71827 : Rational-71627) (y-71828 : Rational-71627) -> - Bool_match-71611 - (`$fOrdRational0_$c<=`-71666 x-71827 y-71828) - {all dead-71829. Rational-71627} - (/\dead-71830 -> y-71828) - (/\dead-71831 -> x-71827) - {all dead-71832. dead-71832}) - (\(x-71833 : Rational-71627) (y-71834 : Rational-71627) -> - Bool_match-71611 - (`$fOrdRational0_$c<=`-71666 x-71833 y-71834) - {all dead-71835. Rational-71627} - (/\dead-71836 -> x-71833) - (/\dead-71837 -> y-71834) - {all dead-71838. dead-71838})) - preds-71790 + (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 (ifThenElse - {Unit-71638 -> Rational-71627} - (nullList {data} (tailList {data} bl'-71840)) - (\(ds-71841 : Unit-71638) -> - unsafeRatio-71648 - (unIData (headList {data} bl-71839)) - (unIData (headList {data} bl'-71840))) - (\(ds-71842 : Unit-71638) -> error {Rational-71627}) - Unit-71639)) - {all dead-71843. dead-71843} - !validateParamValues-71681 : - List-71588 ParamValue-71630 -> list data -> Bool-71608 - = \(ds-71682 : List-71588 ParamValue-71630) -> - List_match-71591 - {ParamValue-71630} - ds-71682 - {list data -> Bool-71608} - (\(eta-71683 : list data) -> + {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-71608} - (nullList {data} eta-71683) - True-71609 - False-71610) - (\(paramValueHd-71684 : ParamValue-71630) - (paramValueTl-71685 : List-71588 ParamValue-71630) - (actualValueData-71686 : list data) -> - Bool_match-71611 - (validateParamValue-71678 - paramValueHd-71684 - (headList {data} actualValueData-71686)) - {all dead-71687. Bool-71608} - (/\dead-71688 -> - validateParamValues-71681 - paramValueTl-71685 - (tailList {data} actualValueData-71686)) - (/\dead-71689 -> False-71610) - {all dead-71690. dead-71690}) + {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}) in let - data (Maybe-71603 :: * -> *) a-71607 | Maybe_match-71606 where - Just-71604 : a-71607 -> Maybe-71603 a-71607 - Nothing-71605 : Maybe-71603 a-71607 + data (Maybe-71623 :: * -> *) a-71627 | Maybe_match-71626 where + Just-71624 : a-71627 -> Maybe-71623 a-71627 + Nothing-71625 : Maybe-71623 a-71627 in letrec - !go-71598 : list (pair data data) -> List-71588 (Tuple2-71593 data data) - = \(l-71599 : list (pair data data)) -> + !go-71618 : list (pair data data) -> List-71608 (Tuple2-71613 data data) + = \(l-71619 : list (pair data data)) -> chooseList {pair data data} - {unit -> List-71588 (Tuple2-71593 data data)} - l-71599 - (\(ds-71600 : unit) -> Nil-71589 {Tuple2-71593 data data}) - (\(ds-71601 : unit) -> - Cons-71590 - {Tuple2-71593 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} (let - !p-71602 : pair data data = headList {pair data data} l-71599 + !p-71622 : pair data data = headList {pair data data} l-71619 in - Tuple2-71594 + Tuple2-71614 {data} {data} - (fstPair {data} {data} p-71602) - (sndPair {data} {data} p-71602)) - (go-71598 (tailList {pair data data} l-71599))) + (fstPair {data} {data} p-71622) + (sndPair {data} {data} p-71622)) + (go-71618 (tailList {pair data data} l-71619))) () in let - !cfg-72697 : List-71588 (Tuple2-71593 integer ParamValue-71630) + !cfg-72718 : List-71608 (Tuple2-71613 integer ParamValue-71653) = (let - a-71844 = Tuple2-71593 integer ParamValue-71630 + a-71865 = Tuple2-71613 integer ParamValue-71653 in - \(g-71845 : - all b-71846. - (a-71844 -> b-71846 -> b-71846) -> b-71846 -> b-71846) -> - g-71845 - {List-71588 a-71844} - (\(ds-71847 : a-71844) (ds-71848 : List-71588 a-71844) -> - Cons-71590 {a-71844} ds-71847 ds-71848) - (Nil-71589 {a-71844})) - (/\a-71849 -> - \(c-71850 : - Tuple2-71593 integer ParamValue-71630 -> a-71849 -> a-71849) - (n-71851 : a-71849) -> - c-71850 - (Tuple2-71594 + \(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 {integer} - {ParamValue-71630} + {ParamValue-71653} 0 - (ParamInteger-71632 + (ParamInteger-71655 ((let - a-71852 - = Tuple2-71593 PredKey-71612 (List-71588 integer) + a-71873 + = Tuple2-71613 PredKey-71635 (List-71608 integer) in - \(g-71853 : - all b-71854. - (a-71852 -> b-71854 -> b-71854) -> - b-71854 -> - b-71854) -> - g-71853 - {List-71588 a-71852} - (\(ds-71855 : a-71852) - (ds-71856 : List-71588 a-71852) -> - Cons-71590 {a-71852} ds-71855 ds-71856) - (Nil-71589 {a-71852})) - (/\a-71857 -> - \(c-71858 : - Tuple2-71593 - PredKey-71612 - (List-71588 integer) -> - a-71857 -> - a-71857) - (n-71859 : a-71857) -> - c-71858 - (Tuple2-71594 - {PredKey-71612} - {List-71588 integer} - MinValue-71614 + \(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 ((let - a-71860 = List-71588 integer + a-71881 = List-71608 integer in - \(c-71861 : - integer -> a-71860 -> a-71860) - (n-71862 : a-71860) -> - c-71861 30 (c-71861 0 n-71862)) - (\(ds-71863 : integer) - (ds-71864 : List-71588 integer) -> - Cons-71590 + \(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-71863 - ds-71864) - (Nil-71589 {integer}))) - (c-71858 - (Tuple2-71594 - {PredKey-71612} - {List-71588 integer} - MaxValue-71613 + ds-71884 + ds-71885) + (Nil-71609 {integer}))) + (c-71879 + (Tuple2-71614 + {PredKey-71635} + {List-71608 integer} + MaxValue-71636 ((let - a-71865 = List-71588 integer + a-71886 = List-71608 integer in - \(c-71866 : - integer -> a-71865 -> a-71865) - (n-71867 : a-71865) -> - c-71866 1000 n-71867) - (\(ds-71868 : integer) - (ds-71869 : List-71588 integer) -> - Cons-71590 + \(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-71868 - ds-71869) - (Nil-71589 {integer}))) - n-71859))))) - (c-71850 - (Tuple2-71594 + ds-71889 + ds-71890) + (Nil-71609 {integer}))) + n-71880))))) + (c-71871 + (Tuple2-71614 {integer} - {ParamValue-71630} + {ParamValue-71653} 1 - (ParamInteger-71632 + (ParamInteger-71655 ((let - a-71870 - = Tuple2-71593 - PredKey-71612 - (List-71588 integer) + a-71891 + = Tuple2-71613 + PredKey-71635 + (List-71608 integer) in - \(g-71871 : - all b-71872. - (a-71870 -> b-71872 -> b-71872) -> - b-71872 -> - b-71872) -> - g-71871 - {List-71588 a-71870} - (\(ds-71873 : a-71870) - (ds-71874 : List-71588 a-71870) -> - Cons-71590 {a-71870} ds-71873 ds-71874) - (Nil-71589 {a-71870})) - (/\a-71875 -> - \(c-71876 : - Tuple2-71593 - PredKey-71612 - (List-71588 integer) -> - a-71875 -> - a-71875) - (n-71877 : a-71875) -> - c-71876 - (Tuple2-71594 - {PredKey-71612} - {List-71588 integer} - MinValue-71614 + \(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 ((let - a-71878 = List-71588 integer + a-71899 = List-71608 integer in - \(c-71879 : - integer -> a-71878 -> a-71878) - (n-71880 : a-71878) -> - c-71879 100000 (c-71879 0 n-71880)) - (\(ds-71881 : integer) - (ds-71882 : List-71588 integer) -> - Cons-71590 + \(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-71881 - ds-71882) - (Nil-71589 {integer}))) - (c-71876 - (Tuple2-71594 - {PredKey-71612} - {List-71588 integer} - MaxValue-71613 + ds-71902 + ds-71903) + (Nil-71609 {integer}))) + (c-71897 + (Tuple2-71614 + {PredKey-71635} + {List-71608 integer} + MaxValue-71636 ((let - a-71883 = List-71588 integer + a-71904 = List-71608 integer in - \(c-71884 : - integer -> a-71883 -> a-71883) - (n-71885 : a-71883) -> - c-71884 10000000 n-71885) - (\(ds-71886 : integer) - (ds-71887 : - List-71588 integer) -> - Cons-71590 + \(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-71886 - ds-71887) - (Nil-71589 {integer}))) - n-71877))))) - (c-71850 - (Tuple2-71594 + ds-71907 + ds-71908) + (Nil-71609 {integer}))) + n-71898))))) + (c-71871 + (Tuple2-71614 {integer} - {ParamValue-71630} + {ParamValue-71653} 2 - (ParamInteger-71632 + (ParamInteger-71655 ((let - a-71888 - = Tuple2-71593 - PredKey-71612 - (List-71588 integer) + a-71909 + = Tuple2-71613 + PredKey-71635 + (List-71608 integer) in - \(g-71889 : - all b-71890. - (a-71888 -> b-71890 -> b-71890) -> - b-71890 -> - b-71890) -> - g-71889 - {List-71588 a-71888} - (\(ds-71891 : a-71888) - (ds-71892 : List-71588 a-71888) -> - Cons-71590 {a-71888} ds-71891 ds-71892) - (Nil-71589 {a-71888})) - (/\a-71893 -> - \(c-71894 : - Tuple2-71593 - PredKey-71612 - (List-71588 integer) -> - a-71893 -> - a-71893) - (n-71895 : a-71893) -> - c-71894 - (Tuple2-71594 - {PredKey-71612} - {List-71588 integer} - MinValue-71614 + \(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 ((let - a-71896 = List-71588 integer + a-71917 = List-71608 integer in - \(c-71897 : - integer -> a-71896 -> a-71896) - (n-71898 : a-71896) -> - c-71897 24576 n-71898) - (\(ds-71899 : integer) - (ds-71900 : - List-71588 integer) -> - Cons-71590 + \(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-71899 - ds-71900) - (Nil-71589 {integer}))) - (c-71894 - (Tuple2-71594 - {PredKey-71612} - {List-71588 integer} - MaxValue-71613 + ds-71920 + ds-71921) + (Nil-71609 {integer}))) + (c-71915 + (Tuple2-71614 + {PredKey-71635} + {List-71608 integer} + MaxValue-71636 ((let - a-71901 = List-71588 integer + a-71922 = List-71608 integer in - \(c-71902 : + \(c-71923 : integer -> - a-71901 -> - a-71901) - (n-71903 : a-71901) -> - c-71902 122880 n-71903) - (\(ds-71904 : integer) - (ds-71905 : - List-71588 integer) -> - Cons-71590 + 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-71904 - ds-71905) - (Nil-71589 {integer}))) - n-71895))))) - (c-71850 - (Tuple2-71594 + ds-71925 + ds-71926) + (Nil-71609 {integer}))) + n-71916))))) + (c-71871 + (Tuple2-71614 {integer} - {ParamValue-71630} + {ParamValue-71653} 3 - (ParamInteger-71632 + (ParamInteger-71655 ((let - a-71906 - = Tuple2-71593 - PredKey-71612 - (List-71588 integer) + a-71927 + = Tuple2-71613 + PredKey-71635 + (List-71608 integer) in - \(g-71907 : - all b-71908. - (a-71906 -> b-71908 -> b-71908) -> - b-71908 -> - b-71908) -> - g-71907 - {List-71588 a-71906} - (\(ds-71909 : a-71906) - (ds-71910 : List-71588 a-71906) -> - Cons-71590 - {a-71906} - ds-71909 - ds-71910) - (Nil-71589 {a-71906})) - (/\a-71911 -> - \(c-71912 : - Tuple2-71593 - PredKey-71612 - (List-71588 integer) -> - a-71911 -> - a-71911) - (n-71913 : a-71911) -> - c-71912 - (Tuple2-71594 - {PredKey-71612} - {List-71588 integer} - MinValue-71614 + \(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 ((let - a-71914 = List-71588 integer + a-71935 = List-71608 integer in - \(c-71915 : + \(c-71936 : integer -> - a-71914 -> - a-71914) - (n-71916 : a-71914) -> - c-71915 0 n-71916) - (\(ds-71917 : integer) - (ds-71918 : - List-71588 integer) -> - Cons-71590 + 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-71917 - ds-71918) - (Nil-71589 {integer}))) - (c-71912 - (Tuple2-71594 - {PredKey-71612} - {List-71588 integer} - MaxValue-71613 + ds-71938 + ds-71939) + (Nil-71609 {integer}))) + (c-71933 + (Tuple2-71614 + {PredKey-71635} + {List-71608 integer} + MaxValue-71636 ((let - a-71919 - = List-71588 integer + a-71940 + = List-71608 integer in - \(c-71920 : + \(c-71941 : integer -> - a-71919 -> - a-71919) - (n-71921 : a-71919) -> - c-71920 32768 n-71921) - (\(ds-71922 : integer) - (ds-71923 : - List-71588 integer) -> - Cons-71590 + 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-71922 - ds-71923) - (Nil-71589 {integer}))) - n-71913))))) - (c-71850 - (Tuple2-71594 + ds-71943 + ds-71944) + (Nil-71609 {integer}))) + n-71934))))) + (c-71871 + (Tuple2-71614 {integer} - {ParamValue-71630} + {ParamValue-71653} 4 - (ParamInteger-71632 + (ParamInteger-71655 ((let - a-71924 - = Tuple2-71593 - PredKey-71612 - (List-71588 integer) + a-71945 + = Tuple2-71613 + PredKey-71635 + (List-71608 integer) in - \(g-71925 : - all b-71926. - (a-71924 -> b-71926 -> b-71926) -> - b-71926 -> - b-71926) -> - g-71925 - {List-71588 a-71924} - (\(ds-71927 : a-71924) - (ds-71928 : List-71588 a-71924) -> - Cons-71590 - {a-71924} - ds-71927 - ds-71928) - (Nil-71589 {a-71924})) - (/\a-71929 -> - \(c-71930 : - Tuple2-71593 - PredKey-71612 - (List-71588 integer) -> - a-71929 -> - a-71929) - (n-71931 : a-71929) -> - c-71930 - (Tuple2-71594 - {PredKey-71612} - {List-71588 integer} - MinValue-71614 + \(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 ((let - a-71932 - = List-71588 integer + a-71953 + = List-71608 integer in - \(c-71933 : + \(c-71954 : integer -> - a-71932 -> - a-71932) - (n-71934 : a-71932) -> - c-71933 0 n-71934) - (\(ds-71935 : integer) - (ds-71936 : - List-71588 integer) -> - Cons-71590 + 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-71935 - ds-71936) - (Nil-71589 {integer}))) - (c-71930 - (Tuple2-71594 - {PredKey-71612} - {List-71588 integer} - MaxValue-71613 + ds-71956 + ds-71957) + (Nil-71609 {integer}))) + (c-71951 + (Tuple2-71614 + {PredKey-71635} + {List-71608 integer} + MaxValue-71636 ((let - a-71937 - = List-71588 integer + a-71958 + = List-71608 integer in - \(c-71938 : + \(c-71959 : integer -> - a-71937 -> - a-71937) - (n-71939 : a-71937) -> - c-71938 5000 n-71939) - (\(ds-71940 : integer) - (ds-71941 : - List-71588 + a-71958 -> + a-71958) + (n-71960 : a-71958) -> + c-71959 5000 n-71960) + (\(ds-71961 : integer) + (ds-71962 : + List-71608 integer) -> - Cons-71590 + Cons-71610 {integer} - ds-71940 - ds-71941) - (Nil-71589 {integer}))) - n-71931))))) - (c-71850 - (Tuple2-71594 + ds-71961 + ds-71962) + (Nil-71609 {integer}))) + n-71952))))) + (c-71871 + (Tuple2-71614 {integer} - {ParamValue-71630} + {ParamValue-71653} 5 - (ParamInteger-71632 + (ParamInteger-71655 ((let - a-71942 - = Tuple2-71593 - PredKey-71612 - (List-71588 integer) + a-71963 + = Tuple2-71613 + PredKey-71635 + (List-71608 integer) in - \(g-71943 : - all b-71944. - (a-71942 -> - b-71944 -> - b-71944) -> - b-71944 -> - b-71944) -> - g-71943 - {List-71588 a-71942} - (\(ds-71945 : a-71942) - (ds-71946 : - List-71588 a-71942) -> - Cons-71590 - {a-71942} - ds-71945 - ds-71946) - (Nil-71589 {a-71942})) - (/\a-71947 -> - \(c-71948 : - Tuple2-71593 - PredKey-71612 - (List-71588 integer) -> - a-71947 -> - a-71947) - (n-71949 : a-71947) -> - c-71948 - (Tuple2-71594 - {PredKey-71612} - {List-71588 integer} - MinValue-71614 + \(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 ((let - a-71950 - = List-71588 integer + a-71971 + = List-71608 integer in - \(c-71951 : + \(c-71972 : integer -> - a-71950 -> - a-71950) - (n-71952 : a-71950) -> - c-71951 + a-71971 -> + a-71971) + (n-71973 : a-71971) -> + c-71972 1000000 - (c-71951 0 n-71952)) - (\(ds-71953 : integer) - (ds-71954 : - List-71588 + (c-71972 0 n-71973)) + (\(ds-71974 : integer) + (ds-71975 : + List-71608 integer) -> - Cons-71590 + Cons-71610 {integer} - ds-71953 - ds-71954) - (Nil-71589 {integer}))) - (c-71948 - (Tuple2-71594 - {PredKey-71612} - {List-71588 integer} - MaxValue-71613 + ds-71974 + ds-71975) + (Nil-71609 {integer}))) + (c-71969 + (Tuple2-71614 + {PredKey-71635} + {List-71608 integer} + MaxValue-71636 ((let - a-71955 - = List-71588 + a-71976 + = List-71608 integer in - \(c-71956 : + \(c-71977 : integer -> - a-71955 -> - a-71955) - (n-71957 : a-71955) -> - c-71956 + a-71976 -> + a-71976) + (n-71978 : a-71976) -> + c-71977 5000000 - n-71957) - (\(ds-71958 : integer) - (ds-71959 : - List-71588 + n-71978) + (\(ds-71979 : integer) + (ds-71980 : + List-71608 integer) -> - Cons-71590 + Cons-71610 {integer} - ds-71958 - ds-71959) - (Nil-71589 {integer}))) - n-71949))))) - (c-71850 - (Tuple2-71594 + ds-71979 + ds-71980) + (Nil-71609 {integer}))) + n-71970))))) + (c-71871 + (Tuple2-71614 {integer} - {ParamValue-71630} + {ParamValue-71653} 6 - (ParamInteger-71632 + (ParamInteger-71655 ((let - a-71960 - = Tuple2-71593 - PredKey-71612 - (List-71588 integer) + a-71981 + = Tuple2-71613 + PredKey-71635 + (List-71608 integer) in - \(g-71961 : - all b-71962. - (a-71960 -> - b-71962 -> - b-71962) -> - b-71962 -> - b-71962) -> - g-71961 - {List-71588 a-71960} - (\(ds-71963 : a-71960) - (ds-71964 : - List-71588 a-71960) -> - Cons-71590 - {a-71960} - ds-71963 - ds-71964) - (Nil-71589 {a-71960})) - (/\a-71965 -> - \(c-71966 : - Tuple2-71593 - PredKey-71612 - (List-71588 integer) -> - a-71965 -> - a-71965) - (n-71967 : a-71965) -> - c-71966 - (Tuple2-71594 - {PredKey-71612} - {List-71588 integer} - MinValue-71614 + \(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 ((let - a-71968 - = List-71588 + a-71989 + = List-71608 integer in - \(c-71969 : + \(c-71990 : integer -> - a-71968 -> - a-71968) - (n-71970 : a-71968) -> - c-71969 + a-71989 -> + a-71989) + (n-71991 : a-71989) -> + c-71990 250000000 - (c-71969 + (c-71990 0 - n-71970)) - (\(ds-71971 : integer) - (ds-71972 : - List-71588 + n-71991)) + (\(ds-71992 : integer) + (ds-71993 : + List-71608 integer) -> - Cons-71590 + Cons-71610 {integer} - ds-71971 - ds-71972) - (Nil-71589 {integer}))) - (c-71966 - (Tuple2-71594 - {PredKey-71612} - {List-71588 integer} - MaxValue-71613 + ds-71992 + ds-71993) + (Nil-71609 {integer}))) + (c-71987 + (Tuple2-71614 + {PredKey-71635} + {List-71608 integer} + MaxValue-71636 ((let - a-71973 - = List-71588 + a-71994 + = List-71608 integer in - \(c-71974 : + \(c-71995 : integer -> - a-71973 -> - a-71973) - (n-71975 : - a-71973) -> - c-71974 + a-71994 -> + a-71994) + (n-71996 : + a-71994) -> + c-71995 500000000 - n-71975) - (\(ds-71976 : + n-71996) + (\(ds-71997 : integer) - (ds-71977 : - List-71588 + (ds-71998 : + List-71608 integer) -> - Cons-71590 + Cons-71610 {integer} - ds-71976 - ds-71977) - (Nil-71589 + ds-71997 + ds-71998) + (Nil-71609 {integer}))) - n-71967))))) - (c-71850 - (Tuple2-71594 + n-71988))))) + (c-71871 + (Tuple2-71614 {integer} - {ParamValue-71630} + {ParamValue-71653} 7 - (ParamInteger-71632 + (ParamInteger-71655 ((let - a-71978 - = Tuple2-71593 - PredKey-71612 - (List-71588 integer) + a-71999 + = Tuple2-71613 + PredKey-71635 + (List-71608 integer) in - \(g-71979 : - all b-71980. - (a-71978 -> - b-71980 -> - b-71980) -> - b-71980 -> - b-71980) -> - g-71979 - {List-71588 a-71978} - (\(ds-71981 : a-71978) - (ds-71982 : - List-71588 a-71978) -> - Cons-71590 - {a-71978} - ds-71981 - ds-71982) - (Nil-71589 {a-71978})) - (/\a-71983 -> - \(c-71984 : - Tuple2-71593 - PredKey-71612 - (List-71588 integer) -> - a-71983 -> - a-71983) - (n-71985 : a-71983) -> - c-71984 - (Tuple2-71594 - {PredKey-71612} - {List-71588 integer} - MinValue-71614 + \(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 ((let - a-71986 - = List-71588 + a-72007 + = List-71608 integer in - \(c-71987 : + \(c-72008 : integer -> - a-71986 -> - a-71986) - (n-71988 : - a-71986) -> - c-71987 0 n-71988) - (\(ds-71989 : + a-72007 -> + a-72007) + (n-72009 : + a-72007) -> + c-72008 0 n-72009) + (\(ds-72010 : integer) - (ds-71990 : - List-71588 + (ds-72011 : + List-71608 integer) -> - Cons-71590 + Cons-71610 {integer} - ds-71989 - ds-71990) - (Nil-71589 + ds-72010 + ds-72011) + (Nil-71609 {integer}))) - n-71985)))) - (c-71850 - (Tuple2-71594 + n-72006)))) + (c-71871 + (Tuple2-71614 {integer} - {ParamValue-71630} + {ParamValue-71653} 8 - (ParamInteger-71632 + (ParamInteger-71655 ((let - a-71991 - = Tuple2-71593 - PredKey-71612 - (List-71588 integer) + a-72012 + = Tuple2-71613 + PredKey-71635 + (List-71608 integer) in - \(g-71992 : - all b-71993. - (a-71991 -> - b-71993 -> - b-71993) -> - b-71993 -> - b-71993) -> - g-71992 - {List-71588 a-71991} - (\(ds-71994 : a-71991) - (ds-71995 : - List-71588 - a-71991) -> - Cons-71590 - {a-71991} - ds-71994 - ds-71995) - (Nil-71589 {a-71991})) - (/\a-71996 -> - \(c-71997 : - Tuple2-71593 - PredKey-71612 - (List-71588 + \(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-71996 -> - a-71996) - (n-71998 : a-71996) -> - c-71997 - (Tuple2-71594 - {PredKey-71612} - {List-71588 integer} - MinValue-71614 + a-72017 -> + a-72017) + (n-72019 : a-72017) -> + c-72018 + (Tuple2-71614 + {PredKey-71635} + {List-71608 integer} + MinValue-71637 ((let - a-71999 - = List-71588 + a-72020 + = List-71608 integer in - \(c-72000 : + \(c-72021 : integer -> - a-71999 -> - a-71999) - (n-72001 : - a-71999) -> - c-72000 + a-72020 -> + a-72020) + (n-72022 : + a-72020) -> + c-72021 250 - (c-72000 + (c-72021 0 - n-72001)) - (\(ds-72002 : + n-72022)) + (\(ds-72023 : integer) - (ds-72003 : - List-71588 + (ds-72024 : + List-71608 integer) -> - Cons-71590 + Cons-71610 {integer} - ds-72002 - ds-72003) - (Nil-71589 + ds-72023 + ds-72024) + (Nil-71609 {integer}))) - (c-71997 - (Tuple2-71594 - {PredKey-71612} - {List-71588 + (c-72018 + (Tuple2-71614 + {PredKey-71635} + {List-71608 integer} - MaxValue-71613 + MaxValue-71636 ((let - a-72004 - = List-71588 + a-72025 + = List-71608 integer in - \(c-72005 : + \(c-72026 : integer -> - a-72004 -> - a-72004) - (n-72006 : - a-72004) -> - c-72005 + a-72025 -> + a-72025) + (n-72027 : + a-72025) -> + c-72026 2000 - n-72006) - (\(ds-72007 : + n-72027) + (\(ds-72028 : integer) - (ds-72008 : - List-71588 + (ds-72029 : + List-71608 integer) -> - Cons-71590 + Cons-71610 {integer} - ds-72007 - ds-72008) - (Nil-71589 + ds-72028 + ds-72029) + (Nil-71609 {integer}))) - (c-71997 - (Tuple2-71594 - {PredKey-71612} - {List-71588 + (c-72018 + (Tuple2-71614 + {PredKey-71635} + {List-71608 integer} - NotEqual-71615 + NotEqual-71638 ((let - a-72009 - = List-71588 + a-72030 + = List-71608 integer in - \(c-72010 : + \(c-72031 : integer -> - a-72009 -> - a-72009) - (n-72011 : - a-72009) -> - c-72010 + a-72030 -> + a-72030) + (n-72032 : + a-72030) -> + c-72031 0 - n-72011) - (\(ds-72012 : + n-72032) + (\(ds-72033 : integer) - (ds-72013 : - List-71588 + (ds-72034 : + List-71608 integer) -> - Cons-71590 + Cons-71610 {integer} - ds-72012 - ds-72013) - (Nil-71589 + ds-72033 + ds-72034) + (Nil-71609 {integer}))) - n-71998)))))) - (c-71850 - (Tuple2-71594 + n-72019)))))) + (c-71871 + (Tuple2-71614 {integer} - {ParamValue-71630} + {ParamValue-71653} 9 - (ParamRational-71634 + (ParamRational-71657 ((let - a-72014 - = Tuple2-71593 - PredKey-71612 - (List-71588 - Rational-71627) + a-72035 + = Tuple2-71613 + PredKey-71635 + (List-71608 + Rational-71650) in - \(g-72015 : - all b-72016. - (a-72014 -> - b-72016 -> - b-72016) -> - b-72016 -> - b-72016) -> - g-72015 - {List-71588 a-72014} - (\(ds-72017 : a-72014) - (ds-72018 : - List-71588 - a-72014) -> - Cons-71590 - {a-72014} - ds-72017 - ds-72018) - (Nil-71589 {a-72014})) - (/\a-72019 -> - \(c-72020 : - Tuple2-71593 - PredKey-71612 - (List-71588 - Rational-71627) -> - a-72019 -> - a-72019) - (n-72021 : a-72019) -> - c-72020 - (Tuple2-71594 - {PredKey-71612} - {List-71588 - Rational-71627} - MinValue-71614 + \(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 ((let - a-72022 - = List-71588 - Rational-71627 + a-72043 + = List-71608 + Rational-71650 in - \(c-72023 : - Rational-71627 -> - a-72022 -> - a-72022) - (n-72024 : - a-72022) -> - c-72023 - (unsafeRatio-71648 + \(c-72044 : + Rational-71650 -> + a-72043 -> + a-72043) + (n-72045 : + a-72043) -> + c-72044 + (unsafeRatio-71668 1 10) - (c-72023 - (unsafeRatio-71648 + (c-72044 + (unsafeRatio-71668 0 1) - n-72024)) - (\(ds-72025 : - Rational-71627) - (ds-72026 : - List-71588 - Rational-71627) -> - Cons-71590 - {Rational-71627} - ds-72025 - ds-72026) - (Nil-71589 - {Rational-71627}))) - (c-72020 - (Tuple2-71594 - {PredKey-71612} - {List-71588 - Rational-71627} - MaxValue-71613 + 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 ((let - a-72027 - = List-71588 - Rational-71627 + a-72048 + = List-71608 + Rational-71650 in - \(c-72028 : - Rational-71627 -> - a-72027 -> - a-72027) - (n-72029 : - a-72027) -> - c-72028 - (unsafeRatio-71648 + \(c-72049 : + Rational-71650 -> + a-72048 -> + a-72048) + (n-72050 : + a-72048) -> + c-72049 + (unsafeRatio-71668 1 1) - n-72029) - (\(ds-72030 : - Rational-71627) - (ds-72031 : - List-71588 - Rational-71627) -> - Cons-71590 - {Rational-71627} - ds-72030 - ds-72031) - (Nil-71589 - {Rational-71627}))) - n-72021))))) - (c-71850 - (Tuple2-71594 + 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 {integer} - {ParamValue-71630} + {ParamValue-71653} 10 - (ParamRational-71634 + (ParamRational-71657 ((let - a-72032 - = Tuple2-71593 - PredKey-71612 - (List-71588 - Rational-71627) + a-72053 + = Tuple2-71613 + PredKey-71635 + (List-71608 + Rational-71650) in - \(g-72033 : - all b-72034. - (a-72032 -> - b-72034 -> - b-72034) -> - b-72034 -> - b-72034) -> - g-72033 - {List-71588 a-72032} - (\(ds-72035 : - a-72032) - (ds-72036 : - List-71588 - a-72032) -> - Cons-71590 - {a-72032} - ds-72035 - ds-72036) - (Nil-71589 - {a-72032})) - (/\a-72037 -> - \(c-72038 : - Tuple2-71593 - PredKey-71612 - (List-71588 - Rational-71627) -> - a-72037 -> - a-72037) - (n-72039 : - a-72037) -> - c-72038 - (Tuple2-71594 - {PredKey-71612} - {List-71588 - Rational-71627} - MinValue-71614 + \(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 ((let - a-72040 - = List-71588 - Rational-71627 + a-72061 + = List-71608 + Rational-71650 in - \(c-72041 : - Rational-71627 -> - a-72040 -> - a-72040) - (n-72042 : - a-72040) -> - c-72041 - (unsafeRatio-71648 + \(c-72062 : + Rational-71650 -> + a-72061 -> + a-72061) + (n-72063 : + a-72061) -> + c-72062 + (unsafeRatio-71668 1 1000) - (c-72041 - (unsafeRatio-71648 + (c-72062 + (unsafeRatio-71668 0 1) - n-72042)) - (\(ds-72043 : - Rational-71627) - (ds-72044 : - List-71588 - Rational-71627) -> - Cons-71590 - {Rational-71627} - ds-72043 - ds-72044) - (Nil-71589 - {Rational-71627}))) - (c-72038 - (Tuple2-71594 - {PredKey-71612} - {List-71588 - Rational-71627} - MaxValue-71613 + 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 ((let - a-72045 - = List-71588 - Rational-71627 + a-72066 + = List-71608 + Rational-71650 in - \(c-72046 : - Rational-71627 -> - a-72045 -> - a-72045) - (n-72047 : - a-72045) -> - c-72046 - (unsafeRatio-71648 + \(c-72067 : + Rational-71650 -> + a-72066 -> + a-72066) + (n-72068 : + a-72066) -> + c-72067 + (unsafeRatio-71668 1 200) - n-72047) - (\(ds-72048 : - Rational-71627) - (ds-72049 : - List-71588 - Rational-71627) -> - Cons-71590 - {Rational-71627} - ds-72048 - ds-72049) - (Nil-71589 - {Rational-71627}))) - n-72039))))) - (c-71850 - (Tuple2-71594 + 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 {integer} - {ParamValue-71630} + {ParamValue-71653} 11 - (ParamRational-71634 + (ParamRational-71657 ((let - a-72050 - = Tuple2-71593 - PredKey-71612 - (List-71588 - Rational-71627) + a-72071 + = Tuple2-71613 + PredKey-71635 + (List-71608 + Rational-71650) in - \(g-72051 : - all b-72052. - (a-72050 -> - b-72052 -> - b-72052) -> - b-72052 -> - b-72052) -> - g-72051 - {List-71588 - a-72050} - (\(ds-72053 : - a-72050) - (ds-72054 : - List-71588 - a-72050) -> - Cons-71590 - {a-72050} - ds-72053 - ds-72054) - (Nil-71589 - {a-72050})) - (/\a-72055 -> - \(c-72056 : - Tuple2-71593 - PredKey-71612 - (List-71588 - Rational-71627) -> - a-72055 -> - a-72055) - (n-72057 : - a-72055) -> - c-72056 - (Tuple2-71594 - {PredKey-71612} - {List-71588 - Rational-71627} - MinValue-71614 + \(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 ((let - a-72058 - = List-71588 - Rational-71627 + a-72079 + = List-71608 + Rational-71650 in - \(c-72059 : - Rational-71627 -> - a-72058 -> - a-72058) - (n-72060 : - a-72058) -> - c-72059 - (unsafeRatio-71648 + \(c-72080 : + Rational-71650 -> + a-72079 -> + a-72079) + (n-72081 : + a-72079) -> + c-72080 + (unsafeRatio-71668 1 10) - (c-72059 - (unsafeRatio-71648 + (c-72080 + (unsafeRatio-71668 0 1) - n-72060)) - (\(ds-72061 : - Rational-71627) - (ds-72062 : - List-71588 - Rational-71627) -> - Cons-71590 - {Rational-71627} - ds-72061 - ds-72062) - (Nil-71589 - {Rational-71627}))) - (c-72056 - (Tuple2-71594 - {PredKey-71612} - {List-71588 - Rational-71627} - MaxValue-71613 + 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 ((let - a-72063 - = List-71588 - Rational-71627 + a-72084 + = List-71608 + Rational-71650 in - \(c-72064 : - Rational-71627 -> - a-72063 -> - a-72063) - (n-72065 : - a-72063) -> - c-72064 - (unsafeRatio-71648 + \(c-72085 : + Rational-71650 -> + a-72084 -> + a-72084) + (n-72086 : + a-72084) -> + c-72085 + (unsafeRatio-71668 3 10) - (c-72064 - (unsafeRatio-71648 + (c-72085 + (unsafeRatio-71668 1 1) - n-72065)) - (\(ds-72066 : - Rational-71627) - (ds-72067 : - List-71588 - Rational-71627) -> - Cons-71590 - {Rational-71627} - ds-72066 - ds-72067) - (Nil-71589 - {Rational-71627}))) - n-72057))))) - (c-71850 - (Tuple2-71594 + 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 {integer} - {ParamValue-71630} + {ParamValue-71653} 16 - (ParamInteger-71632 + (ParamInteger-71655 ((let - a-72068 - = Tuple2-71593 - PredKey-71612 - (List-71588 + a-72089 + = Tuple2-71613 + PredKey-71635 + (List-71608 integer) in - \(g-72069 : - all b-72070. - (a-72068 -> - b-72070 -> - b-72070) -> - b-72070 -> - b-72070) -> - g-72069 - {List-71588 - a-72068} - (\(ds-72071 : - a-72068) - (ds-72072 : - List-71588 - a-72068) -> - Cons-71590 - {a-72068} - ds-72071 - ds-72072) - (Nil-71589 - {a-72068})) - (/\a-72073 -> - \(c-72074 : - Tuple2-71593 - PredKey-71612 - (List-71588 + \(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 integer) -> - a-72073 -> - a-72073) - (n-72075 : - a-72073) -> - c-72074 - (Tuple2-71594 - {PredKey-71612} - {List-71588 + a-72094 -> + a-72094) + (n-72096 : + a-72094) -> + c-72095 + (Tuple2-71614 + {PredKey-71635} + {List-71608 integer} - MinValue-71614 + MinValue-71637 ((let - a-72076 - = List-71588 + a-72097 + = List-71608 integer in - \(c-72077 : + \(c-72098 : integer -> - a-72076 -> - a-72076) - (n-72078 : - a-72076) -> - c-72077 + a-72097 -> + a-72097) + (n-72099 : + a-72097) -> + c-72098 0 - n-72078) - (\(ds-72079 : + n-72099) + (\(ds-72100 : integer) - (ds-72080 : - List-71588 + (ds-72101 : + List-71608 integer) -> - Cons-71590 + Cons-71610 {integer} - ds-72079 - ds-72080) - (Nil-71589 + ds-72100 + ds-72101) + (Nil-71609 {integer}))) - (c-72074 - (Tuple2-71594 - {PredKey-71612} - {List-71588 + (c-72095 + (Tuple2-71614 + {PredKey-71635} + {List-71608 integer} - MaxValue-71613 + MaxValue-71636 ((let - a-72081 - = List-71588 + a-72102 + = List-71608 integer in - \(c-72082 : + \(c-72103 : integer -> - a-72081 -> - a-72081) - (n-72083 : - a-72081) -> - c-72082 + a-72102 -> + a-72102) + (n-72104 : + a-72102) -> + c-72103 500000000 - n-72083) - (\(ds-72084 : + n-72104) + (\(ds-72105 : integer) - (ds-72085 : - List-71588 + (ds-72106 : + List-71608 integer) -> - Cons-71590 + Cons-71610 {integer} - ds-72084 - ds-72085) - (Nil-71589 + ds-72105 + ds-72106) + (Nil-71609 {integer}))) - n-72075))))) - (c-71850 - (Tuple2-71594 + n-72096))))) + (c-71871 + (Tuple2-71614 {integer} - {ParamValue-71630} + {ParamValue-71653} 17 - (ParamInteger-71632 + (ParamInteger-71655 ((let - a-72086 - = Tuple2-71593 - PredKey-71612 - (List-71588 + a-72107 + = Tuple2-71613 + PredKey-71635 + (List-71608 integer) in - \(g-72087 : - all b-72088. - (a-72086 -> - b-72088 -> - b-72088) -> - b-72088 -> - b-72088) -> - g-72087 - {List-71588 - a-72086} - (\(ds-72089 : - a-72086) - (ds-72090 : - List-71588 - a-72086) -> - Cons-71590 - {a-72086} - ds-72089 - ds-72090) - (Nil-71589 - {a-72086})) - (/\a-72091 -> - \(c-72092 : - Tuple2-71593 - PredKey-71612 - (List-71588 + \(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 integer) -> - a-72091 -> - a-72091) - (n-72093 : - a-72091) -> - c-72092 - (Tuple2-71594 - {PredKey-71612} - {List-71588 + a-72112 -> + a-72112) + (n-72114 : + a-72112) -> + c-72113 + (Tuple2-71614 + {PredKey-71635} + {List-71608 integer} - MinValue-71614 + MinValue-71637 ((let - a-72094 - = List-71588 + a-72115 + = List-71608 integer in - \(c-72095 : + \(c-72116 : integer -> - a-72094 -> - a-72094) - (n-72096 : - a-72094) -> - c-72095 + a-72115 -> + a-72115) + (n-72117 : + a-72115) -> + c-72116 3000 - (c-72095 + (c-72116 0 - n-72096)) - (\(ds-72097 : + n-72117)) + (\(ds-72118 : integer) - (ds-72098 : - List-71588 + (ds-72119 : + List-71608 integer) -> - Cons-71590 + Cons-71610 {integer} - ds-72097 - ds-72098) - (Nil-71589 + ds-72118 + ds-72119) + (Nil-71609 {integer}))) - (c-72092 - (Tuple2-71594 - {PredKey-71612} - {List-71588 + (c-72113 + (Tuple2-71614 + {PredKey-71635} + {List-71608 integer} - MaxValue-71613 + MaxValue-71636 ((let - a-72099 - = List-71588 + a-72120 + = List-71608 integer in - \(c-72100 : + \(c-72121 : integer -> - a-72099 -> - a-72099) - (n-72101 : - a-72099) -> - c-72100 + a-72120 -> + a-72120) + (n-72122 : + a-72120) -> + c-72121 6500 - n-72101) - (\(ds-72102 : + n-72122) + (\(ds-72123 : integer) - (ds-72103 : - List-71588 + (ds-72124 : + List-71608 integer) -> - Cons-71590 + Cons-71610 {integer} - ds-72102 - ds-72103) - (Nil-71589 + ds-72123 + ds-72124) + (Nil-71609 {integer}))) - (c-72092 - (Tuple2-71594 - {PredKey-71612} - {List-71588 + (c-72113 + (Tuple2-71614 + {PredKey-71635} + {List-71608 integer} - NotEqual-71615 + NotEqual-71638 ((let - a-72104 - = List-71588 + a-72125 + = List-71608 integer in - \(c-72105 : + \(c-72126 : integer -> - a-72104 -> - a-72104) - (n-72106 : - a-72104) -> - c-72105 + a-72125 -> + a-72125) + (n-72127 : + a-72125) -> + c-72126 0 - n-72106) - (\(ds-72107 : + n-72127) + (\(ds-72128 : integer) - (ds-72108 : - List-71588 + (ds-72129 : + List-71608 integer) -> - Cons-71590 + Cons-71610 {integer} - ds-72107 - ds-72108) - (Nil-71589 + ds-72128 + ds-72129) + (Nil-71609 {integer}))) - n-72093)))))) - (c-71850 - (Tuple2-71594 + n-72114)))))) + (c-71871 + (Tuple2-71614 {integer} - {ParamValue-71630} + {ParamValue-71653} 18 - ParamAny-71631) - (c-71850 - (Tuple2-71594 + ParamAny-71654) + (c-71871 + (Tuple2-71614 {integer} - {ParamValue-71630} + {ParamValue-71653} 19 - (ParamList-71633 + (ParamList-71656 ((let - a-72109 - = List-71588 - ParamValue-71630 + a-72130 + = List-71608 + ParamValue-71653 in - \(c-72110 : - ParamValue-71630 -> - a-72109 -> - a-72109) - (n-72111 : - a-72109) -> - c-72110 - (ParamRational-71634 + \(c-72131 : + ParamValue-71653 -> + a-72130 -> + a-72130) + (n-72132 : + a-72130) -> + c-72131 + (ParamRational-71657 ((let - a-72112 - = Tuple2-71593 - PredKey-71612 - (List-71588 - Rational-71627) + a-72133 + = Tuple2-71613 + PredKey-71635 + (List-71608 + Rational-71650) in - \(g-72113 : - all b-72114. - (a-72112 -> - b-72114 -> - b-72114) -> - b-72114 -> - b-72114) -> - g-72113 - {List-71588 - a-72112} - (\(ds-72115 : - a-72112) - (ds-72116 : - List-71588 - a-72112) -> - Cons-71590 - {a-72112} - ds-72115 - ds-72116) - (Nil-71589 - {a-72112})) - (/\a-72117 -> - \(c-72118 : - Tuple2-71593 - PredKey-71612 - (List-71588 - Rational-71627) -> - a-72117 -> - a-72117) - (n-72119 : - a-72117) -> - c-72118 - (Tuple2-71594 - {PredKey-71612} - {List-71588 - Rational-71627} - MinValue-71614 + \(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 ((let - a-72120 - = List-71588 - Rational-71627 + a-72141 + = List-71608 + Rational-71650 in - \(c-72121 : - Rational-71627 -> - a-72120 -> - a-72120) - (n-72122 : - a-72120) -> - c-72121 - (unsafeRatio-71648 + \(c-72142 : + Rational-71650 -> + a-72141 -> + a-72141) + (n-72143 : + a-72141) -> + c-72142 + (unsafeRatio-71668 1 25) - n-72122) - (\(ds-72123 : - Rational-71627) - (ds-72124 : - List-71588 - Rational-71627) -> - Cons-71590 - {Rational-71627} - ds-72123 - ds-72124) - (Nil-71589 - {Rational-71627}))) - (c-72118 - (Tuple2-71594 - {PredKey-71612} - {List-71588 - Rational-71627} - MaxValue-71613 + 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 ((let - a-72125 - = List-71588 - Rational-71627 + a-72146 + = List-71608 + Rational-71650 in - \(c-72126 : - Rational-71627 -> - a-72125 -> - a-72125) - (n-72127 : - a-72125) -> - c-72126 - (unsafeRatio-71648 + \(c-72147 : + Rational-71650 -> + a-72146 -> + a-72146) + (n-72148 : + a-72146) -> + c-72147 + (unsafeRatio-71668 1 5) - n-72127) - (\(ds-72128 : - Rational-71627) - (ds-72129 : - List-71588 - Rational-71627) -> - Cons-71590 - {Rational-71627} - ds-72128 - ds-72129) - (Nil-71589 - {Rational-71627}))) - n-72119)))) - (c-72110 - (ParamRational-71634 + 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 ((let - a-72130 - = Tuple2-71593 - PredKey-71612 - (List-71588 - Rational-71627) + a-72151 + = Tuple2-71613 + PredKey-71635 + (List-71608 + Rational-71650) in - \(g-72131 : - all b-72132. - (a-72130 -> - b-72132 -> - b-72132) -> - b-72132 -> - b-72132) -> - g-72131 - {List-71588 - a-72130} - (\(ds-72133 : - a-72130) - (ds-72134 : - List-71588 - a-72130) -> - Cons-71590 - {a-72130} - ds-72133 - ds-72134) - (Nil-71589 - {a-72130})) - (/\a-72135 -> - \(c-72136 : - Tuple2-71593 - PredKey-71612 - (List-71588 - Rational-71627) -> - a-72135 -> - a-72135) - (n-72137 : - a-72135) -> - c-72136 - (Tuple2-71594 - {PredKey-71612} - {List-71588 - Rational-71627} - MinValue-71614 + \(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 ((let - a-72138 - = List-71588 - Rational-71627 + a-72159 + = List-71608 + Rational-71650 in - \(c-72139 : - Rational-71627 -> - a-72138 -> - a-72138) - (n-72140 : - a-72138) -> - c-72139 - (unsafeRatio-71648 + \(c-72160 : + Rational-71650 -> + a-72159 -> + a-72159) + (n-72161 : + a-72159) -> + c-72160 + (unsafeRatio-71668 1 20000) - n-72140) - (\(ds-72141 : - Rational-71627) - (ds-72142 : - List-71588 - Rational-71627) -> - Cons-71590 - {Rational-71627} - ds-72141 - ds-72142) - (Nil-71589 - {Rational-71627}))) - (c-72136 - (Tuple2-71594 - {PredKey-71612} - {List-71588 - Rational-71627} - MaxValue-71613 + 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 ((let - a-72143 - = List-71588 - Rational-71627 + a-72164 + = List-71608 + Rational-71650 in - \(c-72144 : - Rational-71627 -> - a-72143 -> - a-72143) - (n-72145 : - a-72143) -> - c-72144 - (unsafeRatio-71648 + \(c-72165 : + Rational-71650 -> + a-72164 -> + a-72164) + (n-72166 : + a-72164) -> + c-72165 + (unsafeRatio-71668 1 5000) - n-72145) - (\(ds-72146 : - Rational-71627) - (ds-72147 : - List-71588 - Rational-71627) -> - Cons-71590 - {Rational-71627} - ds-72146 - ds-72147) - (Nil-71589 - {Rational-71627}))) - n-72137)))) - n-72111)) - (\(ds-72148 : - ParamValue-71630) - (ds-72149 : - List-71588 - ParamValue-71630) -> - Cons-71590 - {ParamValue-71630} - ds-72148 - ds-72149) - (Nil-71589 - {ParamValue-71630})))) - (c-71850 - (Tuple2-71594 + 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 {integer} - {ParamValue-71630} + {ParamValue-71653} 20 - (ParamList-71633 + (ParamList-71656 ((let - a-72150 - = List-71588 - ParamValue-71630 + a-72171 + = List-71608 + ParamValue-71653 in - \(c-72151 : - ParamValue-71630 -> - a-72150 -> - a-72150) - (n-72152 : - a-72150) -> - c-72151 - (ParamInteger-71632 + \(c-72172 : + ParamValue-71653 -> + a-72171 -> + a-72171) + (n-72173 : + a-72171) -> + c-72172 + (ParamInteger-71655 ((let - a-72153 - = Tuple2-71593 - PredKey-71612 - (List-71588 + a-72174 + = Tuple2-71613 + PredKey-71635 + (List-71608 integer) in - \(g-72154 : - all b-72155. - (a-72153 -> - b-72155 -> - b-72155) -> - b-72155 -> - b-72155) -> - g-72154 - {List-71588 - a-72153} - (\(ds-72156 : - a-72153) - (ds-72157 : - List-71588 - a-72153) -> - Cons-71590 - {a-72153} - ds-72156 - ds-72157) - (Nil-71589 - {a-72153})) - (/\a-72158 -> - \(c-72159 : - Tuple2-71593 - PredKey-71612 - (List-71588 + \(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 integer) -> - a-72158 -> - a-72158) - (n-72160 : - a-72158) -> - c-72159 - (Tuple2-71594 - {PredKey-71612} - {List-71588 + a-72179 -> + a-72179) + (n-72181 : + a-72179) -> + c-72180 + (Tuple2-71614 + {PredKey-71635} + {List-71608 integer} - MinValue-71614 + MinValue-71637 ((let - a-72161 - = List-71588 + a-72182 + = List-71608 integer in - \(c-72162 : + \(c-72183 : integer -> - a-72161 -> - a-72161) - (n-72163 : - a-72161) -> - c-72162 + a-72182 -> + a-72182) + (n-72184 : + a-72182) -> + c-72183 0 - n-72163) - (\(ds-72164 : + n-72184) + (\(ds-72185 : integer) - (ds-72165 : - List-71588 + (ds-72186 : + List-71608 integer) -> - Cons-71590 + Cons-71610 {integer} - ds-72164 - ds-72165) - (Nil-71589 + ds-72185 + ds-72186) + (Nil-71609 {integer}))) - (c-72159 - (Tuple2-71594 - {PredKey-71612} - {List-71588 + (c-72180 + (Tuple2-71614 + {PredKey-71635} + {List-71608 integer} - MaxValue-71613 + MaxValue-71636 ((let - a-72166 - = List-71588 + a-72187 + = List-71608 integer in - \(c-72167 : + \(c-72188 : integer -> - a-72166 -> - a-72166) - (n-72168 : - a-72166) -> - c-72167 + a-72187 -> + a-72187) + (n-72189 : + a-72187) -> + c-72188 40000000 - n-72168) - (\(ds-72169 : + n-72189) + (\(ds-72190 : integer) - (ds-72170 : - List-71588 + (ds-72191 : + List-71608 integer) -> - Cons-71590 + Cons-71610 {integer} - ds-72169 - ds-72170) - (Nil-71589 + ds-72190 + ds-72191) + (Nil-71609 {integer}))) - n-72160)))) - (c-72151 - (ParamInteger-71632 + n-72181)))) + (c-72172 + (ParamInteger-71655 ((let - a-72171 - = Tuple2-71593 - PredKey-71612 - (List-71588 + a-72192 + = Tuple2-71613 + PredKey-71635 + (List-71608 integer) in - \(g-72172 : - all b-72173. - (a-72171 -> - b-72173 -> - b-72173) -> - b-72173 -> - b-72173) -> - g-72172 - {List-71588 - a-72171} - (\(ds-72174 : - a-72171) - (ds-72175 : - List-71588 - a-72171) -> - Cons-71590 - {a-72171} - ds-72174 - ds-72175) - (Nil-71589 - {a-72171})) - (/\a-72176 -> - \(c-72177 : - Tuple2-71593 - PredKey-71612 - (List-71588 + \(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 integer) -> - a-72176 -> - a-72176) - (n-72178 : - a-72176) -> - c-72177 - (Tuple2-71594 - {PredKey-71612} - {List-71588 + a-72197 -> + a-72197) + (n-72199 : + a-72197) -> + c-72198 + (Tuple2-71614 + {PredKey-71635} + {List-71608 integer} - MinValue-71614 + MinValue-71637 ((let - a-72179 - = List-71588 + a-72200 + = List-71608 integer in - \(c-72180 : + \(c-72201 : integer -> - a-72179 -> - a-72179) - (n-72181 : - a-72179) -> - c-72180 + a-72200 -> + a-72200) + (n-72202 : + a-72200) -> + c-72201 0 - n-72181) - (\(ds-72182 : + n-72202) + (\(ds-72203 : integer) - (ds-72183 : - List-71588 + (ds-72204 : + List-71608 integer) -> - Cons-71590 + Cons-71610 {integer} - ds-72182 - ds-72183) - (Nil-71589 + ds-72203 + ds-72204) + (Nil-71609 {integer}))) - (c-72177 - (Tuple2-71594 - {PredKey-71612} - {List-71588 + (c-72198 + (Tuple2-71614 + {PredKey-71635} + {List-71608 integer} - MaxValue-71613 + MaxValue-71636 ((let - a-72184 - = List-71588 + a-72205 + = List-71608 integer in - \(c-72185 : + \(c-72206 : integer -> - a-72184 -> - a-72184) - (n-72186 : - a-72184) -> - c-72185 + a-72205 -> + a-72205) + (n-72207 : + a-72205) -> + c-72206 15000000000 - n-72186) - (\(ds-72187 : + n-72207) + (\(ds-72208 : integer) - (ds-72188 : - List-71588 + (ds-72209 : + List-71608 integer) -> - Cons-71590 + Cons-71610 {integer} - ds-72187 - ds-72188) - (Nil-71589 + ds-72208 + ds-72209) + (Nil-71609 {integer}))) - n-72178)))) - n-72152)) - (\(ds-72189 : - ParamValue-71630) - (ds-72190 : - List-71588 - ParamValue-71630) -> - Cons-71590 - {ParamValue-71630} - ds-72189 - ds-72190) - (Nil-71589 - {ParamValue-71630})))) - (c-71850 - (Tuple2-71594 + 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 {integer} - {ParamValue-71630} + {ParamValue-71653} 21 - (ParamList-71633 + (ParamList-71656 ((let - a-72191 - = List-71588 - ParamValue-71630 + a-72212 + = List-71608 + ParamValue-71653 in - \(c-72192 : - ParamValue-71630 -> - a-72191 -> - a-72191) - (n-72193 : - a-72191) -> - c-72192 - (ParamInteger-71632 + \(c-72213 : + ParamValue-71653 -> + a-72212 -> + a-72212) + (n-72214 : + a-72212) -> + c-72213 + (ParamInteger-71655 ((let - a-72194 - = Tuple2-71593 - PredKey-71612 - (List-71588 + a-72215 + = Tuple2-71613 + PredKey-71635 + (List-71608 integer) in - \(g-72195 : - all b-72196. - (a-72194 -> - b-72196 -> - b-72196) -> - b-72196 -> - b-72196) -> - g-72195 - {List-71588 - a-72194} - (\(ds-72197 : - a-72194) - (ds-72198 : - List-71588 - a-72194) -> - Cons-71590 - {a-72194} - ds-72197 - ds-72198) - (Nil-71589 - {a-72194})) - (/\a-72199 -> - \(c-72200 : - Tuple2-71593 - PredKey-71612 - (List-71588 + \(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 integer) -> - a-72199 -> - a-72199) - (n-72201 : - a-72199) -> - c-72200 - (Tuple2-71594 - {PredKey-71612} - {List-71588 + a-72220 -> + a-72220) + (n-72222 : + a-72220) -> + c-72221 + (Tuple2-71614 + {PredKey-71635} + {List-71608 integer} - MinValue-71614 + MinValue-71637 ((let - a-72202 - = List-71588 + a-72223 + = List-71608 integer in - \(c-72203 : + \(c-72224 : integer -> - a-72202 -> - a-72202) - (n-72204 : - a-72202) -> - c-72203 + a-72223 -> + a-72223) + (n-72225 : + a-72223) -> + c-72224 0 - n-72204) - (\(ds-72205 : + n-72225) + (\(ds-72226 : integer) - (ds-72206 : - List-71588 + (ds-72227 : + List-71608 integer) -> - Cons-71590 + Cons-71610 {integer} - ds-72205 - ds-72206) - (Nil-71589 + ds-72226 + ds-72227) + (Nil-71609 {integer}))) - (c-72200 - (Tuple2-71594 - {PredKey-71612} - {List-71588 + (c-72221 + (Tuple2-71614 + {PredKey-71635} + {List-71608 integer} - MaxValue-71613 + MaxValue-71636 ((let - a-72207 - = List-71588 + a-72228 + = List-71608 integer in - \(c-72208 : + \(c-72229 : integer -> - a-72207 -> - a-72207) - (n-72209 : - a-72207) -> - c-72208 + a-72228 -> + a-72228) + (n-72230 : + a-72228) -> + c-72229 120000000 - n-72209) - (\(ds-72210 : + n-72230) + (\(ds-72231 : integer) - (ds-72211 : - List-71588 + (ds-72232 : + List-71608 integer) -> - Cons-71590 + Cons-71610 {integer} - ds-72210 - ds-72211) - (Nil-71589 + ds-72231 + ds-72232) + (Nil-71609 {integer}))) - n-72201)))) - (c-72192 - (ParamInteger-71632 + n-72222)))) + (c-72213 + (ParamInteger-71655 ((let - a-72212 - = Tuple2-71593 - PredKey-71612 - (List-71588 + a-72233 + = Tuple2-71613 + PredKey-71635 + (List-71608 integer) in - \(g-72213 : - all b-72214. - (a-72212 -> - b-72214 -> - b-72214) -> - b-72214 -> - b-72214) -> - g-72213 - {List-71588 - a-72212} - (\(ds-72215 : - a-72212) - (ds-72216 : - List-71588 - a-72212) -> - Cons-71590 - {a-72212} - ds-72215 - ds-72216) - (Nil-71589 - {a-72212})) - (/\a-72217 -> - \(c-72218 : - Tuple2-71593 - PredKey-71612 - (List-71588 + \(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 integer) -> - a-72217 -> - a-72217) - (n-72219 : - a-72217) -> - c-72218 - (Tuple2-71594 - {PredKey-71612} - {List-71588 + a-72238 -> + a-72238) + (n-72240 : + a-72238) -> + c-72239 + (Tuple2-71614 + {PredKey-71635} + {List-71608 integer} - MinValue-71614 + MinValue-71637 ((let - a-72220 - = List-71588 + a-72241 + = List-71608 integer in - \(c-72221 : + \(c-72242 : integer -> - a-72220 -> - a-72220) - (n-72222 : - a-72220) -> - c-72221 + a-72241 -> + a-72241) + (n-72243 : + a-72241) -> + c-72242 0 - n-72222) - (\(ds-72223 : + n-72243) + (\(ds-72244 : integer) - (ds-72224 : - List-71588 + (ds-72245 : + List-71608 integer) -> - Cons-71590 + Cons-71610 {integer} - ds-72223 - ds-72224) - (Nil-71589 + ds-72244 + ds-72245) + (Nil-71609 {integer}))) - (c-72218 - (Tuple2-71594 - {PredKey-71612} - {List-71588 + (c-72239 + (Tuple2-71614 + {PredKey-71635} + {List-71608 integer} - MaxValue-71613 + MaxValue-71636 ((let - a-72225 - = List-71588 + a-72246 + = List-71608 integer in - \(c-72226 : + \(c-72247 : integer -> - a-72225 -> - a-72225) - (n-72227 : - a-72225) -> - c-72226 + a-72246 -> + a-72246) + (n-72248 : + a-72246) -> + c-72247 40000000000 - n-72227) - (\(ds-72228 : + n-72248) + (\(ds-72249 : integer) - (ds-72229 : - List-71588 + (ds-72250 : + List-71608 integer) -> - Cons-71590 + Cons-71610 {integer} - ds-72228 - ds-72229) - (Nil-71589 + ds-72249 + ds-72250) + (Nil-71609 {integer}))) - n-72219)))) - n-72193)) - (\(ds-72230 : - ParamValue-71630) - (ds-72231 : - List-71588 - ParamValue-71630) -> - Cons-71590 - {ParamValue-71630} - ds-72230 - ds-72231) - (Nil-71589 - {ParamValue-71630})))) - (c-71850 - (Tuple2-71594 + 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 {integer} - {ParamValue-71630} + {ParamValue-71653} 22 - (ParamInteger-71632 + (ParamInteger-71655 ((let - a-72232 - = Tuple2-71593 - PredKey-71612 - (List-71588 + a-72253 + = Tuple2-71613 + PredKey-71635 + (List-71608 integer) in - \(g-72233 : - all b-72234. - (a-72232 -> - b-72234 -> - b-72234) -> - b-72234 -> - b-72234) -> - g-72233 - {List-71588 - a-72232} - (\(ds-72235 : - a-72232) - (ds-72236 : - List-71588 - a-72232) -> - Cons-71590 - {a-72232} - ds-72235 - ds-72236) - (Nil-71589 - {a-72232})) - (/\a-72237 -> - \(c-72238 : - Tuple2-71593 - PredKey-71612 - (List-71588 + \(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 integer) -> - a-72237 -> - a-72237) - (n-72239 : - a-72237) -> - c-72238 - (Tuple2-71594 - {PredKey-71612} - {List-71588 + a-72258 -> + a-72258) + (n-72260 : + a-72258) -> + c-72259 + (Tuple2-71614 + {PredKey-71635} + {List-71608 integer} - MinValue-71614 + MinValue-71637 ((let - a-72240 - = List-71588 + a-72261 + = List-71608 integer in - \(c-72241 : + \(c-72262 : integer -> - a-72240 -> - a-72240) - (n-72242 : - a-72240) -> - c-72241 + a-72261 -> + a-72261) + (n-72263 : + a-72261) -> + c-72262 0 - n-72242) - (\(ds-72243 : + n-72263) + (\(ds-72264 : integer) - (ds-72244 : - List-71588 + (ds-72265 : + List-71608 integer) -> - Cons-71590 + Cons-71610 {integer} - ds-72243 - ds-72244) - (Nil-71589 + ds-72264 + ds-72265) + (Nil-71609 {integer}))) - (c-72238 - (Tuple2-71594 - {PredKey-71612} - {List-71588 + (c-72259 + (Tuple2-71614 + {PredKey-71635} + {List-71608 integer} - MaxValue-71613 + MaxValue-71636 ((let - a-72245 - = List-71588 + a-72266 + = List-71608 integer in - \(c-72246 : + \(c-72267 : integer -> - a-72245 -> - a-72245) - (n-72247 : - a-72245) -> - c-72246 + a-72266 -> + a-72266) + (n-72268 : + a-72266) -> + c-72267 12288 - n-72247) - (\(ds-72248 : + n-72268) + (\(ds-72269 : integer) - (ds-72249 : - List-71588 + (ds-72270 : + List-71608 integer) -> - Cons-71590 + Cons-71610 {integer} - ds-72248 - ds-72249) - (Nil-71589 + ds-72269 + ds-72270) + (Nil-71609 {integer}))) - n-72239))))) - (c-71850 - (Tuple2-71594 + n-72260))))) + (c-71871 + (Tuple2-71614 {integer} - {ParamValue-71630} + {ParamValue-71653} 23 - (ParamInteger-71632 + (ParamInteger-71655 ((let - a-72250 - = Tuple2-71593 - PredKey-71612 - (List-71588 + a-72271 + = Tuple2-71613 + PredKey-71635 + (List-71608 integer) in - \(g-72251 : - all b-72252. - (a-72250 -> - b-72252 -> - b-72252) -> - b-72252 -> - b-72252) -> - g-72251 - {List-71588 - a-72250} - (\(ds-72253 : - a-72250) - (ds-72254 : - List-71588 - a-72250) -> - Cons-71590 - {a-72250} - ds-72253 - ds-72254) - (Nil-71589 - {a-72250})) - (/\a-72255 -> - \(c-72256 : - Tuple2-71593 - PredKey-71612 - (List-71588 + \(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 integer) -> - a-72255 -> - a-72255) - (n-72257 : - a-72255) -> - c-72256 - (Tuple2-71594 - {PredKey-71612} - {List-71588 + a-72276 -> + a-72276) + (n-72278 : + a-72276) -> + c-72277 + (Tuple2-71614 + {PredKey-71635} + {List-71608 integer} - MinValue-71614 + MinValue-71637 ((let - a-72258 - = List-71588 + a-72279 + = List-71608 integer in - \(c-72259 : + \(c-72280 : integer -> - a-72258 -> - a-72258) - (n-72260 : - a-72258) -> - c-72259 + a-72279 -> + a-72279) + (n-72281 : + a-72279) -> + c-72280 100 - (c-72259 + (c-72280 0 - n-72260)) - (\(ds-72261 : + n-72281)) + (\(ds-72282 : integer) - (ds-72262 : - List-71588 + (ds-72283 : + List-71608 integer) -> - Cons-71590 + Cons-71610 {integer} - ds-72261 - ds-72262) - (Nil-71589 + ds-72282 + ds-72283) + (Nil-71609 {integer}))) - (c-72256 - (Tuple2-71594 - {PredKey-71612} - {List-71588 + (c-72277 + (Tuple2-71614 + {PredKey-71635} + {List-71608 integer} - MaxValue-71613 + MaxValue-71636 ((let - a-72263 - = List-71588 + a-72284 + = List-71608 integer in - \(c-72264 : + \(c-72285 : integer -> - a-72263 -> - a-72263) - (n-72265 : - a-72263) -> - c-72264 + a-72284 -> + a-72284) + (n-72286 : + a-72284) -> + c-72285 200 - n-72265) - (\(ds-72266 : + n-72286) + (\(ds-72287 : integer) - (ds-72267 : - List-71588 + (ds-72288 : + List-71608 integer) -> - Cons-71590 + Cons-71610 {integer} - ds-72266 - ds-72267) - (Nil-71589 + ds-72287 + ds-72288) + (Nil-71609 {integer}))) - (c-72256 - (Tuple2-71594 - {PredKey-71612} - {List-71588 + (c-72277 + (Tuple2-71614 + {PredKey-71635} + {List-71608 integer} - NotEqual-71615 + NotEqual-71638 ((let - a-72268 - = List-71588 + a-72289 + = List-71608 integer in - \(c-72269 : + \(c-72290 : integer -> - a-72268 -> - a-72268) - (n-72270 : - a-72268) -> - c-72269 + a-72289 -> + a-72289) + (n-72291 : + a-72289) -> + c-72290 0 - n-72270) - (\(ds-72271 : + n-72291) + (\(ds-72292 : integer) - (ds-72272 : - List-71588 + (ds-72293 : + List-71608 integer) -> - Cons-71590 + Cons-71610 {integer} - ds-72271 - ds-72272) - (Nil-71589 + ds-72292 + ds-72293) + (Nil-71609 {integer}))) - n-72257)))))) - (c-71850 - (Tuple2-71594 + n-72278)))))) + (c-71871 + (Tuple2-71614 {integer} - {ParamValue-71630} + {ParamValue-71653} 24 - (ParamInteger-71632 + (ParamInteger-71655 ((let - a-72273 - = Tuple2-71593 - PredKey-71612 - (List-71588 + a-72294 + = Tuple2-71613 + PredKey-71635 + (List-71608 integer) in - \(g-72274 : - all b-72275. - (a-72273 -> - b-72275 -> - b-72275) -> - b-72275 -> - b-72275) -> - g-72274 - {List-71588 - a-72273} - (\(ds-72276 : - a-72273) - (ds-72277 : - List-71588 - a-72273) -> - Cons-71590 - {a-72273} - ds-72276 - ds-72277) - (Nil-71589 - {a-72273})) - (/\a-72278 -> - \(c-72279 : - Tuple2-71593 - PredKey-71612 - (List-71588 + \(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 integer) -> - a-72278 -> - a-72278) - (n-72280 : - a-72278) -> - c-72279 - (Tuple2-71594 - {PredKey-71612} - {List-71588 + a-72299 -> + a-72299) + (n-72301 : + a-72299) -> + c-72300 + (Tuple2-71614 + {PredKey-71635} + {List-71608 integer} - MinValue-71614 + MinValue-71637 ((let - a-72281 - = List-71588 + a-72302 + = List-71608 integer in - \(c-72282 : + \(c-72303 : integer -> - a-72281 -> - a-72281) - (n-72283 : - a-72281) -> - c-72282 + a-72302 -> + a-72302) + (n-72304 : + a-72302) -> + c-72303 1 - n-72283) - (\(ds-72284 : + n-72304) + (\(ds-72305 : integer) - (ds-72285 : - List-71588 + (ds-72306 : + List-71608 integer) -> - Cons-71590 + Cons-71610 {integer} - ds-72284 - ds-72285) - (Nil-71589 + ds-72305 + ds-72306) + (Nil-71609 {integer}))) - n-72280)))) - (c-71850 - (Tuple2-71594 + n-72301)))) + (c-71871 + (Tuple2-71614 {integer} - {ParamValue-71630} + {ParamValue-71653} 25 - (ParamList-71633 + (ParamList-71656 ((let - a-72286 - = List-71588 - ParamValue-71630 + a-72307 + = List-71608 + ParamValue-71653 in - \(c-72287 : - ParamValue-71630 -> - a-72286 -> - a-72286) - (n-72288 : - a-72286) -> - c-72287 - (ParamRational-71634 + \(c-72308 : + ParamValue-71653 -> + a-72307 -> + a-72307) + (n-72309 : + a-72307) -> + c-72308 + (ParamRational-71657 ((let - a-72289 - = Tuple2-71593 - PredKey-71612 - (List-71588 - Rational-71627) + a-72310 + = Tuple2-71613 + PredKey-71635 + (List-71608 + Rational-71650) in - \(g-72290 : - all b-72291. - (a-72289 -> - b-72291 -> - b-72291) -> - b-72291 -> - b-72291) -> - g-72290 - {List-71588 - a-72289} - (\(ds-72292 : - a-72289) - (ds-72293 : - List-71588 - a-72289) -> - Cons-71590 - {a-72289} - ds-72292 - ds-72293) - (Nil-71589 - {a-72289})) - (/\a-72294 -> - \(c-72295 : - Tuple2-71593 - PredKey-71612 - (List-71588 - Rational-71627) -> - a-72294 -> - a-72294) - (n-72296 : - a-72294) -> - c-72295 - (Tuple2-71594 - {PredKey-71612} - {List-71588 - Rational-71627} - MinValue-71614 + \(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 ((let - a-72297 - = List-71588 - Rational-71627 + a-72318 + = List-71608 + Rational-71650 in - \(c-72298 : - Rational-71627 -> - a-72297 -> - a-72297) - (n-72299 : - a-72297) -> - c-72298 - (unsafeRatio-71648 + \(c-72319 : + Rational-71650 -> + a-72318 -> + a-72318) + (n-72320 : + a-72318) -> + c-72319 + (unsafeRatio-71668 1 2) - (c-72298 - (unsafeRatio-71648 + (c-72319 + (unsafeRatio-71668 51 100) - n-72299)) - (\(ds-72300 : - Rational-71627) - (ds-72301 : - List-71588 - Rational-71627) -> - Cons-71590 - {Rational-71627} - ds-72300 - ds-72301) - (Nil-71589 - {Rational-71627}))) - (c-72295 - (Tuple2-71594 - {PredKey-71612} - {List-71588 - Rational-71627} - MaxValue-71613 + 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 ((let - a-72302 - = List-71588 - Rational-71627 + a-72323 + = List-71608 + Rational-71650 in - \(c-72303 : - Rational-71627 -> - a-72302 -> - a-72302) - (n-72304 : - a-72302) -> - c-72303 - (unsafeRatio-71648 + \(c-72324 : + Rational-71650 -> + a-72323 -> + a-72323) + (n-72325 : + a-72323) -> + c-72324 + (unsafeRatio-71668 1 1) - (c-72303 - (unsafeRatio-71648 + (c-72324 + (unsafeRatio-71668 3 4) - n-72304)) - (\(ds-72305 : - Rational-71627) - (ds-72306 : - List-71588 - Rational-71627) -> - Cons-71590 - {Rational-71627} - ds-72305 - ds-72306) - (Nil-71589 - {Rational-71627}))) - n-72296)))) - (c-72287 - (ParamRational-71634 + 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 ((let - a-72307 - = Tuple2-71593 - PredKey-71612 - (List-71588 - Rational-71627) + a-72328 + = Tuple2-71613 + PredKey-71635 + (List-71608 + Rational-71650) in - \(g-72308 : - all b-72309. - (a-72307 -> - b-72309 -> - b-72309) -> - b-72309 -> - b-72309) -> - g-72308 - {List-71588 - a-72307} - (\(ds-72310 : - a-72307) - (ds-72311 : - List-71588 - a-72307) -> - Cons-71590 - {a-72307} - ds-72310 - ds-72311) - (Nil-71589 - {a-72307})) - (/\a-72312 -> - \(c-72313 : - Tuple2-71593 - PredKey-71612 - (List-71588 - Rational-71627) -> - a-72312 -> - a-72312) - (n-72314 : - a-72312) -> - c-72313 - (Tuple2-71594 - {PredKey-71612} - {List-71588 - Rational-71627} - MinValue-71614 + \(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 ((let - a-72315 - = List-71588 - Rational-71627 + a-72336 + = List-71608 + Rational-71650 in - \(c-72316 : - Rational-71627 -> - a-72315 -> - a-72315) - (n-72317 : - a-72315) -> - c-72316 - (unsafeRatio-71648 + \(c-72337 : + Rational-71650 -> + a-72336 -> + a-72336) + (n-72338 : + a-72336) -> + c-72337 + (unsafeRatio-71668 1 2) - (c-72316 - (unsafeRatio-71648 + (c-72337 + (unsafeRatio-71668 13 20) - n-72317)) - (\(ds-72318 : - Rational-71627) - (ds-72319 : - List-71588 - Rational-71627) -> - Cons-71590 - {Rational-71627} - ds-72318 - ds-72319) - (Nil-71589 - {Rational-71627}))) - (c-72313 - (Tuple2-71594 - {PredKey-71612} - {List-71588 - Rational-71627} - MaxValue-71613 + 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 ((let - a-72320 - = List-71588 - Rational-71627 + a-72341 + = List-71608 + Rational-71650 in - \(c-72321 : - Rational-71627 -> - a-72320 -> - a-72320) - (n-72322 : - a-72320) -> - c-72321 - (unsafeRatio-71648 + \(c-72342 : + Rational-71650 -> + a-72341 -> + a-72341) + (n-72343 : + a-72341) -> + c-72342 + (unsafeRatio-71668 1 1) - (c-72321 - (unsafeRatio-71648 + (c-72342 + (unsafeRatio-71668 9 10) - n-72322)) - (\(ds-72323 : - Rational-71627) - (ds-72324 : - List-71588 - Rational-71627) -> - Cons-71590 - {Rational-71627} - ds-72323 - ds-72324) - (Nil-71589 - {Rational-71627}))) - n-72314)))) - (c-72287 - (ParamRational-71634 + 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 ((let - a-72325 - = Tuple2-71593 - PredKey-71612 - (List-71588 - Rational-71627) + a-72346 + = Tuple2-71613 + PredKey-71635 + (List-71608 + Rational-71650) in - \(g-72326 : - all b-72327. - (a-72325 -> - b-72327 -> - b-72327) -> - b-72327 -> - b-72327) -> - g-72326 - {List-71588 - a-72325} - (\(ds-72328 : - a-72325) - (ds-72329 : - List-71588 - a-72325) -> - Cons-71590 - {a-72325} - ds-72328 - ds-72329) - (Nil-71589 - {a-72325})) - (/\a-72330 -> - \(c-72331 : - Tuple2-71593 - PredKey-71612 - (List-71588 - Rational-71627) -> - a-72330 -> - a-72330) - (n-72332 : - a-72330) -> - c-72331 - (Tuple2-71594 - {PredKey-71612} - {List-71588 - Rational-71627} - MinValue-71614 + \(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 ((let - a-72333 - = List-71588 - Rational-71627 + a-72354 + = List-71608 + Rational-71650 in - \(c-72334 : - Rational-71627 -> - a-72333 -> - a-72333) - (n-72335 : - a-72333) -> - c-72334 - (unsafeRatio-71648 + \(c-72355 : + Rational-71650 -> + a-72354 -> + a-72354) + (n-72356 : + a-72354) -> + c-72355 + (unsafeRatio-71668 1 2) - (c-72334 - (unsafeRatio-71648 + (c-72355 + (unsafeRatio-71668 13 20) - n-72335)) - (\(ds-72336 : - Rational-71627) - (ds-72337 : - List-71588 - Rational-71627) -> - Cons-71590 - {Rational-71627} - ds-72336 - ds-72337) - (Nil-71589 - {Rational-71627}))) - (c-72331 - (Tuple2-71594 - {PredKey-71612} - {List-71588 - Rational-71627} - MaxValue-71613 + 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 ((let - a-72338 - = List-71588 - Rational-71627 + a-72359 + = List-71608 + Rational-71650 in - \(c-72339 : - Rational-71627 -> - a-72338 -> - a-72338) - (n-72340 : - a-72338) -> - c-72339 - (unsafeRatio-71648 + \(c-72360 : + Rational-71650 -> + a-72359 -> + a-72359) + (n-72361 : + a-72359) -> + c-72360 + (unsafeRatio-71668 1 1) - (c-72339 - (unsafeRatio-71648 + (c-72360 + (unsafeRatio-71668 9 10) - n-72340)) - (\(ds-72341 : - Rational-71627) - (ds-72342 : - List-71588 - Rational-71627) -> - Cons-71590 - {Rational-71627} - ds-72341 - ds-72342) - (Nil-71589 - {Rational-71627}))) - n-72332)))) - (c-72287 - (ParamRational-71634 + 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 ((let - a-72343 - = Tuple2-71593 - PredKey-71612 - (List-71588 - Rational-71627) + a-72364 + = Tuple2-71613 + PredKey-71635 + (List-71608 + Rational-71650) in - \(g-72344 : - all b-72345. - (a-72343 -> - b-72345 -> - b-72345) -> - b-72345 -> - b-72345) -> - g-72344 - {List-71588 - a-72343} - (\(ds-72346 : - a-72343) - (ds-72347 : - List-71588 - a-72343) -> - Cons-71590 - {a-72343} - ds-72346 - ds-72347) - (Nil-71589 - {a-72343})) - (/\a-72348 -> - \(c-72349 : - Tuple2-71593 - PredKey-71612 - (List-71588 - Rational-71627) -> - a-72348 -> - a-72348) - (n-72350 : - a-72348) -> - c-72349 - (Tuple2-71594 - {PredKey-71612} - {List-71588 - Rational-71627} - MinValue-71614 + \(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 ((let - a-72351 - = List-71588 - Rational-71627 + a-72372 + = List-71608 + Rational-71650 in - \(c-72352 : - Rational-71627 -> - a-72351 -> - a-72351) - (n-72353 : - a-72351) -> - c-72352 - (unsafeRatio-71648 + \(c-72373 : + Rational-71650 -> + a-72372 -> + a-72372) + (n-72374 : + a-72372) -> + c-72373 + (unsafeRatio-71668 1 2) - (c-72352 - (unsafeRatio-71648 + (c-72373 + (unsafeRatio-71668 51 100) - n-72353)) - (\(ds-72354 : - Rational-71627) - (ds-72355 : - List-71588 - Rational-71627) -> - Cons-71590 - {Rational-71627} - ds-72354 - ds-72355) - (Nil-71589 - {Rational-71627}))) - (c-72349 - (Tuple2-71594 - {PredKey-71612} - {List-71588 - Rational-71627} - MaxValue-71613 + 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 ((let - a-72356 - = List-71588 - Rational-71627 + a-72377 + = List-71608 + Rational-71650 in - \(c-72357 : - Rational-71627 -> - a-72356 -> - a-72356) - (n-72358 : - a-72356) -> - c-72357 - (unsafeRatio-71648 + \(c-72378 : + Rational-71650 -> + a-72377 -> + a-72377) + (n-72379 : + a-72377) -> + c-72378 + (unsafeRatio-71668 1 1) - (c-72357 - (unsafeRatio-71648 + (c-72378 + (unsafeRatio-71668 4 5) - n-72358)) - (\(ds-72359 : - Rational-71627) - (ds-72360 : - List-71588 - Rational-71627) -> - Cons-71590 - {Rational-71627} - ds-72359 - ds-72360) - (Nil-71589 - {Rational-71627}))) - n-72350)))) - (c-72287 - (ParamRational-71634 + 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 ((let - a-72361 - = Tuple2-71593 - PredKey-71612 - (List-71588 - Rational-71627) + a-72382 + = Tuple2-71613 + PredKey-71635 + (List-71608 + Rational-71650) in - \(g-72362 : - all b-72363. - (a-72361 -> - b-72363 -> - b-72363) -> - b-72363 -> - b-72363) -> - g-72362 - {List-71588 - a-72361} - (\(ds-72364 : - a-72361) - (ds-72365 : - List-71588 - a-72361) -> - Cons-71590 - {a-72361} - ds-72364 - ds-72365) - (Nil-71589 - {a-72361})) - (/\a-72366 -> - \(c-72367 : - Tuple2-71593 - PredKey-71612 - (List-71588 - Rational-71627) -> - a-72366 -> - a-72366) - (n-72368 : - a-72366) -> - c-72367 - (Tuple2-71594 - {PredKey-71612} - {List-71588 - Rational-71627} - MinValue-71614 + \(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 ((let - a-72369 - = List-71588 - Rational-71627 + a-72390 + = List-71608 + Rational-71650 in - \(c-72370 : - Rational-71627 -> - a-72369 -> - a-72369) - (n-72371 : - a-72369) -> - c-72370 - (unsafeRatio-71648 + \(c-72391 : + Rational-71650 -> + a-72390 -> + a-72390) + (n-72392 : + a-72390) -> + c-72391 + (unsafeRatio-71668 1 2) - n-72371) - (\(ds-72372 : - Rational-71627) - (ds-72373 : - List-71588 - Rational-71627) -> - Cons-71590 - {Rational-71627} - ds-72372 - ds-72373) - (Nil-71589 - {Rational-71627}))) - (c-72367 - (Tuple2-71594 - {PredKey-71612} - {List-71588 - Rational-71627} - MaxValue-71613 + 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 ((let - a-72374 - = List-71588 - Rational-71627 + a-72395 + = List-71608 + Rational-71650 in - \(c-72375 : - Rational-71627 -> - a-72374 -> - a-72374) - (n-72376 : - a-72374) -> - c-72375 - (unsafeRatio-71648 + \(c-72396 : + Rational-71650 -> + a-72395 -> + a-72395) + (n-72397 : + a-72395) -> + c-72396 + (unsafeRatio-71668 1 1) - n-72376) - (\(ds-72377 : - Rational-71627) - (ds-72378 : - List-71588 - Rational-71627) -> - Cons-71590 - {Rational-71627} - ds-72377 - ds-72378) - (Nil-71589 - {Rational-71627}))) - n-72368)))) - n-72288))))) - (\(ds-72379 : - ParamValue-71630) - (ds-72380 : - List-71588 - ParamValue-71630) -> - Cons-71590 - {ParamValue-71630} - ds-72379 - ds-72380) - (Nil-71589 - {ParamValue-71630})))) - (c-71850 - (Tuple2-71594 + 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 {integer} - {ParamValue-71630} + {ParamValue-71653} 26 - (ParamList-71633 + (ParamList-71656 ((let - a-72381 - = List-71588 - ParamValue-71630 + a-72402 + = List-71608 + ParamValue-71653 in - \(c-72382 : - ParamValue-71630 -> - a-72381 -> - a-72381) - (n-72383 : - a-72381) -> - c-72382 - (ParamRational-71634 + \(c-72403 : + ParamValue-71653 -> + a-72402 -> + a-72402) + (n-72404 : + a-72402) -> + c-72403 + (ParamRational-71657 ((let - a-72384 - = Tuple2-71593 - PredKey-71612 - (List-71588 - Rational-71627) + a-72405 + = Tuple2-71613 + PredKey-71635 + (List-71608 + Rational-71650) in - \(g-72385 : - all b-72386. - (a-72384 -> - b-72386 -> - b-72386) -> - b-72386 -> - b-72386) -> - g-72385 - {List-71588 - a-72384} - (\(ds-72387 : - a-72384) - (ds-72388 : - List-71588 - a-72384) -> - Cons-71590 - {a-72384} - ds-72387 - ds-72388) - (Nil-71589 - {a-72384})) - (/\a-72389 -> - \(c-72390 : - Tuple2-71593 - PredKey-71612 - (List-71588 - Rational-71627) -> - a-72389 -> - a-72389) - (n-72391 : - a-72389) -> - c-72390 - (Tuple2-71594 - {PredKey-71612} - {List-71588 - Rational-71627} - MinValue-71614 + \(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 ((let - a-72392 - = List-71588 - Rational-71627 + a-72413 + = List-71608 + Rational-71650 in - \(c-72393 : - Rational-71627 -> - a-72392 -> - a-72392) - (n-72394 : - a-72392) -> - c-72393 - (unsafeRatio-71648 + \(c-72414 : + Rational-71650 -> + a-72413 -> + a-72413) + (n-72415 : + a-72413) -> + c-72414 + (unsafeRatio-71668 1 2) - (c-72393 - (unsafeRatio-71648 + (c-72414 + (unsafeRatio-71668 51 100) - n-72394)) - (\(ds-72395 : - Rational-71627) - (ds-72396 : - List-71588 - Rational-71627) -> - Cons-71590 - {Rational-71627} - ds-72395 - ds-72396) - (Nil-71589 - {Rational-71627}))) - (c-72390 - (Tuple2-71594 - {PredKey-71612} - {List-71588 - Rational-71627} - MaxValue-71613 + 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 ((let - a-72397 - = List-71588 - Rational-71627 + a-72418 + = List-71608 + Rational-71650 in - \(c-72398 : - Rational-71627 -> - a-72397 -> - a-72397) - (n-72399 : - a-72397) -> - c-72398 - (unsafeRatio-71648 + \(c-72419 : + Rational-71650 -> + a-72418 -> + a-72418) + (n-72420 : + a-72418) -> + c-72419 + (unsafeRatio-71668 1 1) - (c-72398 - (unsafeRatio-71648 + (c-72419 + (unsafeRatio-71668 3 4) - n-72399)) - (\(ds-72400 : - Rational-71627) - (ds-72401 : - List-71588 - Rational-71627) -> - Cons-71590 - {Rational-71627} - ds-72400 - ds-72401) - (Nil-71589 - {Rational-71627}))) - n-72391)))) - (c-72382 - (ParamRational-71634 + 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 ((let - a-72402 - = Tuple2-71593 - PredKey-71612 - (List-71588 - Rational-71627) + a-72423 + = Tuple2-71613 + PredKey-71635 + (List-71608 + Rational-71650) in - \(g-72403 : - all b-72404. - (a-72402 -> - b-72404 -> - b-72404) -> - b-72404 -> - b-72404) -> - g-72403 - {List-71588 - a-72402} - (\(ds-72405 : - a-72402) - (ds-72406 : - List-71588 - a-72402) -> - Cons-71590 - {a-72402} - ds-72405 - ds-72406) - (Nil-71589 - {a-72402})) - (/\a-72407 -> - \(c-72408 : - Tuple2-71593 - PredKey-71612 - (List-71588 - Rational-71627) -> - a-72407 -> - a-72407) - (n-72409 : - a-72407) -> - c-72408 - (Tuple2-71594 - {PredKey-71612} - {List-71588 - Rational-71627} - MinValue-71614 + \(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 ((let - a-72410 - = List-71588 - Rational-71627 + a-72431 + = List-71608 + Rational-71650 in - \(c-72411 : - Rational-71627 -> - a-72410 -> - a-72410) - (n-72412 : - a-72410) -> - c-72411 - (unsafeRatio-71648 + \(c-72432 : + Rational-71650 -> + a-72431 -> + a-72431) + (n-72433 : + a-72431) -> + c-72432 + (unsafeRatio-71668 1 2) - (c-72411 - (unsafeRatio-71648 + (c-72432 + (unsafeRatio-71668 13 20) - n-72412)) - (\(ds-72413 : - Rational-71627) - (ds-72414 : - List-71588 - Rational-71627) -> - Cons-71590 - {Rational-71627} - ds-72413 - ds-72414) - (Nil-71589 - {Rational-71627}))) - (c-72408 - (Tuple2-71594 - {PredKey-71612} - {List-71588 - Rational-71627} - MaxValue-71613 + 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 ((let - a-72415 - = List-71588 - Rational-71627 + a-72436 + = List-71608 + Rational-71650 in - \(c-72416 : - Rational-71627 -> - a-72415 -> - a-72415) - (n-72417 : - a-72415) -> - c-72416 - (unsafeRatio-71648 + \(c-72437 : + Rational-71650 -> + a-72436 -> + a-72436) + (n-72438 : + a-72436) -> + c-72437 + (unsafeRatio-71668 1 1) - (c-72416 - (unsafeRatio-71648 + (c-72437 + (unsafeRatio-71668 9 10) - n-72417)) - (\(ds-72418 : - Rational-71627) - (ds-72419 : - List-71588 - Rational-71627) -> - Cons-71590 - {Rational-71627} - ds-72418 - ds-72419) - (Nil-71589 - {Rational-71627}))) - n-72409)))) - (c-72382 - (ParamRational-71634 + 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 ((let - a-72420 - = Tuple2-71593 - PredKey-71612 - (List-71588 - Rational-71627) + a-72441 + = Tuple2-71613 + PredKey-71635 + (List-71608 + Rational-71650) in - \(g-72421 : - all b-72422. - (a-72420 -> - b-72422 -> - b-72422) -> - b-72422 -> - b-72422) -> - g-72421 - {List-71588 - a-72420} - (\(ds-72423 : - a-72420) - (ds-72424 : - List-71588 - a-72420) -> - Cons-71590 - {a-72420} - ds-72423 - ds-72424) - (Nil-71589 - {a-72420})) - (/\a-72425 -> - \(c-72426 : - Tuple2-71593 - PredKey-71612 - (List-71588 - Rational-71627) -> - a-72425 -> - a-72425) - (n-72427 : - a-72425) -> - c-72426 - (Tuple2-71594 - {PredKey-71612} - {List-71588 - Rational-71627} - MinValue-71614 + \(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 ((let - a-72428 - = List-71588 - Rational-71627 + a-72449 + = List-71608 + Rational-71650 in - \(c-72429 : - Rational-71627 -> - a-72428 -> - a-72428) - (n-72430 : - a-72428) -> - c-72429 - (unsafeRatio-71648 + \(c-72450 : + Rational-71650 -> + a-72449 -> + a-72449) + (n-72451 : + a-72449) -> + c-72450 + (unsafeRatio-71668 1 2) - (c-72429 - (unsafeRatio-71648 + (c-72450 + (unsafeRatio-71668 13 20) - n-72430)) - (\(ds-72431 : - Rational-71627) - (ds-72432 : - List-71588 - Rational-71627) -> - Cons-71590 - {Rational-71627} - ds-72431 - ds-72432) - (Nil-71589 - {Rational-71627}))) - (c-72426 - (Tuple2-71594 - {PredKey-71612} - {List-71588 - Rational-71627} - MaxValue-71613 + 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 ((let - a-72433 - = List-71588 - Rational-71627 + a-72454 + = List-71608 + Rational-71650 in - \(c-72434 : - Rational-71627 -> - a-72433 -> - a-72433) - (n-72435 : - a-72433) -> - c-72434 - (unsafeRatio-71648 + \(c-72455 : + Rational-71650 -> + a-72454 -> + a-72454) + (n-72456 : + a-72454) -> + c-72455 + (unsafeRatio-71668 1 1) - (c-72434 - (unsafeRatio-71648 + (c-72455 + (unsafeRatio-71668 9 10) - n-72435)) - (\(ds-72436 : - Rational-71627) - (ds-72437 : - List-71588 - Rational-71627) -> - Cons-71590 - {Rational-71627} - ds-72436 - ds-72437) - (Nil-71589 - {Rational-71627}))) - n-72427)))) - (c-72382 - (ParamRational-71634 + 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 ((let - a-72438 - = Tuple2-71593 - PredKey-71612 - (List-71588 - Rational-71627) + a-72459 + = Tuple2-71613 + PredKey-71635 + (List-71608 + Rational-71650) in - \(g-72439 : - all b-72440. - (a-72438 -> - b-72440 -> - b-72440) -> - b-72440 -> - b-72440) -> - g-72439 - {List-71588 - a-72438} - (\(ds-72441 : - a-72438) - (ds-72442 : - List-71588 - a-72438) -> - Cons-71590 - {a-72438} - ds-72441 - ds-72442) - (Nil-71589 - {a-72438})) - (/\a-72443 -> - \(c-72444 : - Tuple2-71593 - PredKey-71612 - (List-71588 - Rational-71627) -> - a-72443 -> - a-72443) - (n-72445 : - a-72443) -> - c-72444 - (Tuple2-71594 - {PredKey-71612} - {List-71588 - Rational-71627} - MinValue-71614 + \(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 ((let - a-72446 - = List-71588 - Rational-71627 + a-72467 + = List-71608 + Rational-71650 in - \(c-72447 : - Rational-71627 -> - a-72446 -> - a-72446) - (n-72448 : - a-72446) -> - c-72447 - (unsafeRatio-71648 + \(c-72468 : + Rational-71650 -> + a-72467 -> + a-72467) + (n-72469 : + a-72467) -> + c-72468 + (unsafeRatio-71668 1 2) - (c-72447 - (unsafeRatio-71648 + (c-72468 + (unsafeRatio-71668 13 20) - n-72448)) - (\(ds-72449 : - Rational-71627) - (ds-72450 : - List-71588 - Rational-71627) -> - Cons-71590 - {Rational-71627} - ds-72449 - ds-72450) - (Nil-71589 - {Rational-71627}))) - (c-72444 - (Tuple2-71594 - {PredKey-71612} - {List-71588 - Rational-71627} - MaxValue-71613 + 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 ((let - a-72451 - = List-71588 - Rational-71627 + a-72472 + = List-71608 + Rational-71650 in - \(c-72452 : - Rational-71627 -> - a-72451 -> - a-72451) - (n-72453 : - a-72451) -> - c-72452 - (unsafeRatio-71648 + \(c-72473 : + Rational-71650 -> + a-72472 -> + a-72472) + (n-72474 : + a-72472) -> + c-72473 + (unsafeRatio-71668 1 1) - (c-72452 - (unsafeRatio-71648 + (c-72473 + (unsafeRatio-71668 9 10) - n-72453)) - (\(ds-72454 : - Rational-71627) - (ds-72455 : - List-71588 - Rational-71627) -> - Cons-71590 - {Rational-71627} - ds-72454 - ds-72455) - (Nil-71589 - {Rational-71627}))) - n-72445)))) - (c-72382 - (ParamRational-71634 + 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 ((let - a-72456 - = Tuple2-71593 - PredKey-71612 - (List-71588 - Rational-71627) + a-72477 + = Tuple2-71613 + PredKey-71635 + (List-71608 + Rational-71650) in - \(g-72457 : - all b-72458. - (a-72456 -> - b-72458 -> - b-72458) -> - b-72458 -> - b-72458) -> - g-72457 - {List-71588 - a-72456} - (\(ds-72459 : - a-72456) - (ds-72460 : - List-71588 - a-72456) -> - Cons-71590 - {a-72456} - ds-72459 - ds-72460) - (Nil-71589 - {a-72456})) - (/\a-72461 -> - \(c-72462 : - Tuple2-71593 - PredKey-71612 - (List-71588 - Rational-71627) -> - a-72461 -> - a-72461) - (n-72463 : - a-72461) -> - c-72462 - (Tuple2-71594 - {PredKey-71612} - {List-71588 - Rational-71627} - MinValue-71614 + \(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 ((let - a-72464 - = List-71588 - Rational-71627 + a-72485 + = List-71608 + Rational-71650 in - \(c-72465 : - Rational-71627 -> - a-72464 -> - a-72464) - (n-72466 : - a-72464) -> - c-72465 - (unsafeRatio-71648 + \(c-72486 : + Rational-71650 -> + a-72485 -> + a-72485) + (n-72487 : + a-72485) -> + c-72486 + (unsafeRatio-71668 1 2) - (c-72465 - (unsafeRatio-71648 + (c-72486 + (unsafeRatio-71668 51 100) - n-72466)) - (\(ds-72467 : - Rational-71627) - (ds-72468 : - List-71588 - Rational-71627) -> - Cons-71590 - {Rational-71627} - ds-72467 - ds-72468) - (Nil-71589 - {Rational-71627}))) - (c-72462 - (Tuple2-71594 - {PredKey-71612} - {List-71588 - Rational-71627} - MaxValue-71613 + 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 ((let - a-72469 - = List-71588 - Rational-71627 + a-72490 + = List-71608 + Rational-71650 in - \(c-72470 : - Rational-71627 -> - a-72469 -> - a-72469) - (n-72471 : - a-72469) -> - c-72470 - (unsafeRatio-71648 + \(c-72491 : + Rational-71650 -> + a-72490 -> + a-72490) + (n-72492 : + a-72490) -> + c-72491 + (unsafeRatio-71668 1 1) - (c-72470 - (unsafeRatio-71648 + (c-72491 + (unsafeRatio-71668 4 5) - n-72471)) - (\(ds-72472 : - Rational-71627) - (ds-72473 : - List-71588 - Rational-71627) -> - Cons-71590 - {Rational-71627} - ds-72472 - ds-72473) - (Nil-71589 - {Rational-71627}))) - n-72463)))) - (c-72382 - (ParamRational-71634 + 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 ((let - a-72474 - = Tuple2-71593 - PredKey-71612 - (List-71588 - Rational-71627) + a-72495 + = Tuple2-71613 + PredKey-71635 + (List-71608 + Rational-71650) in - \(g-72475 : - all b-72476. - (a-72474 -> - b-72476 -> - b-72476) -> - b-72476 -> - b-72476) -> - g-72475 - {List-71588 - a-72474} - (\(ds-72477 : - a-72474) - (ds-72478 : - List-71588 - a-72474) -> - Cons-71590 - {a-72474} - ds-72477 - ds-72478) - (Nil-71589 - {a-72474})) - (/\a-72479 -> - \(c-72480 : - Tuple2-71593 - PredKey-71612 - (List-71588 - Rational-71627) -> - a-72479 -> - a-72479) - (n-72481 : - a-72479) -> - c-72480 - (Tuple2-71594 - {PredKey-71612} - {List-71588 - Rational-71627} - MinValue-71614 + \(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 ((let - a-72482 - = List-71588 - Rational-71627 + a-72503 + = List-71608 + Rational-71650 in - \(c-72483 : - Rational-71627 -> - a-72482 -> - a-72482) - (n-72484 : - a-72482) -> - c-72483 - (unsafeRatio-71648 + \(c-72504 : + Rational-71650 -> + a-72503 -> + a-72503) + (n-72505 : + a-72503) -> + c-72504 + (unsafeRatio-71668 1 2) - (c-72483 - (unsafeRatio-71648 + (c-72504 + (unsafeRatio-71668 51 100) - n-72484)) - (\(ds-72485 : - Rational-71627) - (ds-72486 : - List-71588 - Rational-71627) -> - Cons-71590 - {Rational-71627} - ds-72485 - ds-72486) - (Nil-71589 - {Rational-71627}))) - (c-72480 - (Tuple2-71594 - {PredKey-71612} - {List-71588 - Rational-71627} - MaxValue-71613 + 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 ((let - a-72487 - = List-71588 - Rational-71627 + a-72508 + = List-71608 + Rational-71650 in - \(c-72488 : - Rational-71627 -> - a-72487 -> - a-72487) - (n-72489 : - a-72487) -> - c-72488 - (unsafeRatio-71648 + \(c-72509 : + Rational-71650 -> + a-72508 -> + a-72508) + (n-72510 : + a-72508) -> + c-72509 + (unsafeRatio-71668 1 1) - (c-72488 - (unsafeRatio-71648 + (c-72509 + (unsafeRatio-71668 3 4) - n-72489)) - (\(ds-72490 : - Rational-71627) - (ds-72491 : - List-71588 - Rational-71627) -> - Cons-71590 - {Rational-71627} - ds-72490 - ds-72491) - (Nil-71589 - {Rational-71627}))) - n-72481)))) - (c-72382 - (ParamRational-71634 + 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 ((let - a-72492 - = Tuple2-71593 - PredKey-71612 - (List-71588 - Rational-71627) + a-72513 + = Tuple2-71613 + PredKey-71635 + (List-71608 + Rational-71650) in - \(g-72493 : - all b-72494. - (a-72492 -> - b-72494 -> - b-72494) -> - b-72494 -> - b-72494) -> - g-72493 - {List-71588 - a-72492} - (\(ds-72495 : - a-72492) - (ds-72496 : - List-71588 - a-72492) -> - Cons-71590 - {a-72492} - ds-72495 - ds-72496) - (Nil-71589 - {a-72492})) - (/\a-72497 -> - \(c-72498 : - Tuple2-71593 - PredKey-71612 - (List-71588 - Rational-71627) -> - a-72497 -> - a-72497) - (n-72499 : - a-72497) -> - c-72498 - (Tuple2-71594 - {PredKey-71612} - {List-71588 - Rational-71627} - MinValue-71614 + \(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 ((let - a-72500 - = List-71588 - Rational-71627 + a-72521 + = List-71608 + Rational-71650 in - \(c-72501 : - Rational-71627 -> - a-72500 -> - a-72500) - (n-72502 : - a-72500) -> - c-72501 - (unsafeRatio-71648 + \(c-72522 : + Rational-71650 -> + a-72521 -> + a-72521) + (n-72523 : + a-72521) -> + c-72522 + (unsafeRatio-71668 1 2) - (c-72501 - (unsafeRatio-71648 + (c-72522 + (unsafeRatio-71668 51 100) - n-72502)) - (\(ds-72503 : - Rational-71627) - (ds-72504 : - List-71588 - Rational-71627) -> - Cons-71590 - {Rational-71627} - ds-72503 - ds-72504) - (Nil-71589 - {Rational-71627}))) - (c-72498 - (Tuple2-71594 - {PredKey-71612} - {List-71588 - Rational-71627} - MaxValue-71613 + 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 ((let - a-72505 - = List-71588 - Rational-71627 + a-72526 + = List-71608 + Rational-71650 in - \(c-72506 : - Rational-71627 -> - a-72505 -> - a-72505) - (n-72507 : - a-72505) -> - c-72506 - (unsafeRatio-71648 + \(c-72527 : + Rational-71650 -> + a-72526 -> + a-72526) + (n-72528 : + a-72526) -> + c-72527 + (unsafeRatio-71668 1 1) - (c-72506 - (unsafeRatio-71648 + (c-72527 + (unsafeRatio-71668 3 4) - n-72507)) - (\(ds-72508 : - Rational-71627) - (ds-72509 : - List-71588 - Rational-71627) -> - Cons-71590 - {Rational-71627} - ds-72508 - ds-72509) - (Nil-71589 - {Rational-71627}))) - n-72499)))) - (c-72382 - (ParamRational-71634 + 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 ((let - a-72510 - = Tuple2-71593 - PredKey-71612 - (List-71588 - Rational-71627) + a-72531 + = Tuple2-71613 + PredKey-71635 + (List-71608 + Rational-71650) in - \(g-72511 : - all b-72512. - (a-72510 -> - b-72512 -> - b-72512) -> - b-72512 -> - b-72512) -> - g-72511 - {List-71588 - a-72510} - (\(ds-72513 : - a-72510) - (ds-72514 : - List-71588 - a-72510) -> - Cons-71590 - {a-72510} - ds-72513 - ds-72514) - (Nil-71589 - {a-72510})) - (/\a-72515 -> - \(c-72516 : - Tuple2-71593 - PredKey-71612 - (List-71588 - Rational-71627) -> - a-72515 -> - a-72515) - (n-72517 : - a-72515) -> - c-72516 - (Tuple2-71594 - {PredKey-71612} - {List-71588 - Rational-71627} - MinValue-71614 + \(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 ((let - a-72518 - = List-71588 - Rational-71627 + a-72539 + = List-71608 + Rational-71650 in - \(c-72519 : - Rational-71627 -> - a-72518 -> - a-72518) - (n-72520 : - a-72518) -> - c-72519 - (unsafeRatio-71648 + \(c-72540 : + Rational-71650 -> + a-72539 -> + a-72539) + (n-72541 : + a-72539) -> + c-72540 + (unsafeRatio-71668 1 2) - (c-72519 - (unsafeRatio-71648 + (c-72540 + (unsafeRatio-71668 51 100) - n-72520)) - (\(ds-72521 : - Rational-71627) - (ds-72522 : - List-71588 - Rational-71627) -> - Cons-71590 - {Rational-71627} - ds-72521 - ds-72522) - (Nil-71589 - {Rational-71627}))) - (c-72516 - (Tuple2-71594 - {PredKey-71612} - {List-71588 - Rational-71627} - MaxValue-71613 + 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 ((let - a-72523 - = List-71588 - Rational-71627 + a-72544 + = List-71608 + Rational-71650 in - \(c-72524 : - Rational-71627 -> - a-72523 -> - a-72523) - (n-72525 : - a-72523) -> - c-72524 - (unsafeRatio-71648 + \(c-72545 : + Rational-71650 -> + a-72544 -> + a-72544) + (n-72546 : + a-72544) -> + c-72545 + (unsafeRatio-71668 1 1) - (c-72524 - (unsafeRatio-71648 + (c-72545 + (unsafeRatio-71668 3 4) - n-72525)) - (\(ds-72526 : - Rational-71627) - (ds-72527 : - List-71588 - Rational-71627) -> - Cons-71590 - {Rational-71627} - ds-72526 - ds-72527) - (Nil-71589 - {Rational-71627}))) - n-72517)))) - (c-72382 - (ParamRational-71634 + 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 ((let - a-72528 - = Tuple2-71593 - PredKey-71612 - (List-71588 - Rational-71627) + a-72549 + = Tuple2-71613 + PredKey-71635 + (List-71608 + Rational-71650) in - \(g-72529 : - all b-72530. - (a-72528 -> - b-72530 -> - b-72530) -> - b-72530 -> - b-72530) -> - g-72529 - {List-71588 - a-72528} - (\(ds-72531 : - a-72528) - (ds-72532 : - List-71588 - a-72528) -> - Cons-71590 - {a-72528} - ds-72531 - ds-72532) - (Nil-71589 - {a-72528})) - (/\a-72533 -> - \(c-72534 : - Tuple2-71593 - PredKey-71612 - (List-71588 - Rational-71627) -> - a-72533 -> - a-72533) - (n-72535 : - a-72533) -> - c-72534 - (Tuple2-71594 - {PredKey-71612} - {List-71588 - Rational-71627} - MinValue-71614 + \(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 ((let - a-72536 - = List-71588 - Rational-71627 + a-72557 + = List-71608 + Rational-71650 in - \(c-72537 : - Rational-71627 -> - a-72536 -> - a-72536) - (n-72538 : - a-72536) -> - c-72537 - (unsafeRatio-71648 + \(c-72558 : + Rational-71650 -> + a-72557 -> + a-72557) + (n-72559 : + a-72557) -> + c-72558 + (unsafeRatio-71668 1 2) - (c-72537 - (unsafeRatio-71648 + (c-72558 + (unsafeRatio-71668 3 4) - n-72538)) - (\(ds-72539 : - Rational-71627) - (ds-72540 : - List-71588 - Rational-71627) -> - Cons-71590 - {Rational-71627} - ds-72539 - ds-72540) - (Nil-71589 - {Rational-71627}))) - (c-72534 - (Tuple2-71594 - {PredKey-71612} - {List-71588 - Rational-71627} - MaxValue-71613 + 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 ((let - a-72541 - = List-71588 - Rational-71627 + a-72562 + = List-71608 + Rational-71650 in - \(c-72542 : - Rational-71627 -> - a-72541 -> - a-72541) - (n-72543 : - a-72541) -> - c-72542 - (unsafeRatio-71648 + \(c-72563 : + Rational-71650 -> + a-72562 -> + a-72562) + (n-72564 : + a-72562) -> + c-72563 + (unsafeRatio-71668 1 1) - (c-72542 - (unsafeRatio-71648 + (c-72563 + (unsafeRatio-71668 9 10) - n-72543)) - (\(ds-72544 : - Rational-71627) - (ds-72545 : - List-71588 - Rational-71627) -> - Cons-71590 - {Rational-71627} - ds-72544 - ds-72545) - (Nil-71589 - {Rational-71627}))) - n-72535)))) - (c-72382 - (ParamRational-71634 + 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 ((let - a-72546 - = Tuple2-71593 - PredKey-71612 - (List-71588 - Rational-71627) + a-72567 + = Tuple2-71613 + PredKey-71635 + (List-71608 + Rational-71650) in - \(g-72547 : - all b-72548. - (a-72546 -> - b-72548 -> - b-72548) -> - b-72548 -> - b-72548) -> - g-72547 - {List-71588 - a-72546} - (\(ds-72549 : - a-72546) - (ds-72550 : - List-71588 - a-72546) -> - Cons-71590 - {a-72546} - ds-72549 - ds-72550) - (Nil-71589 - {a-72546})) - (/\a-72551 -> - \(c-72552 : - Tuple2-71593 - PredKey-71612 - (List-71588 - Rational-71627) -> - a-72551 -> - a-72551) - (n-72553 : - a-72551) -> - c-72552 - (Tuple2-71594 - {PredKey-71612} - {List-71588 - Rational-71627} - MinValue-71614 + \(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 ((let - a-72554 - = List-71588 - Rational-71627 + a-72575 + = List-71608 + Rational-71650 in - \(c-72555 : - Rational-71627 -> - a-72554 -> - a-72554) - (n-72556 : - a-72554) -> - c-72555 - (unsafeRatio-71648 + \(c-72576 : + Rational-71650 -> + a-72575 -> + a-72575) + (n-72577 : + a-72575) -> + c-72576 + (unsafeRatio-71668 1 2) - n-72556) - (\(ds-72557 : - Rational-71627) - (ds-72558 : - List-71588 - Rational-71627) -> - Cons-71590 - {Rational-71627} - ds-72557 - ds-72558) - (Nil-71589 - {Rational-71627}))) - (c-72552 - (Tuple2-71594 - {PredKey-71612} - {List-71588 - Rational-71627} - MaxValue-71613 + 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 ((let - a-72559 - = List-71588 - Rational-71627 + a-72580 + = List-71608 + Rational-71650 in - \(c-72560 : - Rational-71627 -> - a-72559 -> - a-72559) - (n-72561 : - a-72559) -> - c-72560 - (unsafeRatio-71648 + \(c-72581 : + Rational-71650 -> + a-72580 -> + a-72580) + (n-72582 : + a-72580) -> + c-72581 + (unsafeRatio-71668 1 1) - n-72561) - (\(ds-72562 : - Rational-71627) - (ds-72563 : - List-71588 - Rational-71627) -> - Cons-71590 - {Rational-71627} - ds-72562 - ds-72563) - (Nil-71589 - {Rational-71627}))) - n-72553)))) - n-72383)))))))))) - (\(ds-72564 : - ParamValue-71630) - (ds-72565 : - List-71588 - ParamValue-71630) -> - Cons-71590 - {ParamValue-71630} - ds-72564 - ds-72565) - (Nil-71589 - {ParamValue-71630})))) - (c-71850 - (Tuple2-71594 + 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 {integer} - {ParamValue-71630} + {ParamValue-71653} 27 - (ParamInteger-71632 + (ParamInteger-71655 ((let - a-72566 - = Tuple2-71593 - PredKey-71612 - (List-71588 + a-72587 + = Tuple2-71613 + PredKey-71635 + (List-71608 integer) in - \(g-72567 : - all b-72568. - (a-72566 -> - b-72568 -> - b-72568) -> - b-72568 -> - b-72568) -> - g-72567 - {List-71588 - a-72566} - (\(ds-72569 : - a-72566) - (ds-72570 : - List-71588 - a-72566) -> - Cons-71590 - {a-72566} - ds-72569 - ds-72570) - (Nil-71589 - {a-72566})) - (/\a-72571 -> - \(c-72572 : - Tuple2-71593 - PredKey-71612 - (List-71588 + \(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 integer) -> - a-72571 -> - a-72571) - (n-72573 : - a-72571) -> - c-72572 - (Tuple2-71594 - {PredKey-71612} - {List-71588 + a-72592 -> + a-72592) + (n-72594 : + a-72592) -> + c-72593 + (Tuple2-71614 + {PredKey-71635} + {List-71608 integer} - MinValue-71614 + MinValue-71637 ((let - a-72574 - = List-71588 + a-72595 + = List-71608 integer in - \(c-72575 : + \(c-72596 : integer -> - a-72574 -> - a-72574) - (n-72576 : - a-72574) -> - c-72575 + a-72595 -> + a-72595) + (n-72597 : + a-72595) -> + c-72596 0 - (c-72575 + (c-72596 3 - n-72576)) - (\(ds-72577 : + n-72597)) + (\(ds-72598 : integer) - (ds-72578 : - List-71588 + (ds-72599 : + List-71608 integer) -> - Cons-71590 + Cons-71610 {integer} - ds-72577 - ds-72578) - (Nil-71589 + ds-72598 + ds-72599) + (Nil-71609 {integer}))) - (c-72572 - (Tuple2-71594 - {PredKey-71612} - {List-71588 + (c-72593 + (Tuple2-71614 + {PredKey-71635} + {List-71608 integer} - MaxValue-71613 + MaxValue-71636 ((let - a-72579 - = List-71588 + a-72600 + = List-71608 integer in - \(c-72580 : + \(c-72601 : integer -> - a-72579 -> - a-72579) - (n-72581 : - a-72579) -> - c-72580 + a-72600 -> + a-72600) + (n-72602 : + a-72600) -> + c-72601 10 - n-72581) - (\(ds-72582 : + n-72602) + (\(ds-72603 : integer) - (ds-72583 : - List-71588 + (ds-72604 : + List-71608 integer) -> - Cons-71590 + Cons-71610 {integer} - ds-72582 - ds-72583) - (Nil-71589 + ds-72603 + ds-72604) + (Nil-71609 {integer}))) - n-72573))))) - (c-71850 - (Tuple2-71594 + n-72594))))) + (c-71871 + (Tuple2-71614 {integer} - {ParamValue-71630} + {ParamValue-71653} 28 - (ParamInteger-71632 + (ParamInteger-71655 ((let - a-72584 - = Tuple2-71593 - PredKey-71612 - (List-71588 + a-72605 + = Tuple2-71613 + PredKey-71635 + (List-71608 integer) in - \(g-72585 : - all b-72586. - (a-72584 -> - b-72586 -> - b-72586) -> - b-72586 -> - b-72586) -> - g-72585 - {List-71588 - a-72584} - (\(ds-72587 : - a-72584) - (ds-72588 : - List-71588 - a-72584) -> - Cons-71590 - {a-72584} - ds-72587 - ds-72588) - (Nil-71589 - {a-72584})) - (/\a-72589 -> - \(c-72590 : - Tuple2-71593 - PredKey-71612 - (List-71588 + \(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 integer) -> - a-72589 -> - a-72589) - (n-72591 : - a-72589) -> - c-72590 - (Tuple2-71594 - {PredKey-71612} - {List-71588 + a-72610 -> + a-72610) + (n-72612 : + a-72610) -> + c-72611 + (Tuple2-71614 + {PredKey-71635} + {List-71608 integer} - MinValue-71614 + MinValue-71637 ((let - a-72592 - = List-71588 + a-72613 + = List-71608 integer in - \(c-72593 : + \(c-72614 : integer -> - a-72592 -> - a-72592) - (n-72594 : - a-72592) -> - c-72593 + a-72613 -> + a-72613) + (n-72615 : + a-72613) -> + c-72614 0 - (c-72593 + (c-72614 18 - n-72594)) - (\(ds-72595 : + n-72615)) + (\(ds-72616 : integer) - (ds-72596 : - List-71588 + (ds-72617 : + List-71608 integer) -> - Cons-71590 + Cons-71610 {integer} - ds-72595 - ds-72596) - (Nil-71589 + ds-72616 + ds-72617) + (Nil-71609 {integer}))) - (c-72590 - (Tuple2-71594 - {PredKey-71612} - {List-71588 + (c-72611 + (Tuple2-71614 + {PredKey-71635} + {List-71608 integer} - MaxValue-71613 + MaxValue-71636 ((let - a-72597 - = List-71588 + a-72618 + = List-71608 integer in - \(c-72598 : + \(c-72619 : integer -> - a-72597 -> - a-72597) - (n-72599 : - a-72597) -> - c-72598 + a-72618 -> + a-72618) + (n-72620 : + a-72618) -> + c-72619 293 - n-72599) - (\(ds-72600 : + n-72620) + (\(ds-72621 : integer) - (ds-72601 : - List-71588 + (ds-72622 : + List-71608 integer) -> - Cons-71590 + Cons-71610 {integer} - ds-72600 - ds-72601) - (Nil-71589 + ds-72621 + ds-72622) + (Nil-71609 {integer}))) - (c-72590 - (Tuple2-71594 - {PredKey-71612} - {List-71588 + (c-72611 + (Tuple2-71614 + {PredKey-71635} + {List-71608 integer} - NotEqual-71615 + NotEqual-71638 ((let - a-72602 - = List-71588 + a-72623 + = List-71608 integer in - \(c-72603 : + \(c-72624 : integer -> - a-72602 -> - a-72602) - (n-72604 : - a-72602) -> - c-72603 + a-72623 -> + a-72623) + (n-72625 : + a-72623) -> + c-72624 0 - n-72604) - (\(ds-72605 : + n-72625) + (\(ds-72626 : integer) - (ds-72606 : - List-71588 + (ds-72627 : + List-71608 integer) -> - Cons-71590 + Cons-71610 {integer} - ds-72605 - ds-72606) - (Nil-71589 + ds-72626 + ds-72627) + (Nil-71609 {integer}))) - n-72591)))))) - (c-71850 - (Tuple2-71594 + n-72612)))))) + (c-71871 + (Tuple2-71614 {integer} - {ParamValue-71630} + {ParamValue-71653} 29 - (ParamInteger-71632 + (ParamInteger-71655 ((let - a-72607 - = Tuple2-71593 - PredKey-71612 - (List-71588 + a-72628 + = Tuple2-71613 + PredKey-71635 + (List-71608 integer) in - \(g-72608 : - all b-72609. - (a-72607 -> - b-72609 -> - b-72609) -> - b-72609 -> - b-72609) -> - g-72608 - {List-71588 - a-72607} - (\(ds-72610 : - a-72607) - (ds-72611 : - List-71588 - a-72607) -> - Cons-71590 - {a-72607} - ds-72610 - ds-72611) - (Nil-71589 - {a-72607})) - (/\a-72612 -> - \(c-72613 : - Tuple2-71593 - PredKey-71612 - (List-71588 + \(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 integer) -> - a-72612 -> - a-72612) - (n-72614 : - a-72612) -> - c-72613 - (Tuple2-71594 - {PredKey-71612} - {List-71588 + a-72633 -> + a-72633) + (n-72635 : + a-72633) -> + c-72634 + (Tuple2-71614 + {PredKey-71635} + {List-71608 integer} - MinValue-71614 + MinValue-71637 ((let - a-72615 - = List-71588 + a-72636 + = List-71608 integer in - \(c-72616 : + \(c-72637 : integer -> - a-72615 -> - a-72615) - (n-72617 : - a-72615) -> - c-72616 + a-72636 -> + a-72636) + (n-72638 : + a-72636) -> + c-72637 1 - n-72617) - (\(ds-72618 : + n-72638) + (\(ds-72639 : integer) - (ds-72619 : - List-71588 + (ds-72640 : + List-71608 integer) -> - Cons-71590 + Cons-71610 {integer} - ds-72618 - ds-72619) - (Nil-71589 + ds-72639 + ds-72640) + (Nil-71609 {integer}))) - (c-72613 - (Tuple2-71594 - {PredKey-71612} - {List-71588 + (c-72634 + (Tuple2-71614 + {PredKey-71635} + {List-71608 integer} - MaxValue-71613 + MaxValue-71636 ((let - a-72620 - = List-71588 + a-72641 + = List-71608 integer in - \(c-72621 : + \(c-72642 : integer -> - a-72620 -> - a-72620) - (n-72622 : - a-72620) -> - c-72621 + a-72641 -> + a-72641) + (n-72643 : + a-72641) -> + c-72642 15 - n-72622) - (\(ds-72623 : + n-72643) + (\(ds-72644 : integer) - (ds-72624 : - List-71588 + (ds-72645 : + List-71608 integer) -> - Cons-71590 + Cons-71610 {integer} - ds-72623 - ds-72624) - (Nil-71589 + ds-72644 + ds-72645) + (Nil-71609 {integer}))) - n-72614))))) - (c-71850 - (Tuple2-71594 + n-72635))))) + (c-71871 + (Tuple2-71614 {integer} - {ParamValue-71630} + {ParamValue-71653} 30 - (ParamInteger-71632 + (ParamInteger-71655 ((let - a-72625 - = Tuple2-71593 - PredKey-71612 - (List-71588 + a-72646 + = Tuple2-71613 + PredKey-71635 + (List-71608 integer) in - \(g-72626 : - all b-72627. - (a-72625 -> - b-72627 -> - b-72627) -> - b-72627 -> - b-72627) -> - g-72626 - {List-71588 - a-72625} - (\(ds-72628 : - a-72625) - (ds-72629 : - List-71588 - a-72625) -> - Cons-71590 - {a-72625} - ds-72628 - ds-72629) - (Nil-71589 - {a-72625})) - (/\a-72630 -> - \(c-72631 : - Tuple2-71593 - PredKey-71612 - (List-71588 + \(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 integer) -> - a-72630 -> - a-72630) - (n-72632 : - a-72630) -> - c-72631 - (Tuple2-71594 - {PredKey-71612} - {List-71588 + a-72651 -> + a-72651) + (n-72653 : + a-72651) -> + c-72652 + (Tuple2-71614 + {PredKey-71635} + {List-71608 integer} - MinValue-71614 + MinValue-71637 ((let - a-72633 - = List-71588 + a-72654 + = List-71608 integer in - \(c-72634 : + \(c-72655 : integer -> - a-72633 -> - a-72633) - (n-72635 : - a-72633) -> - c-72634 + a-72654 -> + a-72654) + (n-72656 : + a-72654) -> + c-72655 0 - (c-72634 + (c-72655 1000000 - n-72635)) - (\(ds-72636 : + n-72656)) + (\(ds-72657 : integer) - (ds-72637 : - List-71588 + (ds-72658 : + List-71608 integer) -> - Cons-71590 + Cons-71610 {integer} - ds-72636 - ds-72637) - (Nil-71589 + ds-72657 + ds-72658) + (Nil-71609 {integer}))) - (c-72631 - (Tuple2-71594 - {PredKey-71612} - {List-71588 + (c-72652 + (Tuple2-71614 + {PredKey-71635} + {List-71608 integer} - MaxValue-71613 + MaxValue-71636 ((let - a-72638 - = List-71588 + a-72659 + = List-71608 integer in - \(c-72639 : + \(c-72660 : integer -> - a-72638 -> - a-72638) - (n-72640 : - a-72638) -> - c-72639 + a-72659 -> + a-72659) + (n-72661 : + a-72659) -> + c-72660 10000000000000 - n-72640) - (\(ds-72641 : + n-72661) + (\(ds-72662 : integer) - (ds-72642 : - List-71588 + (ds-72663 : + List-71608 integer) -> - Cons-71590 + Cons-71610 {integer} - ds-72641 - ds-72642) - (Nil-71589 + ds-72662 + ds-72663) + (Nil-71609 {integer}))) - n-72632))))) - (c-71850 - (Tuple2-71594 + n-72653))))) + (c-71871 + (Tuple2-71614 {integer} - {ParamValue-71630} + {ParamValue-71653} 31 - (ParamInteger-71632 + (ParamInteger-71655 ((let - a-72643 - = Tuple2-71593 - PredKey-71612 - (List-71588 + a-72664 + = Tuple2-71613 + PredKey-71635 + (List-71608 integer) in - \(g-72644 : - all b-72645. - (a-72643 -> - b-72645 -> - b-72645) -> - b-72645 -> - b-72645) -> - g-72644 - {List-71588 - a-72643} - (\(ds-72646 : - a-72643) - (ds-72647 : - List-71588 - a-72643) -> - Cons-71590 - {a-72643} - ds-72646 - ds-72647) - (Nil-71589 - {a-72643})) - (/\a-72648 -> - \(c-72649 : - Tuple2-71593 - PredKey-71612 - (List-71588 + \(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 integer) -> - a-72648 -> - a-72648) - (n-72650 : - a-72648) -> - c-72649 - (Tuple2-71594 - {PredKey-71612} - {List-71588 + a-72669 -> + a-72669) + (n-72671 : + a-72669) -> + c-72670 + (Tuple2-71614 + {PredKey-71635} + {List-71608 integer} - MinValue-71614 + MinValue-71637 ((let - a-72651 - = List-71588 + a-72672 + = List-71608 integer in - \(c-72652 : + \(c-72673 : integer -> - a-72651 -> - a-72651) - (n-72653 : - a-72651) -> - c-72652 + a-72672 -> + a-72672) + (n-72674 : + a-72672) -> + c-72673 0 - (c-72652 + (c-72673 1000000 - n-72653)) - (\(ds-72654 : + n-72674)) + (\(ds-72675 : integer) - (ds-72655 : - List-71588 + (ds-72676 : + List-71608 integer) -> - Cons-71590 + Cons-71610 {integer} - ds-72654 - ds-72655) - (Nil-71589 + ds-72675 + ds-72676) + (Nil-71609 {integer}))) - (c-72649 - (Tuple2-71594 - {PredKey-71612} - {List-71588 + (c-72670 + (Tuple2-71614 + {PredKey-71635} + {List-71608 integer} - MaxValue-71613 + MaxValue-71636 ((let - a-72656 - = List-71588 + a-72677 + = List-71608 integer in - \(c-72657 : + \(c-72678 : integer -> - a-72656 -> - a-72656) - (n-72658 : - a-72656) -> - c-72657 + a-72677 -> + a-72677) + (n-72679 : + a-72677) -> + c-72678 100000000000 - n-72658) - (\(ds-72659 : + n-72679) + (\(ds-72680 : integer) - (ds-72660 : - List-71588 + (ds-72681 : + List-71608 integer) -> - Cons-71590 + Cons-71610 {integer} - ds-72659 - ds-72660) - (Nil-71589 + ds-72680 + ds-72681) + (Nil-71609 {integer}))) - n-72650))))) - (c-71850 - (Tuple2-71594 + n-72671))))) + (c-71871 + (Tuple2-71614 {integer} - {ParamValue-71630} + {ParamValue-71653} 32 - (ParamInteger-71632 + (ParamInteger-71655 ((let - a-72661 - = Tuple2-71593 - PredKey-71612 - (List-71588 + a-72682 + = Tuple2-71613 + PredKey-71635 + (List-71608 integer) in - \(g-72662 : - all b-72663. - (a-72661 -> - b-72663 -> - b-72663) -> - b-72663 -> - b-72663) -> - g-72662 - {List-71588 - a-72661} - (\(ds-72664 : - a-72661) - (ds-72665 : - List-71588 - a-72661) -> - Cons-71590 - {a-72661} - ds-72664 - ds-72665) - (Nil-71589 - {a-72661})) - (/\a-72666 -> - \(c-72667 : - Tuple2-71593 - PredKey-71612 - (List-71588 + \(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 integer) -> - a-72666 -> - a-72666) - (n-72668 : - a-72666) -> - c-72667 - (Tuple2-71594 - {PredKey-71612} - {List-71588 + a-72687 -> + a-72687) + (n-72689 : + a-72687) -> + c-72688 + (Tuple2-71614 + {PredKey-71635} + {List-71608 integer} - MinValue-71614 + MinValue-71637 ((let - a-72669 - = List-71588 + a-72690 + = List-71608 integer in - \(c-72670 : + \(c-72691 : integer -> - a-72669 -> - a-72669) - (n-72671 : - a-72669) -> - c-72670 + a-72690 -> + a-72690) + (n-72692 : + a-72690) -> + c-72691 13 - (c-72670 + (c-72691 0 - n-72671)) - (\(ds-72672 : + n-72692)) + (\(ds-72693 : integer) - (ds-72673 : - List-71588 + (ds-72694 : + List-71608 integer) -> - Cons-71590 + Cons-71610 {integer} - ds-72672 - ds-72673) - (Nil-71589 + ds-72693 + ds-72694) + (Nil-71609 {integer}))) - (c-72667 - (Tuple2-71594 - {PredKey-71612} - {List-71588 + (c-72688 + (Tuple2-71614 + {PredKey-71635} + {List-71608 integer} - MaxValue-71613 + MaxValue-71636 ((let - a-72674 - = List-71588 + a-72695 + = List-71608 integer in - \(c-72675 : + \(c-72696 : integer -> - a-72674 -> - a-72674) - (n-72676 : - a-72674) -> - c-72675 + a-72695 -> + a-72695) + (n-72697 : + a-72695) -> + c-72696 37 - n-72676) - (\(ds-72677 : + n-72697) + (\(ds-72698 : integer) - (ds-72678 : - List-71588 + (ds-72699 : + List-71608 integer) -> - Cons-71590 + Cons-71610 {integer} - ds-72677 - ds-72678) - (Nil-71589 + ds-72698 + ds-72699) + (Nil-71609 {integer}))) - n-72668))))) - (c-71850 - (Tuple2-71594 + n-72689))))) + (c-71871 + (Tuple2-71614 {integer} - {ParamValue-71630} + {ParamValue-71653} 33 - (ParamInteger-71632 + (ParamRational-71657 ((let - a-72679 - = Tuple2-71593 - PredKey-71612 - (List-71588 - integer) + a-72700 + = Tuple2-71613 + PredKey-71635 + (List-71608 + Rational-71650) in - \(g-72680 : - all b-72681. - (a-72679 -> - b-72681 -> - b-72681) -> - b-72681 -> - b-72681) -> - g-72680 - {List-71588 - a-72679} - (\(ds-72682 : - a-72679) - (ds-72683 : - List-71588 - a-72679) -> - Cons-71590 - {a-72679} - ds-72682 - ds-72683) - (Nil-71589 - {a-72679})) - (/\a-72684 -> - \(c-72685 : - Tuple2-71593 - PredKey-71612 - (List-71588 - integer) -> - a-72684 -> - a-72684) - (n-72686 : - a-72684) -> - c-72685 - (Tuple2-71594 - {PredKey-71612} - {List-71588 - integer} - MinValue-71614 + \(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 ((let - a-72687 - = List-71588 - integer + a-72708 + = List-71608 + Rational-71650 in - \(c-72688 : - integer -> - a-72687 -> - a-72687) - (n-72689 : - a-72687) -> - c-72688 - 0 - n-72689) - (\(ds-72690 : - integer) - (ds-72691 : - List-71588 - integer) -> - Cons-71590 - {integer} - ds-72690 - ds-72691) - (Nil-71589 - {integer}))) - (c-72685 - (Tuple2-71594 - {PredKey-71612} - {List-71588 - integer} - MaxValue-71613 + \(c-72709 : + Rational-71650 -> + a-72708 -> + a-72708) + (n-72710 : + a-72708) -> + c-72709 + (unsafeRatio-71668 + 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 ((let - a-72692 - = List-71588 - integer + a-72713 + = List-71608 + Rational-71650 in - \(c-72693 : - integer -> - a-72692 -> - a-72692) - (n-72694 : - a-72692) -> - c-72693 - 1000 - n-72694) - (\(ds-72695 : - integer) - (ds-72696 : - List-71588 - integer) -> - Cons-71590 - {integer} - ds-72695 - ds-72696) - (Nil-71589 - {integer}))) - n-72686))))) - n-71851)))))))))))))))))))))))))))))) - !fun-72731 : List-71588 (Tuple2-71593 data data) -> Bool-71608 + \(c-72714 : + Rational-71650 -> + a-72713 -> + a-72713) + (n-72715 : + a-72713) -> + c-72714 + (unsafeRatio-71668 + 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 = (let - a-72698 = Tuple2-71593 data data + a-72719 = Tuple2-71613 data data in - \(f-72699 : a-72698 -> Bool-71608) -> + \(f-72720 : a-72719 -> Bool-71628) -> letrec - !go-72701 : List-71588 a-72698 -> Bool-71608 - = \(ds-72702 : List-71588 a-72698) -> - List_match-71591 - {a-72698} - ds-72702 - {all dead-72703. Bool-71608} - (/\dead-72704 -> True-71609) - (\(x-72705 : a-72698) (xs-72706 : List-71588 a-72698) -> - /\dead-72707 -> - Bool_match-71611 - (f-72699 x-72705) - {all dead-72708. Bool-71608} - (/\dead-72709 -> go-72701 xs-72706) - (/\dead-72710 -> False-71610) - {all dead-72711. dead-72711}) - {all dead-72712. dead-72712} + !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} in - \(eta-72700 : List-71588 a-72698) -> go-72701 eta-72700) - (\(ds-72713 : Tuple2-71593 data data) -> - Tuple2_match-71595 + \(eta-72721 : List-71608 a-72719) -> go-72722 eta-72721) + (\(ds-72734 : Tuple2-71613 data data) -> + Tuple2_match-71615 {data} {data} - ds-72713 - {Bool-71608} - (\(ds-72714 : data) (actualValueData-72715 : data) -> - validateParamValue-71678 - (let - !k-72716 : integer = unIData ds-72714 - in - letrec - !go-72717 : - List-71588 (Tuple2-71593 integer ParamValue-71630) -> - ParamValue-71630 - = \(ds-72718 : - List-71588 - (Tuple2-71593 integer ParamValue-71630)) -> - List_match-71591 - {Tuple2-71593 integer ParamValue-71630} - ds-72718 - {all dead-72719. ParamValue-71630} - (/\dead-72720 -> error {ParamValue-71630}) - (\(ds-72721 : - Tuple2-71593 integer ParamValue-71630) - (xs'-72722 : - List-71588 - (Tuple2-71593 integer ParamValue-71630)) -> - /\dead-72723 -> - Tuple2_match-71595 - {integer} - {ParamValue-71630} - ds-72721 - {ParamValue-71630} - (\(k'-72724 : integer) - (i-72725 : ParamValue-71630) -> - Bool_match-71611 - (ifThenElse - {Bool-71608} - (equalsInteger k-72716 k'-72724) - True-71609 - False-71610) - {all dead-72726. ParamValue-71630} - (/\dead-72727 -> i-72725) - (/\dead-72728 -> go-72717 xs'-72722) - {all dead-72729. dead-72729})) - {all dead-72730. dead-72730} - in - go-72717 cfg-72697) - actualValueData-72715)) + ds-72734 + {Bool-71628} + (\(ds-72735 : data) (actualValueData-72736 : data) -> + validateParamValue-71701 + ((let + !k-72737 : integer = unIData ds-72735 + 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 + {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} + in + go-72738) + cfg-72718) + actualValueData-72736)) in - \(ds-72732 : data) -> - Maybe_match-71606 - {List-71588 (Tuple2-71593 data data)} + \(ds-72753 : data) -> + Maybe_match-71626 + {List-71608 (Tuple2-71613 data data)} (let - !ds-72739 : data + !ds-72760 : data = headList {data} (tailList @@ -5672,7 +5681,7 @@ program {list data} (unConstrData (let - !ds-72733 : data + !ds-72754 : data = headList {data} (tailList @@ -5682,69 +5691,69 @@ program (sndPair {integer} {list data} - (unConstrData ds-72732)))) - ~si-72734 : pair integer (list data) - = unConstrData ds-72733 + (unConstrData ds-72753)))) + ~si-72755 : pair integer (list data) + = unConstrData ds-72754 in - Bool_match-71611 + Bool_match-71631 (ifThenElse - {Bool-71608} + {Bool-71628} (equalsInteger 5 - (fstPair {integer} {list data} si-72734)) - True-71609 - False-71610) - {all dead-72735. data} - (/\dead-72736 -> + (fstPair {integer} {list data} si-72755)) + True-71629 + False-71630) + {all dead-72756. data} + (/\dead-72757 -> headList {data} (tailList {data} - (sndPair {integer} {list data} si-72734))) - (/\dead-72737 -> error {data}) - {all dead-72738. dead-72738}))))) - ~ds-72740 : pair integer (list data) = unConstrData ds-72739 - !x-72741 : integer = fstPair {integer} {list data} ds-72740 + (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 in - Bool_match-71611 + Bool_match-71631 (ifThenElse - {Bool-71608} - (equalsInteger 0 x-72741) - True-71609 - False-71610) - {all dead-72742. Maybe-71603 (List-71588 (Tuple2-71593 data data))} - (/\dead-72743 -> - Just-71604 - {List-71588 (Tuple2-71593 data data)} - (go-71598 + {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 (unMapData (headList {data} (tailList {data} - (sndPair {integer} {list data} ds-72740)))))) - (/\dead-72744 -> - Bool_match-71611 + (sndPair {integer} {list data} ds-72761)))))) + (/\dead-72765 -> + Bool_match-71631 (ifThenElse - {Bool-71608} - (equalsInteger 2 x-72741) - True-71609 - False-71610) - {all dead-72745. Maybe-71603 (List-71588 (Tuple2-71593 data data))} - (/\dead-72746 -> - Nothing-71605 {List-71588 (Tuple2-71593 data data)}) - (/\dead-72747 -> - error {Maybe-71603 (List-71588 (Tuple2-71593 data data))}) - {all dead-72748. dead-72748}) - {all dead-72749. dead-72749}) - {all dead-72750. unit} - (\(cparams-72751 : List-71588 (Tuple2-71593 data data)) -> - /\dead-72752 -> - Bool_match-71611 - (fun-72731 cparams-72751) - {all dead-72753. unit} - (/\dead-72754 -> ()) - (/\dead-72755 -> error {unit}) - {all dead-72756. dead-72756}) - (/\dead-72757 -> ()) - {all dead-72758. dead-72758}) + {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 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 e1031553ca9..52c0142b091 100644 --- a/cardano-constitution/test/Cardano/Constitution/Validator/GoldenTests/unsorted.uplc.golden +++ b/cardano-constitution/test/Cardano/Constitution/Validator/GoldenTests/unsorted.uplc.golden @@ -3,14 +3,14 @@ program ((\fix1!0 -> (\`$fOrdRational0_$c<=`!0 -> (\`$fOrdInteger_$ccompare`!0 -> - (\validatePreds!0 -> - (\euclid!0 -> - (\unsafeRatio!0 -> - (\cse!0 -> - (\validateParamValue!0 -> - (\validateParamValues!0 -> - (\go!0 -> - (\cse!0 -> + (\equalsInteger!0 -> + (\validatePreds!0 -> + (\euclid!0 -> + (\unsafeRatio!0 -> + (\cse!0 -> + (\validateParamValue!0 -> + (\validateParamValues!0 -> + (\go!0 -> (\cse!0 -> (\cse!0 -> (\cse!0 -> @@ -59,7 +59,7 @@ program (delay (delay (constr 0 - [ (go!38 + [ (go!37 (unMapData (force headList @@ -170,7 +170,7 @@ program x!2 [ (\ds!0 actualValueData!0 -> - validateParamValue!42 + validateParamValue!41 ((\k!0 -> fix1!50 (\go!0 @@ -188,22 +188,18 @@ program [ (\k'!0 i!0 -> force - (force - (force - ifThenElse - (equalsInteger - k!7 - k'!2) - (delay - (delay - i!1)) - (delay - (delay - (go!6 - xs'!3)))))) ])) ])) - cfg!8) + (case + (equalsInteger!53 + k!7 + k'!2) + [ (delay + i!1) + , (delay + (go!6 + xs'!3)) ])) ])) ]))) (unIData - ds!2)) + ds!2) + cfg!7) actualValueData!1) ]) [ (delay (go!4 @@ -221,8 +217,17 @@ program [ ]) , (constr 1 [ 30 - , cse!31 ]) ]) - , cse!13 ]) ]) ]) + , cse!29 ]) ]) + , (constr 1 + [ (constr 0 + [ (constr 0 + [ ]) + , (constr 1 + [ 1000 + , (constr 0 + [ ]) ]) ]) + , (constr 0 + [ ]) ]) ]) ]) ]) , (constr 1 [ (constr 0 [ 1 @@ -233,7 +238,7 @@ program [ ]) , (constr 1 [ 100000 - , cse!31 ]) ]) + , cse!29 ]) ]) , (constr 1 [ (constr 0 [ (constr 0 @@ -271,7 +276,7 @@ program [ 3 , (constr 1 [ (constr 1 - [ cse!19 + [ cse!16 , (constr 1 [ (constr 0 [ (constr 0 @@ -287,7 +292,7 @@ program [ 4 , (constr 1 [ (constr 1 - [ cse!19 + [ cse!16 , (constr 1 [ (constr 0 [ (constr 0 @@ -308,7 +313,7 @@ program [ ]) , (constr 1 [ 1000000 - , cse!31 ]) ]) + , cse!29 ]) ]) , (constr 1 [ (constr 0 [ (constr 0 @@ -329,14 +334,14 @@ program [ ]) , (constr 1 [ 250000000 - , cse!31 ]) ]) + , cse!29 ]) ]) , cse!11 ]) ]) ]) , (constr 1 [ (constr 0 [ 7 , (constr 1 [ (constr 1 - [ cse!19 + [ cse!16 , (constr 0 [ ]) ]) ]) ]) , (constr 1 @@ -349,7 +354,7 @@ program [ ]) , (constr 1 [ 250 - , cse!31 ]) ]) + , cse!29 ]) ]) , (constr 1 [ (constr 0 [ (constr 0 @@ -364,7 +369,7 @@ program [ 9 , (constr 3 [ (constr 1 - [ cse!7 + [ cse!6 , cse!8 ]) ]) ]) , (constr 1 [ (constr 0 @@ -375,15 +380,15 @@ program [ (constr 1 [ ]) , (constr 1 - [ (cse!28 + [ (cse!31 1000) - , cse!12 ]) ]) + , cse!14 ]) ]) , (constr 1 [ (constr 0 [ (constr 0 [ ]) , (constr 1 - [ (cse!28 + [ (cse!31 200) , (constr 0 [ ]) ]) ]) @@ -394,15 +399,15 @@ program [ 11 , (constr 3 [ (constr 1 - [ cse!7 + [ cse!6 , (constr 1 [ (constr 0 [ (constr 0 [ ]) , (constr 1 - [ (cse!27 + [ (cse!26 10) - , cse!14 ]) ]) + , cse!13 ]) ]) , (constr 0 [ ]) ]) ]) ]) ]) , (constr 1 @@ -410,7 +415,7 @@ program [ 16 , (constr 1 [ (constr 1 - [ cse!19 + [ cse!16 , cse!11 ]) ]) ]) , (constr 1 [ (constr 0 @@ -422,7 +427,7 @@ program [ ]) , (constr 1 [ 3000 - , cse!31 ]) ]) + , cse!29 ]) ]) , (constr 1 [ (constr 0 [ (constr 0 @@ -448,7 +453,7 @@ program [ (constr 1 [ ]) , (constr 1 - [ (cse!28 + [ (cse!31 25) , (constr 0 [ ]) ]) ]) @@ -457,7 +462,7 @@ program [ (constr 0 [ ]) , (constr 1 - [ (cse!28 + [ (cse!31 5) , (constr 0 [ ]) ]) ]) @@ -470,7 +475,7 @@ program [ (constr 1 [ ]) , (constr 1 - [ (cse!28 + [ (cse!31 20000) , (constr 0 [ ]) ]) ]) @@ -479,7 +484,7 @@ program [ (constr 0 [ ]) , (constr 1 - [ (cse!28 + [ (cse!31 5000) , (constr 0 [ ]) ]) ]) @@ -494,7 +499,7 @@ program [ (constr 1 [ (constr 1 [ (constr 1 - [ cse!19 + [ cse!16 , (constr 1 [ (constr 0 [ (constr 0 @@ -508,7 +513,7 @@ program , (constr 1 [ (constr 1 [ (constr 1 - [ cse!19 + [ cse!16 , (constr 1 [ (constr 0 [ (constr 0 @@ -528,7 +533,7 @@ program [ (constr 1 [ (constr 1 [ (constr 1 - [ cse!19 + [ cse!16 , (constr 1 [ (constr 0 [ (constr 0 @@ -542,7 +547,7 @@ program , (constr 1 [ (constr 1 [ (constr 1 - [ cse!19 + [ cse!16 , (constr 1 [ (constr 0 [ (constr 0 @@ -560,7 +565,7 @@ program [ 22 , (constr 1 [ (constr 1 - [ cse!19 + [ cse!16 , (constr 1 [ (constr 0 [ (constr 0 @@ -581,7 +586,7 @@ program [ ]) , (constr 1 [ 100 - , cse!31 ]) ]) + , cse!29 ]) ]) , (constr 1 [ (constr 0 [ (constr 0 @@ -596,7 +601,7 @@ program [ 24 , (constr 1 [ (constr 1 - [ cse!22 + [ cse!20 , (constr 0 [ ]) ]) ]) ]) , (constr 1 @@ -604,34 +609,34 @@ program [ 25 , (constr 2 [ (constr 1 - [ cse!1 + [ cse!2 , (constr 1 - [ cse!3 + [ cse!1 , (constr 1 - [ cse!3 + [ cse!1 , (constr 1 - [ cse!2 + [ cse!3 , cse!4 ]) ]) ]) ]) ]) ]) , (constr 1 [ (constr 0 [ 26 , (constr 2 [ (constr 1 - [ cse!1 + [ cse!2 , (constr 1 - [ cse!3 + [ cse!1 , (constr 1 - [ cse!3 + [ cse!1 , (constr 1 - [ cse!3 + [ cse!1 , (constr 1 - [ cse!2 + [ cse!3 , (constr 1 - [ cse!1 + [ cse!2 , (constr 1 - [ cse!1 + [ cse!2 , (constr 1 - [ cse!1 + [ cse!2 , (constr 1 [ (constr 3 [ (constr 1 @@ -640,7 +645,7 @@ program [ ]) , (constr 1 [ cse!18 - , cse!15 ]) ]) + , cse!12 ]) ]) , cse!5 ]) ]) , cse!4 ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) , (constr 1 @@ -695,7 +700,7 @@ program [ 29 , (constr 1 [ (constr 1 - [ cse!22 + [ cse!20 , (constr 1 [ (constr 0 [ (constr 0 @@ -748,7 +753,7 @@ program [ ]) , (constr 1 [ 13 - , cse!31 ]) ]) + , cse!29 ]) ]) , (constr 1 [ (constr 0 [ (constr 0 @@ -762,51 +767,65 @@ program , (constr 1 [ (constr 0 [ 33 - , (constr 1 + , (constr 3 [ (constr 1 - [ cse!19 - , cse!13 ]) ]) ]) + [ (constr 0 + [ (constr 1 + [ ]) + , cse!14 ]) + , (constr 1 + [ (constr 0 + [ (constr 0 + [ ]) + , (constr 1 + [ (unsafeRatio!36 + 1000 + 1) + , (constr 0 + [ ]) ]) ]) + , (constr 0 + [ ]) ]) ]) ]) ]) , (constr 0 [ ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ]) ])) (constr 3 [ (constr 1 - [ cse!5 - , (constr 1 - [ (constr 0 - [ (constr 0 - [ ]) + [ (constr 0 + [ (constr 1 + [ ]) + , (constr 1 + [ cse!17 , (constr 1 - [ cse!15 - , cse!14 ]) ]) - , (constr 0 - [ ]) ]) ]) ])) + [ cse!18 + , (constr 0 + [ ]) ]) ]) ]) + , cse!4 ]) ])) (constr 3 [ (constr 1 - [ cse!4 + [ cse!5 , (constr 1 [ (constr 0 [ (constr 0 [ ]) , (constr 1 - [ cse!14 - , (constr 1 - [ cse!21 - , (constr 0 - [ ]) ]) ]) ]) + [ cse!13 + , cse!10 ]) ]) , (constr 0 [ ]) ]) ]) ])) (constr 3 [ (constr 1 - [ (constr 0 - [ (constr 1 - [ ]) - , (constr 1 - [ cse!15 + [ cse!4 + , (constr 1 + [ (constr 0 + [ (constr 0 + [ ]) , (constr 1 - [ cse!21 - , (constr 0 - [ ]) ]) ]) ]) - , cse!2 ]) ])) + [ cse!12 + , (constr 1 + [ cse!19 + , (constr 0 + [ ]) ]) ]) ]) + , (constr 0 + [ ]) ]) ]) ])) (constr 1 [ (constr 3 [ (constr 1 @@ -825,9 +844,10 @@ program [ (constr 0 [ ]) , (constr 1 - [ cse!11 + [ cse!10 , (constr 1 - [ cse!12 + [ (cse!19 + 10) , (constr 0 [ ]) ]) ]) ]) , (constr 0 @@ -836,22 +856,23 @@ program [ (constr 1 [ ]) , (constr 1 - [ cse!12 - , (constr 1 - [ cse!14 - , (constr 0 - [ ]) ]) ]) ])) + [ (cse!25 + 10) + , cse!8 ]) ])) (constr 0 [ (constr 1 [ ]) , (constr 1 - [ cse!14 - , cse!5 ]) ])) + [ cse!11 + , (constr 1 + [ cse!10 + , (constr 0 + [ ]) ]) ]) ])) (constr 1 [ (constr 0 [ (constr 0 [ ]) - , cse!6 ]) + , cse!5 ]) , (constr 0 [ ]) ])) (constr 0 @@ -867,7 +888,7 @@ program [ (constr 0 [ (constr 2 [ ]) - , cse!21 ]) + , cse!19 ]) , (constr 0 [ ]) ])) (constr 1 @@ -881,490 +902,496 @@ program , (constr 0 [ ]) ])) (constr 1 - [ cse!13 + [ cse!9 , (constr 0 [ ]) ])) (constr 1 - [ (constr 0 - [ (constr 0 - [ ]) - , (constr 1 - [ 1000 - , (constr 0 - [ ]) ]) ]) + [ cse!2 , (constr 0 [ ]) ])) (constr 1 - [ cse!2 + [ cse!9 , (constr 0 [ ]) ])) - (constr 1 - [ (cse!12 - 4) - , (constr 0 - [ ]) ])) - (cse!12 - 1)) - (cse!9 - 10)) - (cse!10 + (cse!16 + 1)) + (constr 0 + [ (constr 1 + [ ]) + , cse!13 ])) + (cse!13 + 100)) + (cse!13 2)) - (constr 0 - [ (constr 1 - [ ]) - , cse!12 ])) - (cse!12 - 100)) - (cse!7 10)) - (constr 0 - [ (constr 1 - []) - , (constr 1 - [ 1 - , (constr 0 - [ ]) ]) ])) - (cse!6 5)) - (cse!6 20)) - (unsafeRatio!12 0 1)) - (unsafeRatio!11 9)) - (unsafeRatio!10 3)) - (unsafeRatio!9 1)) - (unsafeRatio!8 4)) - (unsafeRatio!7 13)) - (constr 1 [0, (constr 0 [])])) - (unsafeRatio!5 51)) - (fix1!9 - (\go!0 l!0 -> - force (force chooseList) - l!1 - (\ds!0 -> constr 0 []) - (\ds!0 -> - constr 1 - [ ((\p!0 -> - constr 0 - [ (force (force fstPair) - p!1) - , (force (force sndPair) - p!1) ]) - (force headList l!2)) - , (go!3 (force tailList l!2)) ]) - ()))) - (cse!2 (\arg_0!0 arg_1!0 -> arg_1!1))) - (cse!1 (\arg_0!0 arg_1!0 -> arg_0!2))) - (force - ((\s!0 -> s!1 s!1) - (\s!0 h!0 -> - 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)))) - (delay - (\choose!0 - validateParamValue!0 - validateParamValues!0 -> - choose!3 - (\eta!0 eta!0 -> - force - (case - eta!2 - [ (delay (constr 0 [])) - , (\preds!0 -> - delay - (validatePreds!9 - (constr 0 - [ (\x!0 y!0 -> - force ifThenElse - (equalsInteger - x!2 - y!1) - (constr 0 []) - (constr 1 [])) - , `$fOrdInteger_$ccompare`!10 - , (\x!0 y!0 -> - force ifThenElse - (lessThanInteger - x!2 - y!1) - (constr 0 []) - (constr 1 [])) - , (\x!0 y!0 -> - force ifThenElse - (lessThanEqualsInteger - x!2 - y!1) - (constr 0 []) - (constr 1 [])) - , (\x!0 y!0 -> - force ifThenElse - (lessThanEqualsInteger - x!2 - y!1) - (constr 1 []) - (constr 0 [])) - , (\x!0 y!0 -> - force ifThenElse - (lessThanInteger - x!2 - y!1) - (constr 1 []) - (constr 0 [])) - , (\x!0 y!0 -> - force - (force + (cse!9 + 20)) + (constr 0 + [ (constr 1 + [ ]) + , (constr 1 + [ 1 + , (constr 0 + [ ]) ]) ])) + (cse!5 4)) + (cse!5 5)) + (cse!2 1)) + (unsafeRatio!12 9)) + (unsafeRatio!11 0)) + (unsafeRatio!10 3)) + (unsafeRatio!9 4)) + (unsafeRatio!8 13)) + (constr 1 [0, (constr 0 [])])) + (unsafeRatio!6 51)) + (unsafeRatio!5 1)) + (fix1!10 + (\go!0 l!0 -> + force (force chooseList) + l!1 + (\ds!0 -> constr 0 []) + (\ds!0 -> + constr 1 + [ ((\p!0 -> + constr 0 + [ (force (force fstPair) + p!1) + , (force (force sndPair) + p!1) ]) + (force headList l!2)) + , (go!3 (force tailList l!2)) ]) + ()))) + (cse!2 (\arg_0!0 arg_1!0 -> arg_1!1))) + (cse!1 (\arg_0!0 arg_1!0 -> arg_0!2))) + (force + ((\s!0 -> s!1 s!1) + (\s!0 h!0 -> + 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)))) + (delay + (\choose!0 + validateParamValue!0 + validateParamValues!0 -> + choose!3 + (\eta!0 eta!0 -> + force + (case + eta!2 + [ (delay (constr 0 [])) + , (\preds!0 -> + delay + (validatePreds!9 + (constr 0 + [ equalsInteger!10 + , `$fOrdInteger_$ccompare`!11 + , (\x!0 y!0 -> + force + ifThenElse + (lessThanInteger + x!2 + y!1) + (constr 0 + []) + (constr 1 + [])) + , (\x!0 y!0 -> + force + ifThenElse + (lessThanEqualsInteger + x!2 + y!1) + (constr 0 + []) + (constr 1 + [])) + , (\x!0 y!0 -> + force + ifThenElse + (lessThanEqualsInteger + x!2 + y!1) + (constr 1 + []) + (constr 0 + [])) + , (\x!0 y!0 -> + force + ifThenElse + (lessThanInteger + x!2 + y!1) + (constr 1 + []) + (constr 0 + [])) + , (\x!0 y!0 -> + force (force - ifThenElse - (lessThanEqualsInteger - x!2 - y!1) - (delay + (force + ifThenElse + (lessThanEqualsInteger + x!2 + y!1) (delay - y!1)) - (delay + (delay + y!1)) (delay - x!2))))) - , (\x!0 y!0 -> - force - (force + (delay + x!2))))) + , (\x!0 y!0 -> + force (force - ifThenElse - (lessThanEqualsInteger - x!2 - y!1) - (delay + (force + ifThenElse + (lessThanEqualsInteger + x!2 + y!1) (delay - x!2)) - (delay + (delay + x!2)) (delay - y!1))))) ]) - preds!1 - (unIData eta!2))) - , (\paramValues!0 -> - delay - (validateParamValues!4 - paramValues!1 - (unListData eta!2))) - , (\preds!0 -> - delay - ((\cse!0 -> - validatePreds!10 - (constr 0 - [ (\ds!0 ds!0 -> - case - ds!2 - [ (\n!0 - d!0 -> - case - ds!3 - [ (\n'!0 - d'!0 -> - force - (force + (delay + y!1))))) ]) + preds!1 + (unIData eta!2))) + , (\paramValues!0 -> + delay + (validateParamValues!4 + paramValues!1 + (unListData eta!2))) + , (\preds!0 -> + delay + ((\cse!0 -> + validatePreds!10 + (constr 0 + [ (\ds!0 ds!0 -> + case + ds!2 + [ (\n!0 + d!0 -> + case + ds!3 + [ (\n'!0 + d'!0 -> + force (force - ifThenElse - (equalsInteger - n!4 - n'!2) - (delay + (force + ifThenElse + (equalsInteger + n!4 + n'!2) (delay - (force - ifThenElse - (equalsInteger - d!3 - d'!1) - (constr 0 - [ ]) - (constr 1 - [ ])))) - (delay + (delay + (force + ifThenElse + (equalsInteger + d!3 + d'!1) + (constr 0 + [ ]) + (constr 1 + [ ])))) (delay - (constr 1 - [ ])))))) ]) ]) - , (\ds!0 ds!0 -> - case - ds!2 - [ (\n!0 - d!0 -> - case - ds!3 - [ (\n'!0 - d'!0 -> - `$fOrdInteger_$ccompare`!17 - (multiplyInteger - n!4 - d'!1) - (multiplyInteger - n'!2 - d!3)) ]) ]) - , (\ds!0 ds!0 -> - case - ds!2 - [ (\n!0 - d!0 -> - case - ds!3 - [ (\n'!0 - d'!0 -> - force - ifThenElse - (lessThanInteger - (multiplyInteger - n!4 - d'!1) - (multiplyInteger - n'!2 - d!3)) - (constr 0 - [ ]) - (constr 1 - [ ])) ]) ]) - , `$fOrdRational0_$c<=`!12 - , (\ds!0 ds!0 -> - case - ds!2 - [ (\n!0 - d!0 -> - case - ds!3 - [ (\n'!0 - d'!0 -> - force - ifThenElse - (lessThanEqualsInteger - (multiplyInteger - n!4 - d'!1) - (multiplyInteger - n'!2 - d!3)) - (constr 1 - [ ]) - (constr 0 - [ ])) ]) ]) - , (\ds!0 ds!0 -> - case - ds!2 - [ (\n!0 - d!0 -> - case - ds!3 - [ (\n'!0 - d'!0 -> - force - ifThenElse - (lessThanInteger + (delay + (constr 1 + [ ])))))) ]) ]) + , (\ds!0 ds!0 -> + case + ds!2 + [ (\n!0 + d!0 -> + case + ds!3 + [ (\n'!0 + d'!0 -> + `$fOrdInteger_$ccompare`!18 (multiplyInteger n!4 d'!1) (multiplyInteger n'!2 - d!3)) - (constr 1 - [ ]) - (constr 0 - [ ])) ]) ]) - , (\x!0 y!0 -> - force - (case - (`$fOrdRational0_$c<=`!14 - x!2 - y!1) - [ (delay - y!1) - , (delay - x!2) ])) - , (\x!0 y!0 -> - force - (case - (`$fOrdRational0_$c<=`!14 - x!2 - y!1) - [ (delay - x!2) - , (delay - y!1) ])) ]) - preds!2 - ((\cse!0 -> - force ifThenElse - (force nullList + d!3)) ]) ]) + , (\ds!0 ds!0 -> + case + ds!2 + [ (\n!0 + d!0 -> + case + ds!3 + [ (\n'!0 + d'!0 -> + force + ifThenElse + (lessThanInteger + (multiplyInteger + n!4 + d'!1) + (multiplyInteger + n'!2 + d!3)) + (constr 0 + [ ]) + (constr 1 + [ ])) ]) ]) + , `$fOrdRational0_$c<=`!13 + , (\ds!0 ds!0 -> + case + ds!2 + [ (\n!0 + d!0 -> + case + ds!3 + [ (\n'!0 + d'!0 -> + force + ifThenElse + (lessThanEqualsInteger + (multiplyInteger + n!4 + d'!1) + (multiplyInteger + n'!2 + d!3)) + (constr 1 + [ ]) + (constr 0 + [ ])) ]) ]) + , (\ds!0 ds!0 -> + case + ds!2 + [ (\n!0 + d!0 -> + case + ds!3 + [ (\n'!0 + d'!0 -> + force + ifThenElse + (lessThanInteger + (multiplyInteger + n!4 + d'!1) + (multiplyInteger + n'!2 + d!3)) + (constr 1 + [ ]) + (constr 0 + [ ])) ]) ]) + , (\x!0 y!0 -> + force + (case + (`$fOrdRational0_$c<=`!15 + x!2 + y!1) + [ (delay + y!1) + , (delay + x!2) ])) + , (\x!0 y!0 -> + force + (case + (`$fOrdRational0_$c<=`!15 + x!2 + y!1) + [ (delay + x!2) + , (delay + y!1) ])) ]) + preds!2 + ((\cse!0 -> + force + ifThenElse (force - tailList - cse!1)) - (\ds!0 -> - unsafeRatio!10 - (unIData - (force - headList - cse!3)) - (unIData - (force - headList - cse!2)))) - (force tailList - cse!1) - (\ds!0 -> error) - (constr 0 []))) - (unListData eta!2))) ])) - (\ds!0 -> - case - ds!1 - [ (\eta!0 -> - force ifThenElse - (force nullList eta!1) - (constr 0 []) - (constr 1 [])) - , (\paramValueHd!0 - paramValueTl!0 - actualValueData!0 -> - force - (case - (validateParamValue!6 - paramValueHd!3 - (force headList - actualValueData!1)) - [ (delay - (validateParamValues!5 - paramValueTl!2 - (force tailList - actualValueData!1))) - , (delay - (constr 1 - [])) ])) ])))))) + nullList + (force + tailList + cse!1)) + (\ds!0 -> + unsafeRatio!10 + (unIData + (force + headList + cse!3)) + (unIData + (force + headList + cse!2)))) + (force tailList + cse!1) + (\ds!0 -> error) + (constr 0 []))) + (unListData + eta!2))) ])) + (\ds!0 -> + case + ds!1 + [ (\eta!0 -> + force ifThenElse + (force nullList eta!1) + (constr 0 []) + (constr 1 [])) + , (\paramValueHd!0 + paramValueTl!0 + actualValueData!0 -> + force + (case + (validateParamValue!6 + paramValueHd!3 + (force headList + actualValueData!1)) + [ (delay + (validateParamValues!5 + paramValueTl!2 + (force tailList + actualValueData!1))) + , (delay + (constr 1 + [])) ])) ])))))) + (fix1!6 + (\unsafeRatio!0 n!0 d!0 -> + force + (force + (force ifThenElse + (equalsInteger 0 d!1) + (delay (delay error)) + (delay + (delay + (force + (force + (force ifThenElse + (lessThanInteger d!1 0) + (delay + (delay + (unsafeRatio!3 + (subtractInteger + 0 + n!2) + (subtractInteger + 0 + d!1)))) + (delay + (delay + ((\gcd'!0 -> + constr 0 + [ (quotientInteger + n!3 + gcd'!1) + , (quotientInteger + d!2 + gcd'!1) ]) + (euclid!4 + n!2 + d!1)))))))))))))) (fix1!5 - (\unsafeRatio!0 n!0 d!0 -> + (\euclid!0 x!0 y!0 -> force (force (force ifThenElse - (equalsInteger 0 d!1) - (delay (delay error)) + (equalsInteger 0 y!1) + (delay (delay x!2)) (delay (delay - (force - (force - (force ifThenElse - (lessThanInteger d!1 0) - (delay - (delay - (unsafeRatio!3 - (subtractInteger - 0 - n!2) - (subtractInteger - 0 - d!1)))) - (delay - (delay - ((\gcd'!0 -> - constr 0 - [ (quotientInteger - n!3 - gcd'!1) - , (quotientInteger - d!2 - gcd'!1) ]) - (euclid!4 - n!2 - d!1)))))))))))))) - (fix1!4 - (\euclid!0 x!0 y!0 -> - 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 -> - force - (case - ds!1 - [ (delay (constr 0 [])) - , (\x!0 xs!0 -> - delay - (case - x!2 - [ (\predKey!0 expectedPredValues!0 -> - (\meaning!0 -> - fix1!13 - (\go!0 ds!0 -> - force - (case - ds!1 - [ (delay (go!9 xs!6)) - , (\x!0 xs!0 -> - delay - (force - (case - (meaning!5 - x!2 - ds!12) - [ (delay - (go!4 - xs!1)) - , (delay - (constr 1 - [ ])) ]))) ])) - expectedPredValues!2) - (force - (case - predKey!2 - [ (delay + (euclid!3 + y!1 + (modInteger x!2 y!1))))))))) + (\`$dOrd`!0 ds!0 ds!0 -> + fix1!7 + (\go!0 ds!0 -> + force + (case + ds!1 + [ (delay (constr 0 [])) + , (\x!0 xs!0 -> + delay + (case + x!2 + [ (\predKey!0 expectedPredValues!0 -> + (\meaning!0 -> + fix1!14 + (\go!0 ds!0 -> + force (case - `$dOrd`!9 - [ (\v!0 - v!0 - v!0 - v!0 - v!0 - v!0 - v!0 - v!0 -> - v!3) ])) - , (delay - (case - `$dOrd`!9 - [ (\v!0 - v!0 - v!0 - v!0 - v!0 - v!0 - v!0 - v!0 -> - v!5) ])) - , (delay - (\x!0 y!0 -> - force - (case + ds!1 + [ (delay (go!9 xs!6)) + , (\x!0 xs!0 -> + delay + (force + (case + (meaning!5 + x!2 + ds!12) + [ (delay + (go!4 + xs!1)) + , (delay + (constr 1 + [ ])) ]))) ])) + expectedPredValues!2) + (force + (case + predKey!2 + [ (delay + (case + `$dOrd`!9 + [ (\v!0 + v!0 + v!0 + v!0 + v!0 + v!0 + v!0 + v!0 -> + v!3) ])) + , (delay + (case + `$dOrd`!9 + [ (\v!0 + v!0 + v!0 + v!0 + v!0 + v!0 + v!0 + v!0 -> + v!5) ])) + , (delay + (\x!0 y!0 -> + force (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) - [ (delay - (constr 1 - [])) - , (delay - (constr 0 - [ ])) ]))) ]))) ])) ])) - ds!2)) + (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) + [ (delay + (constr 1 + [])) + , (delay + (constr 0 + [ ])) ]))) ]))) ])) ])) + ds!2)) + (\x!0 y!0 -> + force ifThenElse + (equalsInteger x!2 y!1) + (constr 0 []) + (constr 1 []))) (\eta!0 eta!0 -> force (force @@ -1392,4 +1419,4 @@ program (multiplyInteger n'!2 d!3)) (constr 0 []) (constr 1 [])) ]) ])) - (\f!0 -> (\s!0 -> s!1 s!1) (\s!0 -> f!2 (\x!0 -> s!2 s!2 x!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