From f709d7c7ae8ead88968b9d70a3d56d67499fb9d2 Mon Sep 17 00:00:00 2001 From: Lasse Letager Hansen Date: Tue, 26 Nov 2024 18:13:29 +0100 Subject: [PATCH] Generated library for numbers --- .../fstar/generated_core/Core.Base.Binary.fst | 168 + .../Core.Base.Number_conversion.fst | 76 + .../fstar/generated_core/Core.Base.Pos.fst | 443 + .../Core.Base.Spec.Binary.Pos.fst | 18 + .../Core.Base.Spec.Binary.Positive.fst | 127 + .../Core.Base.Spec.Constants.fst | 363 + .../generated_core/Core.Base.Spec.Haxint.fst | 98 + .../generated_core/Core.Base.Spec.Unary.fst | 70 + .../fstar/generated_core/Core.Base.Spec.Z.fst | 19 + .../fstar/generated_core/Core.Base.Z.fst | 553 ++ .../Core.Base_interface.Coerce.fst | 19 + .../Core.Base_interface.Int.I128_proofs.fst | 23 + .../Core.Base_interface.Int.I16_proofs.fst | 23 + .../Core.Base_interface.Int.I32_proofs.fst | 23 + .../Core.Base_interface.Int.I64_proofs.fst | 23 + .../Core.Base_interface.Int.I8_proofs.fst | 21 + .../Core.Base_interface.Int.U128_proofs.fst | 519 ++ .../Core.Base_interface.Int.U16_proofs.fst | 519 ++ .../Core.Base_interface.Int.U32_proofs.fst | 519 ++ .../Core.Base_interface.Int.U64_proofs.fst | 519 ++ .../Core.Base_interface.Int.U8_proofs.fst | 513 ++ .../Core.Base_interface.Int.fst | 7241 +++++++++++++++++ .../fstar/generated_core/Core.Clone.fst | 10 + proof-libs/fstar/generated_core/Core.Cmp.fst | 135 + .../fstar/generated_core/Core.Convert.fst | 33 + .../Core.Intrinsics.Rec_bundle_253787241.fst | 5865 +++++++++++++ .../fstar/generated_core/Core.Intrinsics.fst | 220 + .../fstar/generated_core/Core.Marker.fst | 14 + proof-libs/fstar/generated_core/Core.Num.fst | 472 ++ .../Core.Ops.Arith.Impls_for_prims.fst | 1186 +++ .../fstar/generated_core/Core.Ops.Arith.fst | 51 + .../Core.Ops.Bit.Impls_for_prims.fst | 1796 ++++ .../fstar/generated_core/Core.Ops.Bit.fst | 51 + .../fstar/generated_core/Core.Option.fst | 47 + .../fstar/generated_core/Core.Panicking.fst | 51 + .../Core.Primitive.Number_conversion.fst | 88 + .../Core.Primitive.Number_conversion_i.fst | 88 + .../fstar/generated_core/Core.Primitive.fst | 1240 +++ .../fstar/generated_core/Core.Result.fst | 13 + 39 files changed, 23257 insertions(+) create mode 100644 proof-libs/fstar/generated_core/Core.Base.Binary.fst create mode 100644 proof-libs/fstar/generated_core/Core.Base.Number_conversion.fst create mode 100644 proof-libs/fstar/generated_core/Core.Base.Pos.fst create mode 100644 proof-libs/fstar/generated_core/Core.Base.Spec.Binary.Pos.fst create mode 100644 proof-libs/fstar/generated_core/Core.Base.Spec.Binary.Positive.fst create mode 100644 proof-libs/fstar/generated_core/Core.Base.Spec.Constants.fst create mode 100644 proof-libs/fstar/generated_core/Core.Base.Spec.Haxint.fst create mode 100644 proof-libs/fstar/generated_core/Core.Base.Spec.Unary.fst create mode 100644 proof-libs/fstar/generated_core/Core.Base.Spec.Z.fst create mode 100644 proof-libs/fstar/generated_core/Core.Base.Z.fst create mode 100644 proof-libs/fstar/generated_core/Core.Base_interface.Coerce.fst create mode 100644 proof-libs/fstar/generated_core/Core.Base_interface.Int.I128_proofs.fst create mode 100644 proof-libs/fstar/generated_core/Core.Base_interface.Int.I16_proofs.fst create mode 100644 proof-libs/fstar/generated_core/Core.Base_interface.Int.I32_proofs.fst create mode 100644 proof-libs/fstar/generated_core/Core.Base_interface.Int.I64_proofs.fst create mode 100644 proof-libs/fstar/generated_core/Core.Base_interface.Int.I8_proofs.fst create mode 100644 proof-libs/fstar/generated_core/Core.Base_interface.Int.U128_proofs.fst create mode 100644 proof-libs/fstar/generated_core/Core.Base_interface.Int.U16_proofs.fst create mode 100644 proof-libs/fstar/generated_core/Core.Base_interface.Int.U32_proofs.fst create mode 100644 proof-libs/fstar/generated_core/Core.Base_interface.Int.U64_proofs.fst create mode 100644 proof-libs/fstar/generated_core/Core.Base_interface.Int.U8_proofs.fst create mode 100644 proof-libs/fstar/generated_core/Core.Base_interface.Int.fst create mode 100644 proof-libs/fstar/generated_core/Core.Clone.fst create mode 100644 proof-libs/fstar/generated_core/Core.Cmp.fst create mode 100644 proof-libs/fstar/generated_core/Core.Convert.fst create mode 100644 proof-libs/fstar/generated_core/Core.Intrinsics.Rec_bundle_253787241.fst create mode 100644 proof-libs/fstar/generated_core/Core.Intrinsics.fst create mode 100644 proof-libs/fstar/generated_core/Core.Marker.fst create mode 100644 proof-libs/fstar/generated_core/Core.Num.fst create mode 100644 proof-libs/fstar/generated_core/Core.Ops.Arith.Impls_for_prims.fst create mode 100644 proof-libs/fstar/generated_core/Core.Ops.Arith.fst create mode 100644 proof-libs/fstar/generated_core/Core.Ops.Bit.Impls_for_prims.fst create mode 100644 proof-libs/fstar/generated_core/Core.Ops.Bit.fst create mode 100644 proof-libs/fstar/generated_core/Core.Option.fst create mode 100644 proof-libs/fstar/generated_core/Core.Panicking.fst create mode 100644 proof-libs/fstar/generated_core/Core.Primitive.Number_conversion.fst create mode 100644 proof-libs/fstar/generated_core/Core.Primitive.Number_conversion_i.fst create mode 100644 proof-libs/fstar/generated_core/Core.Primitive.fst create mode 100644 proof-libs/fstar/generated_core/Core.Result.fst diff --git a/proof-libs/fstar/generated_core/Core.Base.Binary.fst b/proof-libs/fstar/generated_core/Core.Base.Binary.fst new file mode 100644 index 000000000..b2599d7bd --- /dev/null +++ b/proof-libs/fstar/generated_core/Core.Base.Binary.fst @@ -0,0 +1,168 @@ +module Core.Base.Binary +#set-options "--fuel 0 --ifuel 1 --z3rlimit 15" +open Core +open FStar.Mul + +let rec positive_cmp__cmp_binary_cont + (x y: Core.Base.Spec.Binary.Positive.t_Positive) + (r: Core.Cmp.t_Ordering) + : Core.Cmp.t_Ordering = + match Core.Base.Spec.Binary.Positive.match_positive x with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> + (match Core.Base.Spec.Binary.Positive.match_positive y with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> r + | Core.Base.Spec.Binary.Positive.POSITIVE_XO q + | Core.Base.Spec.Binary.Positive.POSITIVE_XI q -> + Core.Cmp.Ordering_Less <: Core.Cmp.t_Ordering) + | Core.Base.Spec.Binary.Positive.POSITIVE_XO p -> + (match Core.Base.Spec.Binary.Positive.match_positive y with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> + Core.Cmp.Ordering_Greater <: Core.Cmp.t_Ordering + | Core.Base.Spec.Binary.Positive.POSITIVE_XO q -> positive_cmp__cmp_binary_cont p q r + | Core.Base.Spec.Binary.Positive.POSITIVE_XI q -> + positive_cmp__cmp_binary_cont p q (Core.Cmp.Ordering_Less <: Core.Cmp.t_Ordering)) + | Core.Base.Spec.Binary.Positive.POSITIVE_XI p -> + match Core.Base.Spec.Binary.Positive.match_positive y with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> + Core.Cmp.Ordering_Greater <: Core.Cmp.t_Ordering + | Core.Base.Spec.Binary.Positive.POSITIVE_XO q -> + positive_cmp__cmp_binary_cont p q (Core.Cmp.Ordering_Greater <: Core.Cmp.t_Ordering) + | Core.Base.Spec.Binary.Positive.POSITIVE_XI q -> positive_cmp__cmp_binary_cont p q r + +let positive_cmp (lhs rhs: Core.Base.Spec.Binary.Positive.t_Positive) : Core.Cmp.t_Ordering = + positive_cmp__cmp_binary_cont lhs rhs (Core.Cmp.Ordering_Equal <: Core.Cmp.t_Ordering) + +let positive_le (lhs rhs: Core.Base.Spec.Binary.Positive.t_Positive) : bool = + match + Core.Option.Option_Some (positive_cmp lhs rhs) <: Core.Option.t_Option Core.Cmp.t_Ordering + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Less ) + | Core.Option.Option_Some (Core.Cmp.Ordering_Equal ) -> true + | _ -> false + +let rec positive_pred_double (s: Core.Base.Spec.Binary.Positive.t_Positive) + : Core.Base.Spec.Binary.Positive.t_Positive = + match Core.Base.Spec.Binary.Positive.match_positive s with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> Core.Base.Spec.Binary.Positive.xH + | Core.Base.Spec.Binary.Positive.POSITIVE_XO p -> + Core.Base.Spec.Binary.Positive.xI (positive_pred_double p + <: + Core.Base.Spec.Binary.Positive.t_Positive) + | Core.Base.Spec.Binary.Positive.POSITIVE_XI p -> + Core.Base.Spec.Binary.Positive.xI (Core.Base.Spec.Binary.Positive.xO p + <: + Core.Base.Spec.Binary.Positive.t_Positive) + +let rec positive_succ (s: Core.Base.Spec.Binary.Positive.t_Positive) + : Core.Base.Spec.Binary.Positive.t_Positive = + match Core.Base.Spec.Binary.Positive.match_positive s with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> + Core.Base.Spec.Binary.Positive.xO Core.Base.Spec.Binary.Positive.xH + | Core.Base.Spec.Binary.Positive.POSITIVE_XO q -> Core.Base.Spec.Binary.Positive.xI q + | Core.Base.Spec.Binary.Positive.POSITIVE_XI q -> + Core.Base.Spec.Binary.Positive.xO (positive_succ q <: Core.Base.Spec.Binary.Positive.t_Positive) + +let positive_add (lhs rhs: Core.Base.Spec.Binary.Positive.t_Positive) + : Core.Base.Spec.Binary.Positive.t_Positive = positive_add__add lhs rhs + +let rec positive_mul (lhs rhs: Core.Base.Spec.Binary.Positive.t_Positive) + : Core.Base.Spec.Binary.Positive.t_Positive = + match Core.Base.Spec.Binary.Positive.match_positive lhs with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> rhs + | Core.Base.Spec.Binary.Positive.POSITIVE_XO p -> + Core.Base.Spec.Binary.Positive.xO (positive_mul p rhs + <: + Core.Base.Spec.Binary.Positive.t_Positive) + | Core.Base.Spec.Binary.Positive.POSITIVE_XI p -> + positive_add (Core.Clone.f_clone #Core.Base.Spec.Binary.Positive.t_Positive + #FStar.Tactics.Typeclasses.solve + rhs + <: + Core.Base.Spec.Binary.Positive.t_Positive) + (Core.Base.Spec.Binary.Positive.xO (positive_mul p rhs + <: + Core.Base.Spec.Binary.Positive.t_Positive) + <: + Core.Base.Spec.Binary.Positive.t_Positive) + +let rec positive_add__add (lhs rhs: Core.Base.Spec.Binary.Positive.t_Positive) + : Core.Base.Spec.Binary.Positive.t_Positive = + match Core.Base.Spec.Binary.Positive.match_positive lhs with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> + (match Core.Base.Spec.Binary.Positive.match_positive rhs with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> + Core.Base.Spec.Binary.Positive.xO Core.Base.Spec.Binary.Positive.xH + | Core.Base.Spec.Binary.Positive.POSITIVE_XO q -> Core.Base.Spec.Binary.Positive.xI q + | Core.Base.Spec.Binary.Positive.POSITIVE_XI q -> + Core.Base.Spec.Binary.Positive.xO (positive_succ q + <: + Core.Base.Spec.Binary.Positive.t_Positive)) + | Core.Base.Spec.Binary.Positive.POSITIVE_XO p -> + (match Core.Base.Spec.Binary.Positive.match_positive rhs with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> Core.Base.Spec.Binary.Positive.xI p + | Core.Base.Spec.Binary.Positive.POSITIVE_XO q -> + Core.Base.Spec.Binary.Positive.xO (positive_add__add p q + <: + Core.Base.Spec.Binary.Positive.t_Positive) + | Core.Base.Spec.Binary.Positive.POSITIVE_XI q -> + Core.Base.Spec.Binary.Positive.xI (positive_add__add p q + <: + Core.Base.Spec.Binary.Positive.t_Positive)) + | Core.Base.Spec.Binary.Positive.POSITIVE_XI p -> + match Core.Base.Spec.Binary.Positive.match_positive rhs with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> + Core.Base.Spec.Binary.Positive.xO (positive_succ p + <: + Core.Base.Spec.Binary.Positive.t_Positive) + | Core.Base.Spec.Binary.Positive.POSITIVE_XO q -> + Core.Base.Spec.Binary.Positive.xI (positive_add__add p q + <: + Core.Base.Spec.Binary.Positive.t_Positive) + | Core.Base.Spec.Binary.Positive.POSITIVE_XI q -> + Core.Base.Spec.Binary.Positive.xO (positive_add__add_carry p q + <: + Core.Base.Spec.Binary.Positive.t_Positive) + +and positive_add__add_carry (lhs rhs: Core.Base.Spec.Binary.Positive.t_Positive) + : Core.Base.Spec.Binary.Positive.t_Positive = + match Core.Base.Spec.Binary.Positive.match_positive lhs with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> + (match Core.Base.Spec.Binary.Positive.match_positive rhs with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> + Core.Base.Spec.Binary.Positive.xI Core.Base.Spec.Binary.Positive.xH + | Core.Base.Spec.Binary.Positive.POSITIVE_XO q -> + Core.Base.Spec.Binary.Positive.xO (positive_succ q + <: + Core.Base.Spec.Binary.Positive.t_Positive) + | Core.Base.Spec.Binary.Positive.POSITIVE_XI q -> + Core.Base.Spec.Binary.Positive.xI (positive_succ q + <: + Core.Base.Spec.Binary.Positive.t_Positive)) + | Core.Base.Spec.Binary.Positive.POSITIVE_XO p -> + (match Core.Base.Spec.Binary.Positive.match_positive rhs with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> + Core.Base.Spec.Binary.Positive.xO (positive_succ p + <: + Core.Base.Spec.Binary.Positive.t_Positive) + | Core.Base.Spec.Binary.Positive.POSITIVE_XO q -> + Core.Base.Spec.Binary.Positive.xI (positive_add__add p q + <: + Core.Base.Spec.Binary.Positive.t_Positive) + | Core.Base.Spec.Binary.Positive.POSITIVE_XI q -> + Core.Base.Spec.Binary.Positive.xO (positive_add__add_carry p q + <: + Core.Base.Spec.Binary.Positive.t_Positive)) + | Core.Base.Spec.Binary.Positive.POSITIVE_XI p -> + match Core.Base.Spec.Binary.Positive.match_positive rhs with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> + Core.Base.Spec.Binary.Positive.xI (positive_succ p + <: + Core.Base.Spec.Binary.Positive.t_Positive) + | Core.Base.Spec.Binary.Positive.POSITIVE_XO q -> + Core.Base.Spec.Binary.Positive.xO (positive_add__add_carry p q + <: + Core.Base.Spec.Binary.Positive.t_Positive) + | Core.Base.Spec.Binary.Positive.POSITIVE_XI q -> + Core.Base.Spec.Binary.Positive.xI (positive_add__add_carry p q + <: + Core.Base.Spec.Binary.Positive.t_Positive) diff --git a/proof-libs/fstar/generated_core/Core.Base.Number_conversion.fst b/proof-libs/fstar/generated_core/Core.Base.Number_conversion.fst new file mode 100644 index 000000000..c828dcc9a --- /dev/null +++ b/proof-libs/fstar/generated_core/Core.Base.Number_conversion.fst @@ -0,0 +1,76 @@ +module Core.Base.Number_conversion +#set-options "--fuel 0 --ifuel 1 --z3rlimit 15" +open Core +open FStar.Mul + +include Core.Intrinsics.Rec_bundle_253787241 {from_u128_binary as impl_24__from_u128_binary} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_8 as impl_8} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_20 as impl_20} + +include Core.Intrinsics.Rec_bundle_253787241 {from_u16_binary as impl_24__from_u16_binary} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_2 as impl_2} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_14 as impl_14} + +include Core.Intrinsics.Rec_bundle_253787241 {from_u32_binary as impl_24__from_u32_binary} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_4 as impl_4} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_16 as impl_16} + +include Core.Intrinsics.Rec_bundle_253787241 {from_u64_binary as impl_24__from_u64_binary} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_6 as impl_6} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_18 as impl_18} + +include Core.Intrinsics.Rec_bundle_253787241 {from_u8_binary as impl_24__from_u8_binary} + +include Core.Intrinsics.Rec_bundle_253787241 {impl as impl} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_12 as impl_12} + +include Core.Intrinsics.Rec_bundle_253787241 {from_usize_binary as impl_24__from_usize_binary} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_10 as impl_10} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_22 as impl_22} + +include Core.Intrinsics.Rec_bundle_253787241 {to_u128_binary as impl_24__to_u128_binary} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_9 as impl_9} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_21 as impl_21} + +include Core.Intrinsics.Rec_bundle_253787241 {to_u16_binary as impl_24__to_u16_binary} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_3 as impl_3} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_15 as impl_15} + +include Core.Intrinsics.Rec_bundle_253787241 {to_u32_binary as impl_24__to_u32_binary} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_5 as impl_5} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_17 as impl_17} + +include Core.Intrinsics.Rec_bundle_253787241 {to_u64_binary as impl_24__to_u64_binary} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_7 as impl_7} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_19 as impl_19} + +include Core.Intrinsics.Rec_bundle_253787241 {to_u8_binary as impl_24__to_u8_binary} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_1 as impl_1} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_13 as impl_13} + +include Core.Intrinsics.Rec_bundle_253787241 {to_usize_binary as impl_24__to_usize_binary} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_11 as impl_11} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_23 as impl_23} diff --git a/proof-libs/fstar/generated_core/Core.Base.Pos.fst b/proof-libs/fstar/generated_core/Core.Base.Pos.fst new file mode 100644 index 000000000..94c38c5a5 --- /dev/null +++ b/proof-libs/fstar/generated_core/Core.Base.Pos.fst @@ -0,0 +1,443 @@ +module Core.Base.Pos +#set-options "--fuel 0 --ifuel 1 --z3rlimit 15" +open Core +open FStar.Mul + +let haxint_double (s: Core.Base.Spec.Haxint.t_HaxInt) : Core.Base.Spec.Haxint.t_HaxInt = + match Core.Base.Spec.Binary.Pos.match_pos s with + | Core.Base.Spec.Binary.Pos.POS_ZERO -> Core.Base.Spec.Haxint.v_HaxInt_ZERO + | Core.Base.Spec.Binary.Pos.POS_POS p -> + Core.Base.Spec.Binary.Positive.positive_to_int (Core.Base.Spec.Binary.Positive.xO p + <: + Core.Base.Spec.Binary.Positive.t_Positive) + +let haxint_shr__half (s: Core.Base.Spec.Haxint.t_HaxInt) : Core.Base.Spec.Haxint.t_HaxInt = + match Core.Base.Spec.Binary.Pos.match_pos s with + | Core.Base.Spec.Binary.Pos.POS_ZERO -> Core.Base.Spec.Haxint.v_HaxInt_ZERO + | Core.Base.Spec.Binary.Pos.POS_POS n -> + match Core.Base.Spec.Binary.Positive.match_positive n with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> Core.Base.Spec.Haxint.v_HaxInt_ZERO + | Core.Base.Spec.Binary.Positive.POSITIVE_XO p -> + Core.Base.Spec.Binary.Positive.positive_to_int p + | Core.Base.Spec.Binary.Positive.POSITIVE_XI p -> + Core.Base.Spec.Binary.Positive.positive_to_int p + +let haxint_sub__double_mask (lhs: Core.Base.Spec.Haxint.t_HaxInt) : Core.Base.Spec.Haxint.t_HaxInt = + match Core.Base.Spec.Binary.Pos.match_pos lhs with + | Core.Base.Spec.Binary.Pos.POS_ZERO -> Core.Base.Spec.Haxint.v_HaxInt_ZERO + | Core.Base.Spec.Binary.Pos.POS_POS p -> + Core.Base.Spec.Binary.Positive.positive_to_int (Core.Base.Spec.Binary.Positive.xO p + <: + Core.Base.Spec.Binary.Positive.t_Positive) + +let haxint_sub__succ_double_mask (lhs: Core.Base.Spec.Haxint.t_HaxInt) + : Core.Base.Spec.Haxint.t_HaxInt = + match Core.Base.Spec.Binary.Pos.match_pos lhs with + | Core.Base.Spec.Binary.Pos.POS_ZERO -> + Core.Base.Spec.Binary.Positive.positive_to_int Core.Base.Spec.Binary.Positive.xH + | Core.Base.Spec.Binary.Pos.POS_POS p -> + Core.Base.Spec.Binary.Positive.positive_to_int (Core.Base.Spec.Binary.Positive.xI p + <: + Core.Base.Spec.Binary.Positive.t_Positive) + +let haxint_succ_double (s: Core.Base.Spec.Haxint.t_HaxInt) + : Core.Base.Spec.Binary.Positive.t_Positive = + match Core.Base.Spec.Binary.Pos.match_pos s with + | Core.Base.Spec.Binary.Pos.POS_ZERO -> Core.Base.Spec.Binary.Positive.xH + | Core.Base.Spec.Binary.Pos.POS_POS p -> Core.Base.Spec.Binary.Positive.xI p + +let rec bitand_binary (lhs rhs: Core.Base.Spec.Binary.Positive.t_Positive) + : Core.Base.Spec.Haxint.t_HaxInt = + match Core.Base.Spec.Binary.Positive.match_positive lhs with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> + (match Core.Base.Spec.Binary.Positive.match_positive rhs with + | Core.Base.Spec.Binary.Positive.POSITIVE_XO q -> Core.Base.Spec.Haxint.v_HaxInt_ZERO + | Core.Base.Spec.Binary.Positive.POSITIVE_XI _ + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> Core.Base.Spec.Haxint.v_HaxInt_ONE) + | Core.Base.Spec.Binary.Positive.POSITIVE_XO p -> + (match Core.Base.Spec.Binary.Positive.match_positive rhs with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> Core.Base.Spec.Haxint.v_HaxInt_ZERO + | Core.Base.Spec.Binary.Positive.POSITIVE_XO q + | Core.Base.Spec.Binary.Positive.POSITIVE_XI q -> + haxint_double (bitand_binary p q <: Core.Base.Spec.Haxint.t_HaxInt)) + | Core.Base.Spec.Binary.Positive.POSITIVE_XI p -> + match Core.Base.Spec.Binary.Positive.match_positive rhs with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> Core.Base.Spec.Haxint.v_HaxInt_ONE + | Core.Base.Spec.Binary.Positive.POSITIVE_XO q -> + haxint_double (bitand_binary p q <: Core.Base.Spec.Haxint.t_HaxInt) + | Core.Base.Spec.Binary.Positive.POSITIVE_XI q -> + Core.Base.Spec.Binary.Positive.positive_to_int (haxint_succ_double (bitand_binary p q + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Binary.Positive.t_Positive) + +let rec bitor_binary (lhs rhs: Core.Base.Spec.Binary.Positive.t_Positive) + : Core.Base.Spec.Binary.Positive.t_Positive = + match Core.Base.Spec.Binary.Positive.match_positive lhs with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> + (match Core.Base.Spec.Binary.Positive.match_positive rhs with + | Core.Base.Spec.Binary.Positive.POSITIVE_XO q -> Core.Base.Spec.Binary.Positive.xI q + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> Core.Base.Spec.Binary.Positive.xH + | Core.Base.Spec.Binary.Positive.POSITIVE_XI q -> Core.Base.Spec.Binary.Positive.xI q) + | Core.Base.Spec.Binary.Positive.POSITIVE_XO p -> + (match Core.Base.Spec.Binary.Positive.match_positive rhs with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> Core.Base.Spec.Binary.Positive.xI p + | Core.Base.Spec.Binary.Positive.POSITIVE_XO q -> + Core.Base.Spec.Binary.Positive.xO (bitor_binary p q + <: + Core.Base.Spec.Binary.Positive.t_Positive) + | Core.Base.Spec.Binary.Positive.POSITIVE_XI q -> + Core.Base.Spec.Binary.Positive.xI (bitor_binary p q + <: + Core.Base.Spec.Binary.Positive.t_Positive)) + | Core.Base.Spec.Binary.Positive.POSITIVE_XI p -> + match Core.Base.Spec.Binary.Positive.match_positive rhs with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> Core.Base.Spec.Binary.Positive.xI p + | Core.Base.Spec.Binary.Positive.POSITIVE_XO q + | Core.Base.Spec.Binary.Positive.POSITIVE_XI q -> + Core.Base.Spec.Binary.Positive.xI (bitor_binary p q + <: + Core.Base.Spec.Binary.Positive.t_Positive) + +let rec bitxor_binary (lhs rhs: Core.Base.Spec.Binary.Positive.t_Positive) + : Core.Base.Spec.Haxint.t_HaxInt = + match Core.Base.Spec.Binary.Positive.match_positive lhs with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> + (match Core.Base.Spec.Binary.Positive.match_positive rhs with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> Core.Base.Spec.Haxint.v_HaxInt_ZERO + | Core.Base.Spec.Binary.Positive.POSITIVE_XO q -> + Core.Base.Spec.Binary.Positive.positive_to_int (Core.Base.Spec.Binary.Positive.xI q + <: + Core.Base.Spec.Binary.Positive.t_Positive) + | Core.Base.Spec.Binary.Positive.POSITIVE_XI q -> + Core.Base.Spec.Binary.Positive.positive_to_int (Core.Base.Spec.Binary.Positive.xO q + <: + Core.Base.Spec.Binary.Positive.t_Positive)) + | Core.Base.Spec.Binary.Positive.POSITIVE_XO p -> + (match Core.Base.Spec.Binary.Positive.match_positive rhs with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> + Core.Base.Spec.Binary.Positive.positive_to_int (Core.Base.Spec.Binary.Positive.xI p + <: + Core.Base.Spec.Binary.Positive.t_Positive) + | Core.Base.Spec.Binary.Positive.POSITIVE_XO q -> + haxint_double (bitxor_binary p q <: Core.Base.Spec.Haxint.t_HaxInt) + | Core.Base.Spec.Binary.Positive.POSITIVE_XI q -> + Core.Base.Spec.Binary.Positive.positive_to_int (haxint_succ_double (bitxor_binary p q + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Binary.Positive.t_Positive)) + | Core.Base.Spec.Binary.Positive.POSITIVE_XI p -> + match Core.Base.Spec.Binary.Positive.match_positive rhs with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> + Core.Base.Spec.Binary.Positive.positive_to_int (Core.Base.Spec.Binary.Positive.xO p + <: + Core.Base.Spec.Binary.Positive.t_Positive) + | Core.Base.Spec.Binary.Positive.POSITIVE_XO q -> + Core.Base.Spec.Binary.Positive.positive_to_int (haxint_succ_double (bitxor_binary p q + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Binary.Positive.t_Positive) + | Core.Base.Spec.Binary.Positive.POSITIVE_XI q -> + haxint_double (bitxor_binary p q <: Core.Base.Spec.Haxint.t_HaxInt) + +let haxint_bitand (lhs rhs: Core.Base.Spec.Haxint.t_HaxInt) : Core.Base.Spec.Haxint.t_HaxInt = + match Core.Base.Spec.Binary.Pos.match_pos lhs with + | Core.Base.Spec.Binary.Pos.POS_ZERO -> Core.Base.Spec.Haxint.v_HaxInt_ZERO + | Core.Base.Spec.Binary.Pos.POS_POS p -> + match Core.Base.Spec.Binary.Pos.match_pos rhs with + | Core.Base.Spec.Binary.Pos.POS_ZERO -> Core.Base.Spec.Haxint.v_HaxInt_ZERO + | Core.Base.Spec.Binary.Pos.POS_POS q -> bitand_binary p q + +let haxint_bitor (lhs rhs: Core.Base.Spec.Haxint.t_HaxInt) : Core.Base.Spec.Haxint.t_HaxInt = + match Core.Base.Spec.Binary.Pos.match_pos lhs with + | Core.Base.Spec.Binary.Pos.POS_ZERO -> rhs + | Core.Base.Spec.Binary.Pos.POS_POS p -> + match Core.Base.Spec.Binary.Pos.match_pos rhs with + | Core.Base.Spec.Binary.Pos.POS_ZERO -> Core.Base.Spec.Binary.Positive.positive_to_int p + | Core.Base.Spec.Binary.Pos.POS_POS q -> + Core.Base.Spec.Binary.Positive.positive_to_int (bitor_binary p q + <: + Core.Base.Spec.Binary.Positive.t_Positive) + +let haxint_bitxor (lhs rhs: Core.Base.Spec.Haxint.t_HaxInt) : Core.Base.Spec.Haxint.t_HaxInt = + match Core.Base.Spec.Binary.Pos.match_pos lhs with + | Core.Base.Spec.Binary.Pos.POS_ZERO -> rhs + | Core.Base.Spec.Binary.Pos.POS_POS p -> + match Core.Base.Spec.Binary.Pos.match_pos rhs with + | Core.Base.Spec.Binary.Pos.POS_ZERO -> Core.Base.Spec.Binary.Positive.positive_to_int p + | Core.Base.Spec.Binary.Pos.POS_POS q -> bitxor_binary p q + +let haxint_cmp (lhs rhs: Core.Base.Spec.Haxint.t_HaxInt) : Core.Cmp.t_Ordering = + match Core.Base.Spec.Binary.Pos.match_pos lhs with + | Core.Base.Spec.Binary.Pos.POS_ZERO -> + (match Core.Base.Spec.Binary.Pos.match_pos rhs with + | Core.Base.Spec.Binary.Pos.POS_ZERO -> Core.Cmp.Ordering_Equal <: Core.Cmp.t_Ordering + | Core.Base.Spec.Binary.Pos.POS_POS q -> Core.Cmp.Ordering_Less <: Core.Cmp.t_Ordering) + | Core.Base.Spec.Binary.Pos.POS_POS p -> + match Core.Base.Spec.Binary.Pos.match_pos rhs with + | Core.Base.Spec.Binary.Pos.POS_ZERO -> Core.Cmp.Ordering_Greater <: Core.Cmp.t_Ordering + | Core.Base.Spec.Binary.Pos.POS_POS q -> Core.Base.Binary.positive_cmp p q + +let haxint_le (lhs rhs: Core.Base.Spec.Haxint.t_HaxInt) : bool = + match + Core.Option.Option_Some (haxint_cmp lhs rhs) <: Core.Option.t_Option Core.Cmp.t_Ordering + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Less ) + | Core.Option.Option_Some (Core.Cmp.Ordering_Equal ) -> true + | _ -> false + +let haxint_lt (lhs rhs: Core.Base.Spec.Haxint.t_HaxInt) : bool = + match + Core.Option.Option_Some (haxint_cmp lhs rhs) <: Core.Option.t_Option Core.Cmp.t_Ordering + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Less ) -> true + | _ -> false + +let rec haxint_shl__shl_helper (rhs: Core.Base.Spec.Unary.t_Unary) (lhs: Core.Base.Spec.Haxint.t_HaxInt) + : Core.Base.Spec.Haxint.t_HaxInt = + if + Core.Base.Spec.Haxint.is_zero (Core.Clone.f_clone #Core.Base.Spec.Haxint.t_HaxInt + #FStar.Tactics.Typeclasses.solve + lhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + then lhs + else + match Core.Base.Spec.Unary.match_unary rhs with + | Core.Base.Spec.Unary.UNARY_ZERO -> lhs + | Core.Base.Spec.Unary.UNARY_SUCC n -> + haxint_shl__shl_helper n (haxint_double lhs <: Core.Base.Spec.Haxint.t_HaxInt) + +let haxint_shl (lhs rhs: Core.Base.Spec.Haxint.t_HaxInt) : Core.Base.Spec.Haxint.t_HaxInt = + haxint_shl__shl_helper (Core.Base.Spec.Unary.unary_from_int rhs <: Core.Base.Spec.Unary.t_Unary) + lhs + +let rec haxint_shr__shr_helper (rhs: Core.Base.Spec.Unary.t_Unary) (lhs: Core.Base.Spec.Haxint.t_HaxInt) + : Core.Base.Spec.Haxint.t_HaxInt = + if + Core.Base.Spec.Haxint.is_zero (Core.Clone.f_clone #Core.Base.Spec.Haxint.t_HaxInt + #FStar.Tactics.Typeclasses.solve + lhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + then lhs + else + match Core.Base.Spec.Unary.match_unary rhs with + | Core.Base.Spec.Unary.UNARY_ZERO -> lhs + | Core.Base.Spec.Unary.UNARY_SUCC n -> + haxint_shr__shr_helper n (haxint_shr__half lhs <: Core.Base.Spec.Haxint.t_HaxInt) + +let haxint_shr (lhs rhs: Core.Base.Spec.Haxint.t_HaxInt) : Core.Base.Spec.Haxint.t_HaxInt = + haxint_shr__shr_helper (Core.Base.Spec.Unary.unary_from_int rhs <: Core.Base.Spec.Unary.t_Unary) + lhs + +let haxint_sub__double_pred_mask (lhs: Core.Base.Spec.Binary.Positive.t_Positive) + : Core.Base.Spec.Haxint.t_HaxInt = + match Core.Base.Spec.Binary.Positive.match_positive lhs with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> Core.Base.Spec.Haxint.v_HaxInt_ZERO + | Core.Base.Spec.Binary.Positive.POSITIVE_XO p -> + Core.Base.Spec.Binary.Positive.positive_to_int (Core.Base.Spec.Binary.Positive.xO (Core.Base.Binary.positive_pred_double + p + <: + Core.Base.Spec.Binary.Positive.t_Positive) + <: + Core.Base.Spec.Binary.Positive.t_Positive) + | Core.Base.Spec.Binary.Positive.POSITIVE_XI p -> + Core.Base.Spec.Binary.Positive.positive_to_int (Core.Base.Spec.Binary.Positive.xO (Core.Base.Spec.Binary.Positive.xO + p + <: + Core.Base.Spec.Binary.Positive.t_Positive) + <: + Core.Base.Spec.Binary.Positive.t_Positive) + +let rec power_of_two (s: Core.Base.Spec.Unary.t_Unary) : Core.Base.Spec.Binary.Positive.t_Positive = + match Core.Base.Spec.Unary.match_unary s with + | Core.Base.Spec.Unary.UNARY_ZERO -> Core.Base.Spec.Binary.Positive.xH + | Core.Base.Spec.Unary.UNARY_SUCC x -> + Core.Base.Spec.Binary.Positive.xO (power_of_two x <: Core.Base.Spec.Binary.Positive.t_Positive) + +let haxint_add (lhs rhs: Core.Base.Spec.Haxint.t_HaxInt) : Core.Base.Spec.Haxint.t_HaxInt = + match Core.Base.Spec.Binary.Pos.match_pos lhs with + | Core.Base.Spec.Binary.Pos.POS_ZERO -> rhs + | Core.Base.Spec.Binary.Pos.POS_POS p -> + match Core.Base.Spec.Binary.Pos.match_pos rhs with + | Core.Base.Spec.Binary.Pos.POS_ZERO -> Core.Base.Spec.Binary.Positive.positive_to_int p + | Core.Base.Spec.Binary.Pos.POS_POS q -> + Core.Base.Spec.Binary.Positive.positive_to_int (Core.Base.Binary.positive_add p q + <: + Core.Base.Spec.Binary.Positive.t_Positive) + +let haxint_sub (lhs rhs: Core.Base.Spec.Haxint.t_HaxInt) : Core.Base.Spec.Haxint.t_HaxInt = + match Core.Base.Spec.Binary.Pos.match_pos lhs with + | Core.Base.Spec.Binary.Pos.POS_ZERO -> Core.Base.Spec.Haxint.v_HaxInt_ZERO + | Core.Base.Spec.Binary.Pos.POS_POS p -> + match Core.Base.Spec.Binary.Pos.match_pos rhs with + | Core.Base.Spec.Binary.Pos.POS_ZERO -> Core.Base.Spec.Binary.Positive.positive_to_int p + | Core.Base.Spec.Binary.Pos.POS_POS q -> haxint_sub__sub_binary p q + +let rec haxint_divmod__divmod_binary (a b: Core.Base.Spec.Binary.Positive.t_Positive) + : (Core.Base.Spec.Haxint.t_HaxInt & Core.Base.Spec.Haxint.t_HaxInt) = + match Core.Base.Spec.Binary.Positive.match_positive a with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> + (match Core.Base.Spec.Binary.Positive.match_positive b with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> + Core.Base.Spec.Haxint.v_HaxInt_ONE, Core.Base.Spec.Haxint.v_HaxInt_ZERO + <: + (Core.Base.Spec.Haxint.t_HaxInt & Core.Base.Spec.Haxint.t_HaxInt) + | Core.Base.Spec.Binary.Positive.POSITIVE_XO q + | Core.Base.Spec.Binary.Positive.POSITIVE_XI q -> + Core.Base.Spec.Haxint.v_HaxInt_ZERO, Core.Base.Spec.Haxint.v_HaxInt_ONE + <: + (Core.Base.Spec.Haxint.t_HaxInt & Core.Base.Spec.Haxint.t_HaxInt)) + | Core.Base.Spec.Binary.Positive.POSITIVE_XO a___ -> + let q, r:(Core.Base.Spec.Haxint.t_HaxInt & Core.Base.Spec.Haxint.t_HaxInt) = + haxint_divmod__divmod_binary a___ + (Core.Clone.f_clone #Core.Base.Spec.Binary.Positive.t_Positive + #FStar.Tactics.Typeclasses.solve + b + <: + Core.Base.Spec.Binary.Positive.t_Positive) + in + let r___:Core.Base.Spec.Haxint.t_HaxInt = haxint_double r in + if + haxint_le (Core.Base.Spec.Binary.Positive.positive_to_int (Core.Clone.f_clone #Core.Base.Spec.Binary.Positive.t_Positive + #FStar.Tactics.Typeclasses.solve + b + <: + Core.Base.Spec.Binary.Positive.t_Positive) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Clone.f_clone #Core.Base.Spec.Haxint.t_HaxInt #FStar.Tactics.Typeclasses.solve r___ + <: + Core.Base.Spec.Haxint.t_HaxInt) + then + Core.Base.Spec.Binary.Positive.positive_to_int (haxint_succ_double q + <: + Core.Base.Spec.Binary.Positive.t_Positive), + haxint_sub r___ + (Core.Base.Spec.Binary.Positive.positive_to_int b <: Core.Base.Spec.Haxint.t_HaxInt) + <: + (Core.Base.Spec.Haxint.t_HaxInt & Core.Base.Spec.Haxint.t_HaxInt) + else haxint_double q, r___ <: (Core.Base.Spec.Haxint.t_HaxInt & Core.Base.Spec.Haxint.t_HaxInt) + | Core.Base.Spec.Binary.Positive.POSITIVE_XI a___ -> + let q, r:(Core.Base.Spec.Haxint.t_HaxInt & Core.Base.Spec.Haxint.t_HaxInt) = + haxint_divmod__divmod_binary a___ + (Core.Clone.f_clone #Core.Base.Spec.Binary.Positive.t_Positive + #FStar.Tactics.Typeclasses.solve + b + <: + Core.Base.Spec.Binary.Positive.t_Positive) + in + let r___:Core.Base.Spec.Haxint.t_HaxInt = + Core.Base.Spec.Binary.Positive.positive_to_int (haxint_succ_double r + <: + Core.Base.Spec.Binary.Positive.t_Positive) + in + if + haxint_le (Core.Base.Spec.Binary.Positive.positive_to_int (Core.Clone.f_clone #Core.Base.Spec.Binary.Positive.t_Positive + #FStar.Tactics.Typeclasses.solve + b + <: + Core.Base.Spec.Binary.Positive.t_Positive) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Clone.f_clone #Core.Base.Spec.Haxint.t_HaxInt #FStar.Tactics.Typeclasses.solve r___ + <: + Core.Base.Spec.Haxint.t_HaxInt) + then + Core.Base.Spec.Binary.Positive.positive_to_int (haxint_succ_double q + <: + Core.Base.Spec.Binary.Positive.t_Positive), + haxint_sub r___ + (Core.Base.Spec.Binary.Positive.positive_to_int b <: Core.Base.Spec.Haxint.t_HaxInt) + <: + (Core.Base.Spec.Haxint.t_HaxInt & Core.Base.Spec.Haxint.t_HaxInt) + else haxint_double q, r___ <: (Core.Base.Spec.Haxint.t_HaxInt & Core.Base.Spec.Haxint.t_HaxInt) + +let haxint_divmod (a b: Core.Base.Spec.Haxint.t_HaxInt) + : (Core.Base.Spec.Haxint.t_HaxInt & Core.Base.Spec.Haxint.t_HaxInt) = + match Core.Base.Spec.Binary.Pos.match_pos a with + | Core.Base.Spec.Binary.Pos.POS_ZERO -> + Core.Base.Spec.Haxint.v_HaxInt_ZERO, Core.Base.Spec.Haxint.v_HaxInt_ZERO + <: + (Core.Base.Spec.Haxint.t_HaxInt & Core.Base.Spec.Haxint.t_HaxInt) + | Core.Base.Spec.Binary.Pos.POS_POS p -> + match Core.Base.Spec.Binary.Pos.match_pos b with + | Core.Base.Spec.Binary.Pos.POS_ZERO -> + Core.Base.Spec.Haxint.v_HaxInt_ZERO, Core.Base.Spec.Binary.Positive.positive_to_int p + <: + (Core.Base.Spec.Haxint.t_HaxInt & Core.Base.Spec.Haxint.t_HaxInt) + | Core.Base.Spec.Binary.Pos.POS_POS q -> haxint_divmod__divmod_binary p q + +let haxint_div (lhs rhs: Core.Base.Spec.Haxint.t_HaxInt) : Core.Base.Spec.Haxint.t_HaxInt = + let q, _:(Core.Base.Spec.Haxint.t_HaxInt & Core.Base.Spec.Haxint.t_HaxInt) = + haxint_divmod lhs rhs + in + q + +let haxint_mul (lhs rhs: Core.Base.Spec.Haxint.t_HaxInt) : Core.Base.Spec.Haxint.t_HaxInt = + match Core.Base.Spec.Binary.Pos.match_pos lhs with + | Core.Base.Spec.Binary.Pos.POS_ZERO -> Core.Base.Spec.Haxint.v_HaxInt_ZERO + | Core.Base.Spec.Binary.Pos.POS_POS p -> + match Core.Base.Spec.Binary.Pos.match_pos rhs with + | Core.Base.Spec.Binary.Pos.POS_ZERO -> Core.Base.Spec.Haxint.v_HaxInt_ZERO + | Core.Base.Spec.Binary.Pos.POS_POS q -> + Core.Base.Spec.Binary.Positive.positive_to_int (Core.Base.Binary.positive_mul p q + <: + Core.Base.Spec.Binary.Positive.t_Positive) + +let haxint_rem (lhs rhs: Core.Base.Spec.Haxint.t_HaxInt) : Core.Base.Spec.Haxint.t_HaxInt = + let _, r:(Core.Base.Spec.Haxint.t_HaxInt & Core.Base.Spec.Haxint.t_HaxInt) = + haxint_divmod lhs rhs + in + r + +let rec haxint_sub__sub_binary (lhs rhs: Core.Base.Spec.Binary.Positive.t_Positive) + : Core.Base.Spec.Haxint.t_HaxInt = + match Core.Base.Spec.Binary.Positive.match_positive lhs with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> Core.Base.Spec.Haxint.v_HaxInt_ZERO + | Core.Base.Spec.Binary.Positive.POSITIVE_XO p -> + (match Core.Base.Spec.Binary.Positive.match_positive rhs with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> + Core.Base.Spec.Binary.Positive.positive_to_int (Core.Base.Binary.positive_pred_double p + <: + Core.Base.Spec.Binary.Positive.t_Positive) + | Core.Base.Spec.Binary.Positive.POSITIVE_XO q -> + haxint_sub__double_mask (haxint_sub__sub_binary p q <: Core.Base.Spec.Haxint.t_HaxInt) + | Core.Base.Spec.Binary.Positive.POSITIVE_XI q -> + haxint_sub__succ_double_mask (haxint_sub__sub_carry p q <: Core.Base.Spec.Haxint.t_HaxInt)) + | Core.Base.Spec.Binary.Positive.POSITIVE_XI p -> + match Core.Base.Spec.Binary.Positive.match_positive rhs with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> + Core.Base.Spec.Binary.Positive.positive_to_int (Core.Base.Spec.Binary.Positive.xO p + <: + Core.Base.Spec.Binary.Positive.t_Positive) + | Core.Base.Spec.Binary.Positive.POSITIVE_XO q -> + haxint_sub__succ_double_mask (haxint_sub__sub_binary p q <: Core.Base.Spec.Haxint.t_HaxInt) + | Core.Base.Spec.Binary.Positive.POSITIVE_XI q -> + haxint_sub__double_mask (haxint_sub__sub_binary p q <: Core.Base.Spec.Haxint.t_HaxInt) + +and haxint_sub__sub_carry (lhs rhs: Core.Base.Spec.Binary.Positive.t_Positive) + : Core.Base.Spec.Haxint.t_HaxInt = + match Core.Base.Spec.Binary.Positive.match_positive lhs with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> Core.Base.Spec.Haxint.v_HaxInt_ZERO + | Core.Base.Spec.Binary.Positive.POSITIVE_XO p -> + (match Core.Base.Spec.Binary.Positive.match_positive rhs with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> haxint_sub__double_pred_mask p + | Core.Base.Spec.Binary.Positive.POSITIVE_XO q -> + haxint_sub__succ_double_mask (haxint_sub__sub_carry p q <: Core.Base.Spec.Haxint.t_HaxInt) + | Core.Base.Spec.Binary.Positive.POSITIVE_XI q -> + haxint_sub__double_mask (haxint_sub__sub_carry p q <: Core.Base.Spec.Haxint.t_HaxInt)) + | Core.Base.Spec.Binary.Positive.POSITIVE_XI p -> + match Core.Base.Spec.Binary.Positive.match_positive rhs with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> + Core.Base.Spec.Binary.Positive.positive_to_int (Core.Base.Binary.positive_pred_double p + <: + Core.Base.Spec.Binary.Positive.t_Positive) + | Core.Base.Spec.Binary.Positive.POSITIVE_XO q -> + haxint_sub__double_mask (haxint_sub__sub_binary p q <: Core.Base.Spec.Haxint.t_HaxInt) + | Core.Base.Spec.Binary.Positive.POSITIVE_XI q -> + haxint_sub__succ_double_mask (haxint_sub__sub_carry p q <: Core.Base.Spec.Haxint.t_HaxInt) diff --git a/proof-libs/fstar/generated_core/Core.Base.Spec.Binary.Pos.fst b/proof-libs/fstar/generated_core/Core.Base.Spec.Binary.Pos.fst new file mode 100644 index 000000000..11e9e7ee6 --- /dev/null +++ b/proof-libs/fstar/generated_core/Core.Base.Spec.Binary.Pos.fst @@ -0,0 +1,18 @@ +module Core.Base.Spec.Binary.Pos +#set-options "--fuel 0 --ifuel 1 --z3rlimit 15" +open Core +open FStar.Mul + +type t_POS = + | POS_ZERO : t_POS + | POS_POS : Core.Base.Spec.Binary.Positive.t_Positive -> t_POS + +let match_pos (s: Core.Base.Spec.Haxint.t_HaxInt) : t_POS = + if + Core.Base.Spec.Haxint.is_zero (Core.Clone.f_clone #Core.Base.Spec.Haxint.t_HaxInt + #FStar.Tactics.Typeclasses.solve + s + <: + Core.Base.Spec.Haxint.t_HaxInt) + then POS_ZERO <: t_POS + else POS_POS (Core.Base.Spec.Binary.Positive.positive_from_int s) <: t_POS diff --git a/proof-libs/fstar/generated_core/Core.Base.Spec.Binary.Positive.fst b/proof-libs/fstar/generated_core/Core.Base.Spec.Binary.Positive.fst new file mode 100644 index 000000000..7bb9bd61f --- /dev/null +++ b/proof-libs/fstar/generated_core/Core.Base.Spec.Binary.Positive.fst @@ -0,0 +1,127 @@ +module Core.Base.Spec.Binary.Positive +#set-options "--fuel 0 --ifuel 1 --z3rlimit 15" +open Core +open FStar.Mul + +type t_Positive = | Positive : Core.Base.Spec.Haxint.t_HaxInt -> t_Positive + +type t_POSITIVE = + | POSITIVE_XH : t_POSITIVE + | POSITIVE_XO : t_Positive -> t_POSITIVE + | POSITIVE_XI : t_Positive -> t_POSITIVE + +let positive_from_int (x: Core.Base.Spec.Haxint.t_HaxInt) : t_Positive = Positive x <: t_Positive + +let positive_to_int (s: t_Positive) : Core.Base.Spec.Haxint.t_HaxInt = s._0 + +let xH: t_Positive = Positive Core.Base.Spec.Haxint.v_HaxInt_ONE <: t_Positive + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl: Core.Clone.t_Clone t_Positive = + { + f_clone_pre = (fun (self: t_Positive) -> true); + f_clone_post = (fun (self: t_Positive) (out: t_Positive) -> true); + f_clone + = + fun (self: t_Positive) -> + Rust_primitives.Hax.never_to_any (Core.Panicking.panic_fmt (Core.Fmt.impl_2__new_v1 (sz 1) + (sz 0) + (let list = ["not yet implemented: specification needed"] in + FStar.Pervasives.assert_norm (Prims.eq2 (List.Tot.length list) 1); + Rust_primitives.Hax.array_of_list 1 list) + (Core.Fmt.Rt.impl_1__none () <: t_Array Core.Fmt.Rt.t_Argument (sz 0)) + <: + Core.Fmt.t_Arguments) + <: + Rust_primitives.Hax.t_Never) + } + +let match_positive__is_xH (s: t_Positive) : bool = + Rust_primitives.Hax.never_to_any (Core.Panicking.panic_fmt (Core.Fmt.impl_2__new_v1 (sz 1) + (sz 0) + (let list = ["not yet implemented: specification needed"] in + FStar.Pervasives.assert_norm (Prims.eq2 (List.Tot.length list) 1); + Rust_primitives.Hax.array_of_list 1 list) + (Core.Fmt.Rt.impl_1__none () <: t_Array Core.Fmt.Rt.t_Argument (sz 0)) + <: + Core.Fmt.t_Arguments) + <: + Rust_primitives.Hax.t_Never) + +let match_positive__is_xI (s: t_Positive) : bool = + Rust_primitives.Hax.never_to_any (Core.Panicking.panic_fmt (Core.Fmt.impl_2__new_v1 (sz 1) + (sz 0) + (let list = ["not yet implemented: specification needed"] in + FStar.Pervasives.assert_norm (Prims.eq2 (List.Tot.length list) 1); + Rust_primitives.Hax.array_of_list 1 list) + (Core.Fmt.Rt.impl_1__none () <: t_Array Core.Fmt.Rt.t_Argument (sz 0)) + <: + Core.Fmt.t_Arguments) + <: + Rust_primitives.Hax.t_Never) + +let match_positive__is_xO (s: t_Positive) : bool = + Rust_primitives.Hax.never_to_any (Core.Panicking.panic_fmt (Core.Fmt.impl_2__new_v1 (sz 1) + (sz 0) + (let list = ["not yet implemented: specification needed"] in + FStar.Pervasives.assert_norm (Prims.eq2 (List.Tot.length list) 1); + Rust_primitives.Hax.array_of_list 1 list) + (Core.Fmt.Rt.impl_1__none () <: t_Array Core.Fmt.Rt.t_Argument (sz 0)) + <: + Core.Fmt.t_Arguments) + <: + Rust_primitives.Hax.t_Never) + +let xI (s: t_Positive) : t_Positive = + Rust_primitives.Hax.never_to_any (Core.Panicking.panic_fmt (Core.Fmt.impl_2__new_v1 (sz 1) + (sz 0) + (let list = ["not yet implemented: specification needed"] in + FStar.Pervasives.assert_norm (Prims.eq2 (List.Tot.length list) 1); + Rust_primitives.Hax.array_of_list 1 list) + (Core.Fmt.Rt.impl_1__none () <: t_Array Core.Fmt.Rt.t_Argument (sz 0)) + <: + Core.Fmt.t_Arguments) + <: + Rust_primitives.Hax.t_Never) + +let xO (s: t_Positive) : t_Positive = + Rust_primitives.Hax.never_to_any (Core.Panicking.panic_fmt (Core.Fmt.impl_2__new_v1 (sz 1) + (sz 0) + (let list = ["not yet implemented: specification needed"] in + FStar.Pervasives.assert_norm (Prims.eq2 (List.Tot.length list) 1); + Rust_primitives.Hax.array_of_list 1 list) + (Core.Fmt.Rt.impl_1__none () <: t_Array Core.Fmt.Rt.t_Argument (sz 0)) + <: + Core.Fmt.t_Arguments) + <: + Rust_primitives.Hax.t_Never) + +let match_positive (s: t_Positive) : t_POSITIVE = + if + match_positive__is_xH (Core.Clone.f_clone #t_Positive #FStar.Tactics.Typeclasses.solve s + <: + t_Positive) + then POSITIVE_XH <: t_POSITIVE + else + if + match_positive__is_xO (Core.Clone.f_clone #t_Positive #FStar.Tactics.Typeclasses.solve s + <: + t_Positive) + then + POSITIVE_XO + (positive_from_int (Core.Base.Spec.Haxint.div2 (positive_to_int s + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt)) + <: + t_POSITIVE + else + POSITIVE_XI + (positive_from_int (Core.Base.Spec.Haxint.div2 (positive_to_int s + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt)) + <: + t_POSITIVE diff --git a/proof-libs/fstar/generated_core/Core.Base.Spec.Constants.fst b/proof-libs/fstar/generated_core/Core.Base.Spec.Constants.fst new file mode 100644 index 000000000..dfc0806fb --- /dev/null +++ b/proof-libs/fstar/generated_core/Core.Base.Spec.Constants.fst @@ -0,0 +1,363 @@ +module Core.Base.Spec.Constants +#set-options "--fuel 0 --ifuel 1 --z3rlimit 15" +open Core +open FStar.Mul + +let v_BITS_128_: Core.Base.Spec.Haxint.t_HaxInt = + { + Core.Base.Spec.Haxint.f_v + = + Alloc.Borrow.Cow_Borrowed + ((let list = [128uy] in + FStar.Pervasives.assert_norm (Prims.eq2 (List.Tot.length list) 1); + Rust_primitives.Hax.array_of_list 1 list) + <: + t_Slice u8) + <: + Alloc.Borrow.t_Cow (t_Slice u8) + } + <: + Core.Base.Spec.Haxint.t_HaxInt + +let v_BITS_16_: Core.Base.Spec.Haxint.t_HaxInt = + { + Core.Base.Spec.Haxint.f_v + = + Alloc.Borrow.Cow_Borrowed + ((let list = [16uy] in + FStar.Pervasives.assert_norm (Prims.eq2 (List.Tot.length list) 1); + Rust_primitives.Hax.array_of_list 1 list) + <: + t_Slice u8) + <: + Alloc.Borrow.t_Cow (t_Slice u8) + } + <: + Core.Base.Spec.Haxint.t_HaxInt + +let v_BITS_32_: Core.Base.Spec.Haxint.t_HaxInt = + { + Core.Base.Spec.Haxint.f_v + = + Alloc.Borrow.Cow_Borrowed + ((let list = [32uy] in + FStar.Pervasives.assert_norm (Prims.eq2 (List.Tot.length list) 1); + Rust_primitives.Hax.array_of_list 1 list) + <: + t_Slice u8) + <: + Alloc.Borrow.t_Cow (t_Slice u8) + } + <: + Core.Base.Spec.Haxint.t_HaxInt + +let v_BITS_64_: Core.Base.Spec.Haxint.t_HaxInt = + { + Core.Base.Spec.Haxint.f_v + = + Alloc.Borrow.Cow_Borrowed + ((let list = [64uy] in + FStar.Pervasives.assert_norm (Prims.eq2 (List.Tot.length list) 1); + Rust_primitives.Hax.array_of_list 1 list) + <: + t_Slice u8) + <: + Alloc.Borrow.t_Cow (t_Slice u8) + } + <: + Core.Base.Spec.Haxint.t_HaxInt + +let v_BITS_8_: Core.Base.Spec.Haxint.t_HaxInt = + { + Core.Base.Spec.Haxint.f_v + = + Alloc.Borrow.Cow_Borrowed + ((let list = [8uy] in + FStar.Pervasives.assert_norm (Prims.eq2 (List.Tot.length list) 1); + Rust_primitives.Hax.array_of_list 1 list) + <: + t_Slice u8) + <: + Alloc.Borrow.t_Cow (t_Slice u8) + } + <: + Core.Base.Spec.Haxint.t_HaxInt + +let v_WORDSIZE_128_: Core.Base.Spec.Haxint.t_HaxInt = + { + Core.Base.Spec.Haxint.f_v + = + Alloc.Borrow.Cow_Borrowed + ((let list = + [0uy; 0uy; 0uy; 0uy; 0uy; 0uy; 0uy; 0uy; 0uy; 0uy; 0uy; 0uy; 0uy; 0uy; 0uy; 0uy; 1uy] + in + FStar.Pervasives.assert_norm (Prims.eq2 (List.Tot.length list) 17); + Rust_primitives.Hax.array_of_list 17 list) + <: + t_Slice u8) + <: + Alloc.Borrow.t_Cow (t_Slice u8) + } + <: + Core.Base.Spec.Haxint.t_HaxInt + +let v_WORDSIZE_128_SUB_1_: Core.Base.Spec.Haxint.t_HaxInt = + { + Core.Base.Spec.Haxint.f_v + = + Alloc.Borrow.Cow_Borrowed + ((let list = + [ + 255uy; 255uy; 255uy; 255uy; 255uy; 255uy; 255uy; 255uy; 255uy; 255uy; 255uy; 255uy; + 255uy; 255uy; 255uy; 255uy + ] + in + FStar.Pervasives.assert_norm (Prims.eq2 (List.Tot.length list) 16); + Rust_primitives.Hax.array_of_list 16 list) + <: + t_Slice u8) + <: + Alloc.Borrow.t_Cow (t_Slice u8) + } + <: + Core.Base.Spec.Haxint.t_HaxInt + +let v_WORDSIZE_16_: Core.Base.Spec.Haxint.t_HaxInt = + { + Core.Base.Spec.Haxint.f_v + = + Alloc.Borrow.Cow_Borrowed + ((let list = [0uy; 0uy; 1uy] in + FStar.Pervasives.assert_norm (Prims.eq2 (List.Tot.length list) 3); + Rust_primitives.Hax.array_of_list 3 list) + <: + t_Slice u8) + <: + Alloc.Borrow.t_Cow (t_Slice u8) + } + <: + Core.Base.Spec.Haxint.t_HaxInt + +let v_NEG_WORDSIZE_32_: Core.Base.Spec.Z.t_Z = + Core.Base.Spec.Z.Z_NEG + (Core.Base.Spec.Binary.Positive.Positive v_WORDSIZE_16_ + <: + Core.Base.Spec.Binary.Positive.t_Positive) + <: + Core.Base.Spec.Z.t_Z + +let v_WORDSIZE_16_SUB_1_: Core.Base.Spec.Haxint.t_HaxInt = + { + Core.Base.Spec.Haxint.f_v + = + Alloc.Borrow.Cow_Borrowed + ((let list = [255uy; 255uy] in + FStar.Pervasives.assert_norm (Prims.eq2 (List.Tot.length list) 2); + Rust_primitives.Hax.array_of_list 2 list) + <: + t_Slice u8) + <: + Alloc.Borrow.t_Cow (t_Slice u8) + } + <: + Core.Base.Spec.Haxint.t_HaxInt + +let v_POS_WORDSIZE_32_: Core.Base.Spec.Z.t_Z = + Core.Base.Spec.Z.Z_POS + (Core.Base.Spec.Binary.Positive.Positive v_WORDSIZE_16_SUB_1_ + <: + Core.Base.Spec.Binary.Positive.t_Positive) + <: + Core.Base.Spec.Z.t_Z + +let v_WORDSIZE_32_: Core.Base.Spec.Haxint.t_HaxInt = + { + Core.Base.Spec.Haxint.f_v + = + Alloc.Borrow.Cow_Borrowed + ((let list = [0uy; 0uy; 0uy; 0uy; 1uy] in + FStar.Pervasives.assert_norm (Prims.eq2 (List.Tot.length list) 5); + Rust_primitives.Hax.array_of_list 5 list) + <: + t_Slice u8) + <: + Alloc.Borrow.t_Cow (t_Slice u8) + } + <: + Core.Base.Spec.Haxint.t_HaxInt + +let v_NEG_WORDSIZE_64_: Core.Base.Spec.Z.t_Z = + Core.Base.Spec.Z.Z_NEG + (Core.Base.Spec.Binary.Positive.Positive v_WORDSIZE_32_ + <: + Core.Base.Spec.Binary.Positive.t_Positive) + <: + Core.Base.Spec.Z.t_Z + +let v_WORDSIZE_32_SUB_1_: Core.Base.Spec.Haxint.t_HaxInt = + { + Core.Base.Spec.Haxint.f_v + = + Alloc.Borrow.Cow_Borrowed + ((let list = [255uy; 255uy; 255uy; 255uy] in + FStar.Pervasives.assert_norm (Prims.eq2 (List.Tot.length list) 4); + Rust_primitives.Hax.array_of_list 4 list) + <: + t_Slice u8) + <: + Alloc.Borrow.t_Cow (t_Slice u8) + } + <: + Core.Base.Spec.Haxint.t_HaxInt + +let v_POS_WORDSIZE_64_: Core.Base.Spec.Z.t_Z = + Core.Base.Spec.Z.Z_POS + (Core.Base.Spec.Binary.Positive.Positive v_WORDSIZE_32_SUB_1_ + <: + Core.Base.Spec.Binary.Positive.t_Positive) + <: + Core.Base.Spec.Z.t_Z + +let v_WORDSIZE_4_: Core.Base.Spec.Haxint.t_HaxInt = + { + Core.Base.Spec.Haxint.f_v + = + Alloc.Borrow.Cow_Borrowed + ((let list = [128uy] in + FStar.Pervasives.assert_norm (Prims.eq2 (List.Tot.length list) 1); + Rust_primitives.Hax.array_of_list 1 list) + <: + t_Slice u8) + <: + Alloc.Borrow.t_Cow (t_Slice u8) + } + <: + Core.Base.Spec.Haxint.t_HaxInt + +let v_NEG_WORDSIZE_8_: Core.Base.Spec.Z.t_Z = + Core.Base.Spec.Z.Z_NEG + (Core.Base.Spec.Binary.Positive.Positive v_WORDSIZE_4_ + <: + Core.Base.Spec.Binary.Positive.t_Positive) + <: + Core.Base.Spec.Z.t_Z + +let v_WORDSIZE_4_SUB_1_: Core.Base.Spec.Haxint.t_HaxInt = + { + Core.Base.Spec.Haxint.f_v + = + Alloc.Borrow.Cow_Borrowed + ((let list = [127uy] in + FStar.Pervasives.assert_norm (Prims.eq2 (List.Tot.length list) 1); + Rust_primitives.Hax.array_of_list 1 list) + <: + t_Slice u8) + <: + Alloc.Borrow.t_Cow (t_Slice u8) + } + <: + Core.Base.Spec.Haxint.t_HaxInt + +let v_POS_WORDSIZE_8_: Core.Base.Spec.Z.t_Z = + Core.Base.Spec.Z.Z_POS + (Core.Base.Spec.Binary.Positive.Positive v_WORDSIZE_4_SUB_1_ + <: + Core.Base.Spec.Binary.Positive.t_Positive) + <: + Core.Base.Spec.Z.t_Z + +let v_WORDSIZE_64_: Core.Base.Spec.Haxint.t_HaxInt = + { + Core.Base.Spec.Haxint.f_v + = + Alloc.Borrow.Cow_Borrowed + ((let list = [0uy; 0uy; 0uy; 0uy; 0uy; 0uy; 0uy; 0uy; 1uy] in + FStar.Pervasives.assert_norm (Prims.eq2 (List.Tot.length list) 9); + Rust_primitives.Hax.array_of_list 9 list) + <: + t_Slice u8) + <: + Alloc.Borrow.t_Cow (t_Slice u8) + } + <: + Core.Base.Spec.Haxint.t_HaxInt + +let v_NEG_WORDSIZE_128_: Core.Base.Spec.Z.t_Z = + Core.Base.Spec.Z.Z_NEG + (Core.Base.Spec.Binary.Positive.Positive v_WORDSIZE_64_ + <: + Core.Base.Spec.Binary.Positive.t_Positive) + <: + Core.Base.Spec.Z.t_Z + +let v_WORDSIZE_64_SUB_1_: Core.Base.Spec.Haxint.t_HaxInt = + { + Core.Base.Spec.Haxint.f_v + = + Alloc.Borrow.Cow_Borrowed + ((let list = [255uy; 255uy; 255uy; 255uy; 255uy; 255uy; 255uy; 255uy] in + FStar.Pervasives.assert_norm (Prims.eq2 (List.Tot.length list) 8); + Rust_primitives.Hax.array_of_list 8 list) + <: + t_Slice u8) + <: + Alloc.Borrow.t_Cow (t_Slice u8) + } + <: + Core.Base.Spec.Haxint.t_HaxInt + +let v_POS_WORDSIZE_128_: Core.Base.Spec.Z.t_Z = + Core.Base.Spec.Z.Z_POS + (Core.Base.Spec.Binary.Positive.Positive v_WORDSIZE_64_SUB_1_ + <: + Core.Base.Spec.Binary.Positive.t_Positive) + <: + Core.Base.Spec.Z.t_Z + +let v_WORDSIZE_8_: Core.Base.Spec.Haxint.t_HaxInt = + { + Core.Base.Spec.Haxint.f_v + = + Alloc.Borrow.Cow_Borrowed + ((let list = [0uy; 1uy] in + FStar.Pervasives.assert_norm (Prims.eq2 (List.Tot.length list) 2); + Rust_primitives.Hax.array_of_list 2 list) + <: + t_Slice u8) + <: + Alloc.Borrow.t_Cow (t_Slice u8) + } + <: + Core.Base.Spec.Haxint.t_HaxInt + +let v_NEG_WORDSIZE_16_: Core.Base.Spec.Z.t_Z = + Core.Base.Spec.Z.Z_NEG + (Core.Base.Spec.Binary.Positive.Positive v_WORDSIZE_8_ + <: + Core.Base.Spec.Binary.Positive.t_Positive) + <: + Core.Base.Spec.Z.t_Z + +let v_WORDSIZE_8_SUB_1_: Core.Base.Spec.Haxint.t_HaxInt = + { + Core.Base.Spec.Haxint.f_v + = + Alloc.Borrow.Cow_Borrowed + ((let list = [255uy] in + FStar.Pervasives.assert_norm (Prims.eq2 (List.Tot.length list) 1); + Rust_primitives.Hax.array_of_list 1 list) + <: + t_Slice u8) + <: + Alloc.Borrow.t_Cow (t_Slice u8) + } + <: + Core.Base.Spec.Haxint.t_HaxInt + +let v_POS_WORDSIZE_16_: Core.Base.Spec.Z.t_Z = + Core.Base.Spec.Z.Z_POS + (Core.Base.Spec.Binary.Positive.Positive v_WORDSIZE_8_SUB_1_ + <: + Core.Base.Spec.Binary.Positive.t_Positive) + <: + Core.Base.Spec.Z.t_Z diff --git a/proof-libs/fstar/generated_core/Core.Base.Spec.Haxint.fst b/proof-libs/fstar/generated_core/Core.Base.Spec.Haxint.fst new file mode 100644 index 000000000..905782d89 --- /dev/null +++ b/proof-libs/fstar/generated_core/Core.Base.Spec.Haxint.fst @@ -0,0 +1,98 @@ +module Core.Base.Spec.Haxint +#set-options "--fuel 0 --ifuel 1 --z3rlimit 15" +open Core +open FStar.Mul + +type t_HaxInt = { f_v:Alloc.Borrow.t_Cow (t_Slice u8) } + +let v_HaxInt_ONE: t_HaxInt = + { + f_v + = + Alloc.Borrow.Cow_Borrowed + ((let list = [1uy] in + FStar.Pervasives.assert_norm (Prims.eq2 (List.Tot.length list) 1); + Rust_primitives.Hax.array_of_list 1 list) + <: + t_Slice u8) + <: + Alloc.Borrow.t_Cow (t_Slice u8) + } + <: + t_HaxInt + +let v_HaxInt_TWO: t_HaxInt = + { + f_v + = + Alloc.Borrow.Cow_Borrowed + ((let list = [2uy] in + FStar.Pervasives.assert_norm (Prims.eq2 (List.Tot.length list) 1); + Rust_primitives.Hax.array_of_list 1 list) + <: + t_Slice u8) + <: + Alloc.Borrow.t_Cow (t_Slice u8) + } + <: + t_HaxInt + +let v_HaxInt_ZERO: t_HaxInt = + { + f_v + = + Alloc.Borrow.Cow_Borrowed + ((let list:Prims.list u8 = [] in + FStar.Pervasives.assert_norm (Prims.eq2 (List.Tot.length list) 0); + Rust_primitives.Hax.array_of_list 0 list) + <: + t_Slice u8) + <: + Alloc.Borrow.t_Cow (t_Slice u8) + } + <: + t_HaxInt + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl: Core.Clone.t_Clone t_HaxInt = + { + f_clone_pre = (fun (self: t_HaxInt) -> true); + f_clone_post = (fun (self: t_HaxInt) (out: t_HaxInt) -> true); + f_clone + = + fun (self: t_HaxInt) -> + Rust_primitives.Hax.never_to_any (Core.Panicking.panic_fmt (Core.Fmt.impl_2__new_v1 (sz 1) + (sz 0) + (let list = ["not yet implemented: specification needed"] in + FStar.Pervasives.assert_norm (Prims.eq2 (List.Tot.length list) 1); + Rust_primitives.Hax.array_of_list 1 list) + (Core.Fmt.Rt.impl_1__none () <: t_Array Core.Fmt.Rt.t_Argument (sz 0)) + <: + Core.Fmt.t_Arguments) + <: + Rust_primitives.Hax.t_Never) + } + +let div2 (s: t_HaxInt) : t_HaxInt = + Rust_primitives.Hax.never_to_any (Core.Panicking.panic_fmt (Core.Fmt.impl_2__new_v1 (sz 1) + (sz 0) + (let list = ["not yet implemented: specification needed"] in + FStar.Pervasives.assert_norm (Prims.eq2 (List.Tot.length list) 1); + Rust_primitives.Hax.array_of_list 1 list) + (Core.Fmt.Rt.impl_1__none () <: t_Array Core.Fmt.Rt.t_Argument (sz 0)) + <: + Core.Fmt.t_Arguments) + <: + Rust_primitives.Hax.t_Never) + +let is_zero (s: t_HaxInt) : bool = + Rust_primitives.Hax.never_to_any (Core.Panicking.panic_fmt (Core.Fmt.impl_2__new_v1 (sz 1) + (sz 0) + (let list = ["not yet implemented: specification needed"] in + FStar.Pervasives.assert_norm (Prims.eq2 (List.Tot.length list) 1); + Rust_primitives.Hax.array_of_list 1 list) + (Core.Fmt.Rt.impl_1__none () <: t_Array Core.Fmt.Rt.t_Argument (sz 0)) + <: + Core.Fmt.t_Arguments) + <: + Rust_primitives.Hax.t_Never) diff --git a/proof-libs/fstar/generated_core/Core.Base.Spec.Unary.fst b/proof-libs/fstar/generated_core/Core.Base.Spec.Unary.fst new file mode 100644 index 000000000..9bae9d16a --- /dev/null +++ b/proof-libs/fstar/generated_core/Core.Base.Spec.Unary.fst @@ -0,0 +1,70 @@ +module Core.Base.Spec.Unary +#set-options "--fuel 0 --ifuel 1 --z3rlimit 15" +open Core +open FStar.Mul + +type t_Unary = | Unary : Core.Base.Spec.Haxint.t_HaxInt -> t_Unary + +type t_UNARY = + | UNARY_ZERO : t_UNARY + | UNARY_SUCC : t_Unary -> t_UNARY + +let unary_from_int (x: Core.Base.Spec.Haxint.t_HaxInt) : t_Unary = Unary x <: t_Unary + +let unary_to_int (s: t_Unary) : Core.Base.Spec.Haxint.t_HaxInt = s._0 + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl: Core.Clone.t_Clone t_Unary = + { + f_clone_pre = (fun (self: t_Unary) -> true); + f_clone_post = (fun (self: t_Unary) (out: t_Unary) -> true); + f_clone + = + fun (self: t_Unary) -> + Rust_primitives.Hax.never_to_any (Core.Panicking.panic_fmt (Core.Fmt.impl_2__new_v1 (sz 1) + (sz 0) + (let list = ["not yet implemented: specification needed"] in + FStar.Pervasives.assert_norm (Prims.eq2 (List.Tot.length list) 1); + Rust_primitives.Hax.array_of_list 1 list) + (Core.Fmt.Rt.impl_1__none () <: t_Array Core.Fmt.Rt.t_Argument (sz 0)) + <: + Core.Fmt.t_Arguments) + <: + Rust_primitives.Hax.t_Never) + } + +let pred (x: t_Unary) : t_Unary = + Rust_primitives.Hax.never_to_any (Core.Panicking.panic_fmt (Core.Fmt.impl_2__new_v1 (sz 1) + (sz 0) + (let list = ["not yet implemented: specification needed"] in + FStar.Pervasives.assert_norm (Prims.eq2 (List.Tot.length list) 1); + Rust_primitives.Hax.array_of_list 1 list) + (Core.Fmt.Rt.impl_1__none () <: t_Array Core.Fmt.Rt.t_Argument (sz 0)) + <: + Core.Fmt.t_Arguments) + <: + Rust_primitives.Hax.t_Never) + +let match_unary (s: t_Unary) : t_UNARY = + if + Core.Base.Spec.Haxint.is_zero (unary_to_int (Core.Clone.f_clone #t_Unary + #FStar.Tactics.Typeclasses.solve + s + <: + t_Unary) + <: + Core.Base.Spec.Haxint.t_HaxInt) + then UNARY_ZERO <: t_UNARY + else UNARY_SUCC (pred s) <: t_UNARY + +let succ (x: t_Unary) : t_Unary = + Rust_primitives.Hax.never_to_any (Core.Panicking.panic_fmt (Core.Fmt.impl_2__new_v1 (sz 1) + (sz 0) + (let list = ["not yet implemented: specification needed"] in + FStar.Pervasives.assert_norm (Prims.eq2 (List.Tot.length list) 1); + Rust_primitives.Hax.array_of_list 1 list) + (Core.Fmt.Rt.impl_1__none () <: t_Array Core.Fmt.Rt.t_Argument (sz 0)) + <: + Core.Fmt.t_Arguments) + <: + Rust_primitives.Hax.t_Never) diff --git a/proof-libs/fstar/generated_core/Core.Base.Spec.Z.fst b/proof-libs/fstar/generated_core/Core.Base.Spec.Z.fst new file mode 100644 index 000000000..c7c717bdf --- /dev/null +++ b/proof-libs/fstar/generated_core/Core.Base.Spec.Z.fst @@ -0,0 +1,19 @@ +module Core.Base.Spec.Z +#set-options "--fuel 0 --ifuel 1 --z3rlimit 15" +open Core +open FStar.Mul + +type t_Z = + | Z_NEG : Core.Base.Spec.Binary.Positive.t_Positive -> t_Z + | Z_ZERO : t_Z + | Z_POS : Core.Base.Spec.Binary.Positive.t_Positive -> t_Z + +let v_Z_ONE: t_Z = Z_POS Core.Base.Spec.Binary.Positive.xH <: t_Z + +let v_Z_TWO: t_Z = + Z_POS + (Core.Base.Spec.Binary.Positive.Positive Core.Base.Spec.Haxint.v_HaxInt_TWO + <: + Core.Base.Spec.Binary.Positive.t_Positive) + <: + t_Z diff --git a/proof-libs/fstar/generated_core/Core.Base.Z.fst b/proof-libs/fstar/generated_core/Core.Base.Z.fst new file mode 100644 index 000000000..2ce8b863c --- /dev/null +++ b/proof-libs/fstar/generated_core/Core.Base.Z.fst @@ -0,0 +1,553 @@ +module Core.Base.Z +#set-options "--fuel 0 --ifuel 1 --z3rlimit 15" +open Core +open FStar.Mul + +let z_neg (x: Core.Base.Spec.Z.t_Z) : Core.Base.Spec.Z.t_Z = + match x with + | Core.Base.Spec.Z.Z_NEG p -> Core.Base.Spec.Z.Z_POS p <: Core.Base.Spec.Z.t_Z + | Core.Base.Spec.Z.Z_ZERO -> Core.Base.Spec.Z.Z_ZERO <: Core.Base.Spec.Z.t_Z + | Core.Base.Spec.Z.Z_POS p -> Core.Base.Spec.Z.Z_NEG p <: Core.Base.Spec.Z.t_Z + +let z_of_n (x: Core.Base.Spec.Binary.Pos.t_POS) : Core.Base.Spec.Z.t_Z = + match x with + | Core.Base.Spec.Binary.Pos.POS_ZERO -> Core.Base.Spec.Z.Z_ZERO <: Core.Base.Spec.Z.t_Z + | Core.Base.Spec.Binary.Pos.POS_POS p -> Core.Base.Spec.Z.Z_POS p <: Core.Base.Spec.Z.t_Z + +let haxint_ldiff__n_double (x: Core.Base.Spec.Binary.Pos.t_POS) : Core.Base.Spec.Binary.Pos.t_POS = + match x with + | Core.Base.Spec.Binary.Pos.POS_ZERO -> + Core.Base.Spec.Binary.Pos.POS_ZERO <: Core.Base.Spec.Binary.Pos.t_POS + | Core.Base.Spec.Binary.Pos.POS_POS p -> + Core.Base.Spec.Binary.Pos.POS_POS (Core.Base.Spec.Binary.Positive.xO p) + <: + Core.Base.Spec.Binary.Pos.t_POS + +let haxint_ldiff__n_succ_double (x: Core.Base.Spec.Binary.Pos.t_POS) + : Core.Base.Spec.Binary.Pos.t_POS = + match x with + | Core.Base.Spec.Binary.Pos.POS_ZERO -> + Core.Base.Spec.Binary.Pos.POS_POS Core.Base.Spec.Binary.Positive.xH + <: + Core.Base.Spec.Binary.Pos.t_POS + | Core.Base.Spec.Binary.Pos.POS_POS p -> + Core.Base.Spec.Binary.Pos.POS_POS (Core.Base.Spec.Binary.Positive.xI p) + <: + Core.Base.Spec.Binary.Pos.t_POS + +let n_succ (x: Core.Base.Spec.Binary.Pos.t_POS) : Core.Base.Spec.Binary.Positive.t_Positive = + match x with + | Core.Base.Spec.Binary.Pos.POS_ZERO -> Core.Base.Spec.Binary.Positive.xH + | Core.Base.Spec.Binary.Pos.POS_POS p -> + Core.Base.Spec.Binary.Positive.positive_from_int (Core.Base.Spec.Unary.unary_to_int (Core.Base.Spec.Unary.succ + (Core.Base.Spec.Unary.unary_from_int (Core.Base.Spec.Binary.Positive.positive_to_int p + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Unary.t_Unary) + <: + Core.Base.Spec.Unary.t_Unary) + <: + Core.Base.Spec.Haxint.t_HaxInt) + +let z_add__z_double (s: Core.Base.Spec.Z.t_Z) : Core.Base.Spec.Z.t_Z = + match s with + | Core.Base.Spec.Z.Z_ZERO -> Core.Base.Spec.Z.Z_ZERO <: Core.Base.Spec.Z.t_Z + | Core.Base.Spec.Z.Z_POS p -> + Core.Base.Spec.Z.Z_POS (Core.Base.Spec.Binary.Positive.xO p) <: Core.Base.Spec.Z.t_Z + | Core.Base.Spec.Z.Z_NEG p -> + Core.Base.Spec.Z.Z_NEG (Core.Base.Spec.Binary.Positive.xO p) <: Core.Base.Spec.Z.t_Z + +let rec haxint_ldiff__positive_ldiff (lhs rhs: Core.Base.Spec.Binary.Positive.t_Positive) + : Core.Base.Spec.Binary.Pos.t_POS = + match Core.Base.Spec.Binary.Positive.match_positive lhs with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> + (match Core.Base.Spec.Binary.Positive.match_positive rhs with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> + Core.Base.Spec.Binary.Pos.POS_ZERO <: Core.Base.Spec.Binary.Pos.t_POS + | Core.Base.Spec.Binary.Positive.POSITIVE_XO _ -> + Core.Base.Spec.Binary.Pos.POS_POS Core.Base.Spec.Binary.Positive.xH + <: + Core.Base.Spec.Binary.Pos.t_POS + | Core.Base.Spec.Binary.Positive.POSITIVE_XI _ -> + Core.Base.Spec.Binary.Pos.POS_ZERO <: Core.Base.Spec.Binary.Pos.t_POS) + | Core.Base.Spec.Binary.Positive.POSITIVE_XO p -> + (match Core.Base.Spec.Binary.Positive.match_positive rhs with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> + Core.Base.Spec.Binary.Pos.POS_POS (Core.Base.Spec.Binary.Positive.xO p) + <: + Core.Base.Spec.Binary.Pos.t_POS + | Core.Base.Spec.Binary.Positive.POSITIVE_XO q -> + haxint_ldiff__n_double (haxint_ldiff__positive_ldiff p q <: Core.Base.Spec.Binary.Pos.t_POS) + | Core.Base.Spec.Binary.Positive.POSITIVE_XI q -> + haxint_ldiff__n_double (haxint_ldiff__positive_ldiff p q <: Core.Base.Spec.Binary.Pos.t_POS) + ) + | Core.Base.Spec.Binary.Positive.POSITIVE_XI p -> + match Core.Base.Spec.Binary.Positive.match_positive rhs with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> + Core.Base.Spec.Binary.Pos.POS_POS (Core.Base.Spec.Binary.Positive.xO p) + <: + Core.Base.Spec.Binary.Pos.t_POS + | Core.Base.Spec.Binary.Positive.POSITIVE_XO q -> + haxint_ldiff__n_succ_double (haxint_ldiff__positive_ldiff p q + <: + Core.Base.Spec.Binary.Pos.t_POS) + | Core.Base.Spec.Binary.Positive.POSITIVE_XI q -> + haxint_ldiff__n_double (haxint_ldiff__positive_ldiff p q <: Core.Base.Spec.Binary.Pos.t_POS) + +let haxint_ldiff (lhs rhs: Core.Base.Spec.Binary.Pos.t_POS) : Core.Base.Spec.Binary.Pos.t_POS = + match lhs with + | Core.Base.Spec.Binary.Pos.POS_ZERO -> + Core.Base.Spec.Binary.Pos.POS_ZERO <: Core.Base.Spec.Binary.Pos.t_POS + | Core.Base.Spec.Binary.Pos.POS_POS p -> + match rhs with + | Core.Base.Spec.Binary.Pos.POS_ZERO -> + Core.Base.Spec.Binary.Pos.POS_POS p <: Core.Base.Spec.Binary.Pos.t_POS + | Core.Base.Spec.Binary.Pos.POS_POS q -> haxint_ldiff__positive_ldiff p q + +let positive_pred_N (x: Core.Base.Spec.Binary.Positive.t_Positive) : Core.Base.Spec.Binary.Pos.t_POS = + match Core.Base.Spec.Binary.Positive.match_positive x with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> + Core.Base.Spec.Binary.Pos.POS_ZERO <: Core.Base.Spec.Binary.Pos.t_POS + | Core.Base.Spec.Binary.Positive.POSITIVE_XI p -> + Core.Base.Spec.Binary.Pos.POS_POS (Core.Base.Spec.Binary.Positive.xO p) + <: + Core.Base.Spec.Binary.Pos.t_POS + | Core.Base.Spec.Binary.Positive.POSITIVE_XO p -> + Core.Base.Spec.Binary.Pos.POS_POS (Core.Base.Binary.positive_pred_double p) + <: + Core.Base.Spec.Binary.Pos.t_POS + +let z_add__z_pred_double (s: Core.Base.Spec.Z.t_Z) : Core.Base.Spec.Z.t_Z = + match s with + | Core.Base.Spec.Z.Z_ZERO -> + Core.Base.Spec.Z.Z_NEG Core.Base.Spec.Binary.Positive.xH <: Core.Base.Spec.Z.t_Z + | Core.Base.Spec.Z.Z_POS p -> + Core.Base.Spec.Z.Z_POS (Core.Base.Binary.positive_pred_double p) <: Core.Base.Spec.Z.t_Z + | Core.Base.Spec.Z.Z_NEG p -> + Core.Base.Spec.Z.Z_NEG (Core.Base.Spec.Binary.Positive.xI p) <: Core.Base.Spec.Z.t_Z + +let z_add__z_succ_double (s: Core.Base.Spec.Z.t_Z) : Core.Base.Spec.Z.t_Z = + match s with + | Core.Base.Spec.Z.Z_ZERO -> + Core.Base.Spec.Z.Z_POS Core.Base.Spec.Binary.Positive.xH <: Core.Base.Spec.Z.t_Z + | Core.Base.Spec.Z.Z_POS p -> + Core.Base.Spec.Z.Z_POS (Core.Base.Spec.Binary.Positive.xI p) <: Core.Base.Spec.Z.t_Z + | Core.Base.Spec.Z.Z_NEG p -> + Core.Base.Spec.Z.Z_NEG (Core.Base.Binary.positive_pred_double p) <: Core.Base.Spec.Z.t_Z + +let z_bitand__n_or (lhs rhs: Core.Base.Spec.Binary.Pos.t_POS) : Core.Base.Spec.Binary.Pos.t_POS = + match lhs with + | Core.Base.Spec.Binary.Pos.POS_ZERO -> rhs + | Core.Base.Spec.Binary.Pos.POS_POS p -> + match rhs with + | Core.Base.Spec.Binary.Pos.POS_ZERO -> + Core.Base.Spec.Binary.Pos.POS_POS p <: Core.Base.Spec.Binary.Pos.t_POS + | Core.Base.Spec.Binary.Pos.POS_POS q -> + Core.Base.Spec.Binary.Pos.POS_POS (Core.Base.Pos.bitor_binary p q) + <: + Core.Base.Spec.Binary.Pos.t_POS + +let z_bitand (lhs rhs: Core.Base.Spec.Z.t_Z) : Core.Base.Spec.Z.t_Z = + match lhs with + | Core.Base.Spec.Z.Z_ZERO -> Core.Base.Spec.Z.Z_ZERO <: Core.Base.Spec.Z.t_Z + | Core.Base.Spec.Z.Z_POS a -> + (match rhs with + | Core.Base.Spec.Z.Z_ZERO -> Core.Base.Spec.Z.Z_ZERO <: Core.Base.Spec.Z.t_Z + | Core.Base.Spec.Z.Z_POS b -> + z_of_n (Core.Base.Spec.Binary.Pos.match_pos (Core.Base.Pos.bitand_binary a b + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Binary.Pos.t_POS) + | Core.Base.Spec.Z.Z_NEG b -> + z_of_n (haxint_ldiff (Core.Base.Spec.Binary.Pos.POS_POS a <: Core.Base.Spec.Binary.Pos.t_POS + ) + (positive_pred_N b <: Core.Base.Spec.Binary.Pos.t_POS) + <: + Core.Base.Spec.Binary.Pos.t_POS)) + | Core.Base.Spec.Z.Z_NEG a -> + match rhs with + | Core.Base.Spec.Z.Z_ZERO -> Core.Base.Spec.Z.Z_ZERO <: Core.Base.Spec.Z.t_Z + | Core.Base.Spec.Z.Z_POS b -> + z_of_n (haxint_ldiff (Core.Base.Spec.Binary.Pos.POS_POS b <: Core.Base.Spec.Binary.Pos.t_POS) + (positive_pred_N a <: Core.Base.Spec.Binary.Pos.t_POS) + <: + Core.Base.Spec.Binary.Pos.t_POS) + | Core.Base.Spec.Z.Z_NEG b -> + Core.Base.Spec.Z.Z_NEG + (n_succ (z_bitand__n_or (positive_pred_N a <: Core.Base.Spec.Binary.Pos.t_POS) + (positive_pred_N b <: Core.Base.Spec.Binary.Pos.t_POS) + <: + Core.Base.Spec.Binary.Pos.t_POS)) + <: + Core.Base.Spec.Z.t_Z + +let z_bitor__n_and (lhs rhs: Core.Base.Spec.Binary.Pos.t_POS) : Core.Base.Spec.Binary.Pos.t_POS = + match lhs with + | Core.Base.Spec.Binary.Pos.POS_ZERO -> + Core.Base.Spec.Binary.Pos.POS_ZERO <: Core.Base.Spec.Binary.Pos.t_POS + | Core.Base.Spec.Binary.Pos.POS_POS p -> + match rhs with + | Core.Base.Spec.Binary.Pos.POS_ZERO -> + Core.Base.Spec.Binary.Pos.POS_ZERO <: Core.Base.Spec.Binary.Pos.t_POS + | Core.Base.Spec.Binary.Pos.POS_POS q -> + Core.Base.Spec.Binary.Pos.match_pos (Core.Base.Pos.bitand_binary p q + <: + Core.Base.Spec.Haxint.t_HaxInt) + +let z_bitor (lhs rhs: Core.Base.Spec.Z.t_Z) : Core.Base.Spec.Z.t_Z = + match lhs with + | Core.Base.Spec.Z.Z_ZERO -> rhs + | Core.Base.Spec.Z.Z_POS x -> + (match rhs with + | Core.Base.Spec.Z.Z_ZERO -> Core.Base.Spec.Z.Z_POS x <: Core.Base.Spec.Z.t_Z + | Core.Base.Spec.Z.Z_POS y -> + Core.Base.Spec.Z.Z_POS (Core.Base.Pos.bitor_binary x y) <: Core.Base.Spec.Z.t_Z + | Core.Base.Spec.Z.Z_NEG y -> + Core.Base.Spec.Z.Z_NEG + (n_succ (haxint_ldiff (positive_pred_N y <: Core.Base.Spec.Binary.Pos.t_POS) + (Core.Base.Spec.Binary.Pos.POS_POS x <: Core.Base.Spec.Binary.Pos.t_POS) + <: + Core.Base.Spec.Binary.Pos.t_POS)) + <: + Core.Base.Spec.Z.t_Z) + | Core.Base.Spec.Z.Z_NEG x -> + match rhs with + | Core.Base.Spec.Z.Z_ZERO -> Core.Base.Spec.Z.Z_NEG x <: Core.Base.Spec.Z.t_Z + | Core.Base.Spec.Z.Z_POS y -> + Core.Base.Spec.Z.Z_NEG + (n_succ (haxint_ldiff (positive_pred_N x <: Core.Base.Spec.Binary.Pos.t_POS) + (Core.Base.Spec.Binary.Pos.POS_POS y <: Core.Base.Spec.Binary.Pos.t_POS) + <: + Core.Base.Spec.Binary.Pos.t_POS)) + <: + Core.Base.Spec.Z.t_Z + | Core.Base.Spec.Z.Z_NEG y -> + Core.Base.Spec.Z.Z_NEG + (n_succ (z_bitor__n_and (positive_pred_N x <: Core.Base.Spec.Binary.Pos.t_POS) + (positive_pred_N y <: Core.Base.Spec.Binary.Pos.t_POS) + <: + Core.Base.Spec.Binary.Pos.t_POS)) + <: + Core.Base.Spec.Z.t_Z + +let z_bitxor__n_xor (lhs rhs: Core.Base.Spec.Binary.Pos.t_POS) : Core.Base.Spec.Binary.Pos.t_POS = + match lhs with + | Core.Base.Spec.Binary.Pos.POS_ZERO -> rhs + | Core.Base.Spec.Binary.Pos.POS_POS p -> + match rhs with + | Core.Base.Spec.Binary.Pos.POS_ZERO -> + Core.Base.Spec.Binary.Pos.POS_POS p <: Core.Base.Spec.Binary.Pos.t_POS + | Core.Base.Spec.Binary.Pos.POS_POS q -> + Core.Base.Spec.Binary.Pos.match_pos (Core.Base.Pos.bitxor_binary p q + <: + Core.Base.Spec.Haxint.t_HaxInt) + +let z_bitxor (lhs rhs: Core.Base.Spec.Z.t_Z) : Core.Base.Spec.Z.t_Z = + match lhs with + | Core.Base.Spec.Z.Z_ZERO -> rhs + | Core.Base.Spec.Z.Z_POS a -> + (match rhs with + | Core.Base.Spec.Z.Z_ZERO -> Core.Base.Spec.Z.Z_POS a <: Core.Base.Spec.Z.t_Z + | Core.Base.Spec.Z.Z_POS b -> + z_of_n (Core.Base.Spec.Binary.Pos.match_pos (Core.Base.Pos.bitxor_binary a b + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Binary.Pos.t_POS) + | Core.Base.Spec.Z.Z_NEG b -> + Core.Base.Spec.Z.Z_NEG + (n_succ (z_bitxor__n_xor (Core.Base.Spec.Binary.Pos.POS_POS a + <: + Core.Base.Spec.Binary.Pos.t_POS) + (positive_pred_N b <: Core.Base.Spec.Binary.Pos.t_POS) + <: + Core.Base.Spec.Binary.Pos.t_POS)) + <: + Core.Base.Spec.Z.t_Z) + | Core.Base.Spec.Z.Z_NEG a -> + match rhs with + | Core.Base.Spec.Z.Z_ZERO -> Core.Base.Spec.Z.Z_NEG a <: Core.Base.Spec.Z.t_Z + | Core.Base.Spec.Z.Z_POS b -> + Core.Base.Spec.Z.Z_NEG + (n_succ (z_bitxor__n_xor (positive_pred_N a <: Core.Base.Spec.Binary.Pos.t_POS) + (Core.Base.Spec.Binary.Pos.POS_POS b <: Core.Base.Spec.Binary.Pos.t_POS) + <: + Core.Base.Spec.Binary.Pos.t_POS)) + <: + Core.Base.Spec.Z.t_Z + | Core.Base.Spec.Z.Z_NEG b -> + z_of_n (z_bitxor__n_xor (positive_pred_N a <: Core.Base.Spec.Binary.Pos.t_POS) + (positive_pred_N b <: Core.Base.Spec.Binary.Pos.t_POS) + <: + Core.Base.Spec.Binary.Pos.t_POS) + +let z_cmp (lhs rhs: Core.Base.Spec.Z.t_Z) : Core.Cmp.t_Ordering = + match lhs with + | Core.Base.Spec.Z.Z_NEG p -> + (match rhs with + | Core.Base.Spec.Z.Z_NEG q -> + (match Core.Base.Binary.positive_cmp p q with + | Core.Cmp.Ordering_Equal -> Core.Cmp.Ordering_Equal <: Core.Cmp.t_Ordering + | Core.Cmp.Ordering_Less -> Core.Cmp.Ordering_Greater <: Core.Cmp.t_Ordering + | Core.Cmp.Ordering_Greater -> Core.Cmp.Ordering_Less <: Core.Cmp.t_Ordering) + | _ -> Core.Cmp.Ordering_Less <: Core.Cmp.t_Ordering) + | Core.Base.Spec.Z.Z_ZERO -> + (match rhs with + | Core.Base.Spec.Z.Z_ZERO -> Core.Cmp.Ordering_Equal <: Core.Cmp.t_Ordering + | Core.Base.Spec.Z.Z_POS _ -> Core.Cmp.Ordering_Less <: Core.Cmp.t_Ordering + | Core.Base.Spec.Z.Z_NEG _ -> Core.Cmp.Ordering_Greater <: Core.Cmp.t_Ordering) + | Core.Base.Spec.Z.Z_POS p -> + match rhs with + | Core.Base.Spec.Z.Z_POS q -> Core.Base.Binary.positive_cmp p q + | _ -> Core.Cmp.Ordering_Greater <: Core.Cmp.t_Ordering + +let z_le (lhs rhs: Core.Base.Spec.Z.t_Z) : bool = + match Core.Option.Option_Some (z_cmp lhs rhs) <: Core.Option.t_Option Core.Cmp.t_Ordering with + | Core.Option.Option_Some (Core.Cmp.Ordering_Less ) + | Core.Option.Option_Some (Core.Cmp.Ordering_Equal ) -> true + | _ -> false + +let z_lt (lhs rhs: Core.Base.Spec.Z.t_Z) : bool = + match Core.Option.Option_Some (z_cmp lhs rhs) <: Core.Option.t_Option Core.Cmp.t_Ordering with + | Core.Option.Option_Some (Core.Cmp.Ordering_Less ) -> true + | _ -> false + +let z_shl (lhs rhs: Core.Base.Spec.Z.t_Z) : Core.Base.Spec.Z.t_Z = + match rhs with + | Core.Base.Spec.Z.Z_ZERO -> lhs + | Core.Base.Spec.Z.Z_POS p -> + (match lhs with + | Core.Base.Spec.Z.Z_ZERO -> Core.Base.Spec.Z.Z_ZERO <: Core.Base.Spec.Z.t_Z + | Core.Base.Spec.Z.Z_POS q -> + z_of_n (Core.Base.Spec.Binary.Pos.match_pos (Core.Base.Pos.haxint_shl (Core.Base.Spec.Binary.Positive.positive_to_int + q + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base.Spec.Binary.Positive.positive_to_int p + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Binary.Pos.t_POS) + | Core.Base.Spec.Z.Z_NEG q -> + z_neg (z_of_n (Core.Base.Spec.Binary.Pos.match_pos (Core.Base.Pos.haxint_shl (Core.Base.Spec.Binary.Positive.positive_to_int + q + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base.Spec.Binary.Positive.positive_to_int p + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Binary.Pos.t_POS) + <: + Core.Base.Spec.Z.t_Z)) + | Core.Base.Spec.Z.Z_NEG p -> + match lhs with + | Core.Base.Spec.Z.Z_ZERO -> Core.Base.Spec.Z.Z_ZERO <: Core.Base.Spec.Z.t_Z + | Core.Base.Spec.Z.Z_POS q -> + z_of_n (Core.Base.Spec.Binary.Pos.match_pos (Core.Base.Pos.haxint_shr (Core.Base.Spec.Binary.Positive.positive_to_int + q + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base.Spec.Binary.Positive.positive_to_int p <: Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Binary.Pos.t_POS) + | Core.Base.Spec.Z.Z_NEG q -> + z_neg (z_of_n (Core.Base.Spec.Binary.Pos.match_pos (Core.Base.Pos.haxint_shr (Core.Base.Spec.Binary.Positive.positive_to_int + q + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base.Spec.Binary.Positive.positive_to_int p + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Binary.Pos.t_POS) + <: + Core.Base.Spec.Z.t_Z) + +let z_shr (lhs rhs: Core.Base.Spec.Z.t_Z) : Core.Base.Spec.Z.t_Z = + z_shl lhs (z_neg rhs <: Core.Base.Spec.Z.t_Z) + +let rec z_add__pos_z_sub (x y: Core.Base.Spec.Binary.Positive.t_Positive) : Core.Base.Spec.Z.t_Z = + match Core.Base.Spec.Binary.Positive.match_positive x with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> + (match Core.Base.Spec.Binary.Positive.match_positive y with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> + Core.Base.Spec.Z.Z_ZERO <: Core.Base.Spec.Z.t_Z + | Core.Base.Spec.Binary.Positive.POSITIVE_XO q -> + Core.Base.Spec.Z.Z_NEG (Core.Base.Binary.positive_pred_double q) <: Core.Base.Spec.Z.t_Z + | Core.Base.Spec.Binary.Positive.POSITIVE_XI q -> + Core.Base.Spec.Z.Z_NEG (Core.Base.Spec.Binary.Positive.xO q) <: Core.Base.Spec.Z.t_Z) + | Core.Base.Spec.Binary.Positive.POSITIVE_XO p -> + (match Core.Base.Spec.Binary.Positive.match_positive y with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> + Core.Base.Spec.Z.Z_POS (Core.Base.Binary.positive_pred_double p) <: Core.Base.Spec.Z.t_Z + | Core.Base.Spec.Binary.Positive.POSITIVE_XO q -> + z_add__z_double (z_add__pos_z_sub p q <: Core.Base.Spec.Z.t_Z) + | Core.Base.Spec.Binary.Positive.POSITIVE_XI q -> + z_add__z_pred_double (z_add__pos_z_sub p q <: Core.Base.Spec.Z.t_Z)) + | Core.Base.Spec.Binary.Positive.POSITIVE_XI p -> + match Core.Base.Spec.Binary.Positive.match_positive y with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> + Core.Base.Spec.Z.Z_POS (Core.Base.Spec.Binary.Positive.xO p) <: Core.Base.Spec.Z.t_Z + | Core.Base.Spec.Binary.Positive.POSITIVE_XO q -> + z_add__z_succ_double (z_add__pos_z_sub p q <: Core.Base.Spec.Z.t_Z) + | Core.Base.Spec.Binary.Positive.POSITIVE_XI q -> + z_add__z_double (z_add__pos_z_sub p q <: Core.Base.Spec.Z.t_Z) + +let z_add (lhs rhs: Core.Base.Spec.Z.t_Z) : Core.Base.Spec.Z.t_Z = + match lhs with + | Core.Base.Spec.Z.Z_NEG p -> + (match rhs with + | Core.Base.Spec.Z.Z_NEG q -> + Core.Base.Spec.Z.Z_NEG (Core.Base.Binary.positive_add p q) <: Core.Base.Spec.Z.t_Z + | Core.Base.Spec.Z.Z_ZERO -> Core.Base.Spec.Z.Z_NEG p <: Core.Base.Spec.Z.t_Z + | Core.Base.Spec.Z.Z_POS q -> z_add__pos_z_sub q p) + | Core.Base.Spec.Z.Z_ZERO -> rhs + | Core.Base.Spec.Z.Z_POS p -> + match rhs with + | Core.Base.Spec.Z.Z_NEG q -> z_add__pos_z_sub p q + | Core.Base.Spec.Z.Z_ZERO -> Core.Base.Spec.Z.Z_POS p <: Core.Base.Spec.Z.t_Z + | Core.Base.Spec.Z.Z_POS q -> + Core.Base.Spec.Z.Z_POS (Core.Base.Binary.positive_add p q) <: Core.Base.Spec.Z.t_Z + +let z_sub (lhs rhs: Core.Base.Spec.Z.t_Z) : Core.Base.Spec.Z.t_Z = + z_add lhs (z_neg rhs <: Core.Base.Spec.Z.t_Z) + +let z_mul (lhs rhs: Core.Base.Spec.Z.t_Z) : Core.Base.Spec.Z.t_Z = + match lhs with + | Core.Base.Spec.Z.Z_NEG p -> + (match rhs with + | Core.Base.Spec.Z.Z_NEG q -> + Core.Base.Spec.Z.Z_POS (Core.Base.Binary.positive_mul p q) <: Core.Base.Spec.Z.t_Z + | Core.Base.Spec.Z.Z_ZERO -> Core.Base.Spec.Z.Z_ZERO <: Core.Base.Spec.Z.t_Z + | Core.Base.Spec.Z.Z_POS q -> + Core.Base.Spec.Z.Z_NEG (Core.Base.Binary.positive_mul p q) <: Core.Base.Spec.Z.t_Z) + | Core.Base.Spec.Z.Z_ZERO -> Core.Base.Spec.Z.Z_ZERO <: Core.Base.Spec.Z.t_Z + | Core.Base.Spec.Z.Z_POS p -> + match rhs with + | Core.Base.Spec.Z.Z_NEG q -> + Core.Base.Spec.Z.Z_NEG (Core.Base.Binary.positive_mul p q) <: Core.Base.Spec.Z.t_Z + | Core.Base.Spec.Z.Z_ZERO -> Core.Base.Spec.Z.Z_ZERO <: Core.Base.Spec.Z.t_Z + | Core.Base.Spec.Z.Z_POS q -> + Core.Base.Spec.Z.Z_POS (Core.Base.Binary.positive_mul p q) <: Core.Base.Spec.Z.t_Z + +let rec pos_div_eucl (a: Core.Base.Spec.Binary.Positive.t_Positive) (b: Core.Base.Spec.Z.t_Z) + : (Core.Base.Spec.Z.t_Z & Core.Base.Spec.Z.t_Z) = + match Core.Base.Spec.Binary.Positive.match_positive a with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> + if + z_le Core.Base.Spec.Z.v_Z_TWO + (Core.Clone.f_clone #Core.Base.Spec.Z.t_Z #FStar.Tactics.Typeclasses.solve b + <: + Core.Base.Spec.Z.t_Z) + then + (Core.Base.Spec.Z.Z_ZERO <: Core.Base.Spec.Z.t_Z), Core.Base.Spec.Z.v_Z_ONE + <: + (Core.Base.Spec.Z.t_Z & Core.Base.Spec.Z.t_Z) + else + Core.Base.Spec.Z.v_Z_ONE, (Core.Base.Spec.Z.Z_ZERO <: Core.Base.Spec.Z.t_Z) + <: + (Core.Base.Spec.Z.t_Z & Core.Base.Spec.Z.t_Z) + | Core.Base.Spec.Binary.Positive.POSITIVE_XO p -> + let q, r:(Core.Base.Spec.Z.t_Z & Core.Base.Spec.Z.t_Z) = + pos_div_eucl p + (Core.Clone.f_clone #Core.Base.Spec.Z.t_Z #FStar.Tactics.Typeclasses.solve b + <: + Core.Base.Spec.Z.t_Z) + in + let r___:Core.Base.Spec.Z.t_Z = z_mul Core.Base.Spec.Z.v_Z_TWO r in + if + z_lt (Core.Clone.f_clone #Core.Base.Spec.Z.t_Z #FStar.Tactics.Typeclasses.solve r___ + <: + Core.Base.Spec.Z.t_Z) + (Core.Clone.f_clone #Core.Base.Spec.Z.t_Z #FStar.Tactics.Typeclasses.solve b + <: + Core.Base.Spec.Z.t_Z) + then z_mul Core.Base.Spec.Z.v_Z_TWO q, r___ <: (Core.Base.Spec.Z.t_Z & Core.Base.Spec.Z.t_Z) + else + z_add (z_mul Core.Base.Spec.Z.v_Z_TWO q <: Core.Base.Spec.Z.t_Z) Core.Base.Spec.Z.v_Z_ONE, + z_sub r___ b + <: + (Core.Base.Spec.Z.t_Z & Core.Base.Spec.Z.t_Z) + | Core.Base.Spec.Binary.Positive.POSITIVE_XI p -> + let q, r:(Core.Base.Spec.Z.t_Z & Core.Base.Spec.Z.t_Z) = + pos_div_eucl p + (Core.Clone.f_clone #Core.Base.Spec.Z.t_Z #FStar.Tactics.Typeclasses.solve b + <: + Core.Base.Spec.Z.t_Z) + in + let r___:Core.Base.Spec.Z.t_Z = + z_add (z_mul Core.Base.Spec.Z.v_Z_TWO r <: Core.Base.Spec.Z.t_Z) Core.Base.Spec.Z.v_Z_ONE + in + if + z_lt (Core.Clone.f_clone #Core.Base.Spec.Z.t_Z #FStar.Tactics.Typeclasses.solve r___ + <: + Core.Base.Spec.Z.t_Z) + (Core.Clone.f_clone #Core.Base.Spec.Z.t_Z #FStar.Tactics.Typeclasses.solve b + <: + Core.Base.Spec.Z.t_Z) + then z_mul Core.Base.Spec.Z.v_Z_TWO q, r___ <: (Core.Base.Spec.Z.t_Z & Core.Base.Spec.Z.t_Z) + else + z_add (z_mul Core.Base.Spec.Z.v_Z_TWO q <: Core.Base.Spec.Z.t_Z) Core.Base.Spec.Z.v_Z_ONE, + z_sub r___ b + <: + (Core.Base.Spec.Z.t_Z & Core.Base.Spec.Z.t_Z) + +let z_divmod (a b: Core.Base.Spec.Z.t_Z) : (Core.Base.Spec.Z.t_Z & Core.Base.Spec.Z.t_Z) = + match a with + | Core.Base.Spec.Z.Z_ZERO -> + (Core.Base.Spec.Z.Z_ZERO <: Core.Base.Spec.Z.t_Z), + (Core.Base.Spec.Z.Z_ZERO <: Core.Base.Spec.Z.t_Z) + <: + (Core.Base.Spec.Z.t_Z & Core.Base.Spec.Z.t_Z) + | Core.Base.Spec.Z.Z_POS a___ -> + (match Core.Clone.f_clone #Core.Base.Spec.Z.t_Z #FStar.Tactics.Typeclasses.solve b with + | Core.Base.Spec.Z.Z_ZERO -> + (Core.Base.Spec.Z.Z_ZERO <: Core.Base.Spec.Z.t_Z), + (Core.Base.Spec.Z.Z_POS a___ <: Core.Base.Spec.Z.t_Z) + <: + (Core.Base.Spec.Z.t_Z & Core.Base.Spec.Z.t_Z) + | Core.Base.Spec.Z.Z_POS b___ -> pos_div_eucl a___ b + | Core.Base.Spec.Z.Z_NEG b___ -> + let q, r:(Core.Base.Spec.Z.t_Z & Core.Base.Spec.Z.t_Z) = + pos_div_eucl a___ (Core.Base.Spec.Z.Z_POS b___ <: Core.Base.Spec.Z.t_Z) + in + z_neg q, r <: (Core.Base.Spec.Z.t_Z & Core.Base.Spec.Z.t_Z)) + | Core.Base.Spec.Z.Z_NEG a___ -> + match Core.Clone.f_clone #Core.Base.Spec.Z.t_Z #FStar.Tactics.Typeclasses.solve b with + | Core.Base.Spec.Z.Z_ZERO -> + (Core.Base.Spec.Z.Z_ZERO <: Core.Base.Spec.Z.t_Z), + (Core.Base.Spec.Z.Z_NEG a___ <: Core.Base.Spec.Z.t_Z) + <: + (Core.Base.Spec.Z.t_Z & Core.Base.Spec.Z.t_Z) + | Core.Base.Spec.Z.Z_POS _ -> + let q, r:(Core.Base.Spec.Z.t_Z & Core.Base.Spec.Z.t_Z) = + pos_div_eucl a___ + (Core.Clone.f_clone #Core.Base.Spec.Z.t_Z #FStar.Tactics.Typeclasses.solve b + <: + Core.Base.Spec.Z.t_Z) + in + z_neg q, z_neg r <: (Core.Base.Spec.Z.t_Z & Core.Base.Spec.Z.t_Z) + | Core.Base.Spec.Z.Z_NEG b___ -> + let q, r:(Core.Base.Spec.Z.t_Z & Core.Base.Spec.Z.t_Z) = + pos_div_eucl a___ (Core.Base.Spec.Z.Z_POS b___ <: Core.Base.Spec.Z.t_Z) + in + q, z_neg r <: (Core.Base.Spec.Z.t_Z & Core.Base.Spec.Z.t_Z) + +let z_div (lhs rhs: Core.Base.Spec.Z.t_Z) : Core.Base.Spec.Z.t_Z = + let q, _:(Core.Base.Spec.Z.t_Z & Core.Base.Spec.Z.t_Z) = z_divmod lhs rhs in + q + +let z_rem (lhs rhs: Core.Base.Spec.Z.t_Z) : Core.Base.Spec.Z.t_Z = + let _, r:(Core.Base.Spec.Z.t_Z & Core.Base.Spec.Z.t_Z) = z_divmod lhs rhs in + r diff --git a/proof-libs/fstar/generated_core/Core.Base_interface.Coerce.fst b/proof-libs/fstar/generated_core/Core.Base_interface.Coerce.fst new file mode 100644 index 000000000..c829e1248 --- /dev/null +++ b/proof-libs/fstar/generated_core/Core.Base_interface.Coerce.fst @@ -0,0 +1,19 @@ +module Core.Base_interface.Coerce +#set-options "--fuel 0 --ifuel 1 --z3rlimit 15" +open Core +open FStar.Mul + +class t_Concretization (v_Self: Type0) (v_T: Type0) = { + f_concretize_pre:v_Self -> Type0; + f_concretize_post:v_Self -> v_T -> Type0; + f_concretize:x0: v_Self + -> Prims.Pure v_T (f_concretize_pre x0) (fun result -> f_concretize_post x0 result) +} + +class t_Abstraction (v_Self: Type0) = { + f_AbstractType:Type0; + f_lift_pre:v_Self -> Type0; + f_lift_post:v_Self -> f_AbstractType -> Type0; + f_lift:x0: v_Self + -> Prims.Pure f_AbstractType (f_lift_pre x0) (fun result -> f_lift_post x0 result) +} diff --git a/proof-libs/fstar/generated_core/Core.Base_interface.Int.I128_proofs.fst b/proof-libs/fstar/generated_core/Core.Base_interface.Int.I128_proofs.fst new file mode 100644 index 000000000..344da15c6 --- /dev/null +++ b/proof-libs/fstar/generated_core/Core.Base_interface.Int.I128_proofs.fst @@ -0,0 +1,23 @@ +module Core.Base_interface.Int.I128_proofs +#set-options "--fuel 0 --ifuel 1 --z3rlimit 15" +open Core +open FStar.Mul + +let abstract_concretize_cancel (x: Core.Base_interface.Int.t_I128) + : Lemma Prims.l_True + (ensures + (Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #Core.Base_interface.Int.t_I128 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I128 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base_interface.Int.t_I128 + #FStar.Tactics.Typeclasses.solve + x + <: + Core.Base_interface.Int.t_I128) + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base_interface.Int.t_I128) =. + x) = () diff --git a/proof-libs/fstar/generated_core/Core.Base_interface.Int.I16_proofs.fst b/proof-libs/fstar/generated_core/Core.Base_interface.Int.I16_proofs.fst new file mode 100644 index 000000000..70d5516d0 --- /dev/null +++ b/proof-libs/fstar/generated_core/Core.Base_interface.Int.I16_proofs.fst @@ -0,0 +1,23 @@ +module Core.Base_interface.Int.I16_proofs +#set-options "--fuel 0 --ifuel 1 --z3rlimit 15" +open Core +open FStar.Mul + +let abstract_concretize_cancel (x: Core.Base_interface.Int.t_I16) + : Lemma Prims.l_True + (ensures + (Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #Core.Base_interface.Int.t_I16 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I16 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base_interface.Int.t_I16 + #FStar.Tactics.Typeclasses.solve + x + <: + Core.Base_interface.Int.t_I16) + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base_interface.Int.t_I16) =. + x) = () diff --git a/proof-libs/fstar/generated_core/Core.Base_interface.Int.I32_proofs.fst b/proof-libs/fstar/generated_core/Core.Base_interface.Int.I32_proofs.fst new file mode 100644 index 000000000..257939043 --- /dev/null +++ b/proof-libs/fstar/generated_core/Core.Base_interface.Int.I32_proofs.fst @@ -0,0 +1,23 @@ +module Core.Base_interface.Int.I32_proofs +#set-options "--fuel 0 --ifuel 1 --z3rlimit 15" +open Core +open FStar.Mul + +let abstract_concretize_cancel (x: Core.Base_interface.Int.t_I32) + : Lemma Prims.l_True + (ensures + (Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #Core.Base_interface.Int.t_I32 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I32 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base_interface.Int.t_I32 + #FStar.Tactics.Typeclasses.solve + x + <: + Core.Base_interface.Int.t_I32) + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base_interface.Int.t_I32) =. + x) = () diff --git a/proof-libs/fstar/generated_core/Core.Base_interface.Int.I64_proofs.fst b/proof-libs/fstar/generated_core/Core.Base_interface.Int.I64_proofs.fst new file mode 100644 index 000000000..b7c952144 --- /dev/null +++ b/proof-libs/fstar/generated_core/Core.Base_interface.Int.I64_proofs.fst @@ -0,0 +1,23 @@ +module Core.Base_interface.Int.I64_proofs +#set-options "--fuel 0 --ifuel 1 --z3rlimit 15" +open Core +open FStar.Mul + +let abstract_concretize_cancel (x: Core.Base_interface.Int.t_I64) + : Lemma Prims.l_True + (ensures + (Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #Core.Base_interface.Int.t_I64 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I64 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base_interface.Int.t_I64 + #FStar.Tactics.Typeclasses.solve + x + <: + Core.Base_interface.Int.t_I64) + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base_interface.Int.t_I64) =. + x) = () diff --git a/proof-libs/fstar/generated_core/Core.Base_interface.Int.I8_proofs.fst b/proof-libs/fstar/generated_core/Core.Base_interface.Int.I8_proofs.fst new file mode 100644 index 000000000..93f2caac1 --- /dev/null +++ b/proof-libs/fstar/generated_core/Core.Base_interface.Int.I8_proofs.fst @@ -0,0 +1,21 @@ +module Core.Base_interface.Int.I8_proofs +#set-options "--fuel 0 --ifuel 1 --z3rlimit 15" +open Core +open FStar.Mul + +let abstract_concretize_cancel (x: Core.Base_interface.Int.t_I8) + : Lemma Prims.l_True + (ensures + (Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #Core.Base_interface.Int.t_I8 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I8 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base_interface.Int.t_I8 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_I8) + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base_interface.Int.t_I8) =. + x) = () diff --git a/proof-libs/fstar/generated_core/Core.Base_interface.Int.U128_proofs.fst b/proof-libs/fstar/generated_core/Core.Base_interface.Int.U128_proofs.fst new file mode 100644 index 000000000..d0933429e --- /dev/null +++ b/proof-libs/fstar/generated_core/Core.Base_interface.Int.U128_proofs.fst @@ -0,0 +1,519 @@ +module Core.Base_interface.Int.U128_proofs +#set-options "--fuel 0 --ifuel 1 --z3rlimit 15" +open Core +open FStar.Mul + +let int_range (x: Core.Base_interface.Int.t_U128) + : Lemma Prims.l_True + (ensures + (Core.Base_interface.Int.f_MIN #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U128) <=. + (Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U128) && + x <=. + (Core.Base_interface.Int.f_MAX #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U128)) = () + +let abstract_concretize_cancel (x: Core.Base_interface.Int.t_U128) + : Lemma Prims.l_True + (ensures + (Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #Core.Base_interface.Int.t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base_interface.Int.t_U128 + #FStar.Tactics.Typeclasses.solve + x + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base_interface.Int.t_U128) =. + x) = () + +let addA (x y z: Core.Base_interface.Int.t_U128) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U128) +! + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U128) +! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base_interface.Int.t_U128) =. + ((x +! y <: Core.Base_interface.Int.t_U128) +! z <: Core.Base_interface.Int.t_U128)) = () + +let addC (x y: Core.Base_interface.Int.t_U128) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U128) +! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base_interface.Int.t_U128) =. + (y +! x <: Core.Base_interface.Int.t_U128)) = () + +let add_0_l (x y z: Core.Base_interface.Int.t_U128) + : Lemma Prims.l_True + (ensures + ((Core.Base_interface.Int.f_ZERO #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U128) +! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base_interface.Int.t_U128) =. + x) = () + +let add_0_r (x y z: Core.Base_interface.Int.t_U128) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U128) +! + (Core.Base_interface.Int.f_ZERO #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base_interface.Int.t_U128) =. + x) = () + +let div_1_r (x y: Core.Base_interface.Int.t_U128) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U128) /! + (Core.Base_interface.Int.f_ONE #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base_interface.Int.t_U128) =. + x) = () + +let mod_add (x y z: Core.Base_interface.Int.t_U128) + : Lemma Prims.l_True + (ensures + Core.Base.Pos.haxint_le Core.Base.Spec.Constants.v_WORDSIZE_128_ + (Core.Base.Pos.haxint_add (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base_interface.Int.t_U128 + #FStar.Tactics.Typeclasses.solve + x + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base_interface.Int.t_U128 + #FStar.Tactics.Typeclasses.solve + y + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) || + (((Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U128) +! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base_interface.Int.t_U128) %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base_interface.Int.t_U128) =. + (((x %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base_interface.Int.t_U128) +! + (y %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base_interface.Int.t_U128) %! + z + <: + Core.Base_interface.Int.t_U128)) = () + +let mod_mul (x y z: Core.Base_interface.Int.t_U128) + : Lemma Prims.l_True + (ensures + Core.Base.Pos.haxint_lt Core.Base.Spec.Constants.v_WORDSIZE_128_ + (Core.Base.Pos.haxint_mul (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base_interface.Int.t_U128 + #FStar.Tactics.Typeclasses.solve + x + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base_interface.Int.t_U128 + #FStar.Tactics.Typeclasses.solve + y + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) || + (((Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U128) *! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base_interface.Int.t_U128) %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base_interface.Int.t_U128) =. + ((((x %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U128 + #FStar.Tactics.Typeclasses.solve + z + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base_interface.Int.t_U128) *! + y + <: + Core.Base_interface.Int.t_U128) %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base_interface.Int.t_U128) %! + z + <: + Core.Base_interface.Int.t_U128)) = () + +let mod_one (x: Core.Base_interface.Int.t_U128) + : Lemma Prims.l_True + (ensures + (x %! + (Core.Base_interface.Int.f_ONE #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base_interface.Int.t_U128) =. + (Core.Base_interface.Int.f_ZERO #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U128)) = () + +let mod_small (x y: Core.Base_interface.Int.t_U128) + : Lemma Prims.l_True + (ensures + (Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U128) >=. + (Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U128) || + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U128) %! + y + <: + Core.Base_interface.Int.t_U128) =. + x) = () + +let mulA (x y z: Core.Base_interface.Int.t_U128) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U128) *! + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U128) *! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base_interface.Int.t_U128) =. + ((x *! y <: Core.Base_interface.Int.t_U128) *! z <: Core.Base_interface.Int.t_U128)) = () + +let mulC (x y: Core.Base_interface.Int.t_U128) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U128) *! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base_interface.Int.t_U128) =. + (y *! x <: Core.Base_interface.Int.t_U128)) = () + +let mul_1_l (x: Core.Base_interface.Int.t_U128) + : Lemma Prims.l_True + (ensures + ((Core.Base_interface.Int.f_ONE #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U128) *! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base_interface.Int.t_U128) =. + x) = () + +let mul_1_r (x: Core.Base_interface.Int.t_U128) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U128) *! + (Core.Base_interface.Int.f_ONE #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base_interface.Int.t_U128) =. + x) = () + +let mul_distr (x y z: Core.Base_interface.Int.t_U128) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U128) *! + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U128) +! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base_interface.Int.t_U128) =. + (((Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U128) *! + y + <: + Core.Base_interface.Int.t_U128) +! + (x *! z <: Core.Base_interface.Int.t_U128) + <: + Core.Base_interface.Int.t_U128)) = () + +let mul_opp (x: Core.Base_interface.Int.t_U128) + : Lemma Prims.l_True + (ensures + (Core.Ops.Arith.f_neg #Core.Base_interface.Int.t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base_interface.Int.t_U128) =. + ((Core.Ops.Arith.f_neg #Core.Base_interface.Int.t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Int.f_ONE #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base_interface.Int.t_U128) *! + x + <: + Core.Base_interface.Int.t_U128)) = () + +let neg_idemp (x: Core.Base_interface.Int.t_U128) + : Lemma Prims.l_True + (ensures + (Core.Ops.Arith.f_neg #Core.Base_interface.Int.t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Ops.Arith.f_neg #Core.Base_interface.Int.t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base_interface.Int.t_U128 + #FStar.Tactics.Typeclasses.solve + x + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base_interface.Int.t_U128) =. + x) = () + +let shl_1_ (x: Core.Base_interface.Int.t_U128) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U128) <>! + (Core.Base_interface.Int.f_ONE #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base_interface.Int.t_U128) =. + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U128) /! + ((Core.Base_interface.Int.f_ONE #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U128) +! + (Core.Base_interface.Int.f_ONE #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base_interface.Int.t_U128)) = () + +let addN (x: Core.Base_interface.Int.t_U128) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U128) -! + x + <: + Core.Base_interface.Int.t_U128) =. + (Core.Base_interface.Int.f_ZERO #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U128)) = () + +let mod_sub (x y z: Core.Base_interface.Int.t_U128) + : Lemma Prims.l_True + (ensures + (Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U128) <. + (Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U128) || + (Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U128) <=. + (Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U128) || + (((Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U128) -! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base_interface.Int.t_U128) %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base_interface.Int.t_U128) =. + (((x %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base_interface.Int.t_U128) -! + (y %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base_interface.Int.t_U128) %! + z + <: + Core.Base_interface.Int.t_U128)) = () + +let sub_distr (x y z: Core.Base_interface.Int.t_U128) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U128) -! + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U128) +! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base_interface.Int.t_U128) =. + (x +! + ((Core.Ops.Arith.f_neg #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U128) +! + (Core.Ops.Arith.f_neg #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base_interface.Int.t_U128)) = () + +let sub_is (x y: Core.Base_interface.Int.t_U128) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U128) -! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base_interface.Int.t_U128) =. + (x +! + (Core.Ops.Arith.f_neg #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U128) + <: + Core.Base_interface.Int.t_U128)) = () diff --git a/proof-libs/fstar/generated_core/Core.Base_interface.Int.U16_proofs.fst b/proof-libs/fstar/generated_core/Core.Base_interface.Int.U16_proofs.fst new file mode 100644 index 000000000..d38b30ff1 --- /dev/null +++ b/proof-libs/fstar/generated_core/Core.Base_interface.Int.U16_proofs.fst @@ -0,0 +1,519 @@ +module Core.Base_interface.Int.U16_proofs +#set-options "--fuel 0 --ifuel 1 --z3rlimit 15" +open Core +open FStar.Mul + +let int_range (x: Core.Base_interface.Int.t_U16) + : Lemma Prims.l_True + (ensures + (Core.Base_interface.Int.f_MIN #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U16) <=. + (Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U16) && + x <=. + (Core.Base_interface.Int.f_MAX #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U16)) = () + +let abstract_concretize_cancel (x: Core.Base_interface.Int.t_U16) + : Lemma Prims.l_True + (ensures + (Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #Core.Base_interface.Int.t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base_interface.Int.t_U16 + #FStar.Tactics.Typeclasses.solve + x + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base_interface.Int.t_U16) =. + x) = () + +let addA (x y z: Core.Base_interface.Int.t_U16) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U16) +! + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U16) +! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base_interface.Int.t_U16) =. + ((x +! y <: Core.Base_interface.Int.t_U16) +! z <: Core.Base_interface.Int.t_U16)) = () + +let addC (x y: Core.Base_interface.Int.t_U16) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U16) +! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base_interface.Int.t_U16) =. + (y +! x <: Core.Base_interface.Int.t_U16)) = () + +let add_0_l (x y z: Core.Base_interface.Int.t_U16) + : Lemma Prims.l_True + (ensures + ((Core.Base_interface.Int.f_ZERO #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U16) +! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base_interface.Int.t_U16) =. + x) = () + +let add_0_r (x y z: Core.Base_interface.Int.t_U16) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U16) +! + (Core.Base_interface.Int.f_ZERO #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base_interface.Int.t_U16) =. + x) = () + +let div_1_r (x y: Core.Base_interface.Int.t_U16) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U16) /! + (Core.Base_interface.Int.f_ONE #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base_interface.Int.t_U16) =. + x) = () + +let mod_add (x y z: Core.Base_interface.Int.t_U16) + : Lemma Prims.l_True + (ensures + Core.Base.Pos.haxint_le Core.Base.Spec.Constants.v_WORDSIZE_16_ + (Core.Base.Pos.haxint_add (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base_interface.Int.t_U16 + #FStar.Tactics.Typeclasses.solve + x + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base_interface.Int.t_U16 + #FStar.Tactics.Typeclasses.solve + y + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) || + (((Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U16) +! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base_interface.Int.t_U16) %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base_interface.Int.t_U16) =. + (((x %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base_interface.Int.t_U16) +! + (y %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base_interface.Int.t_U16) %! + z + <: + Core.Base_interface.Int.t_U16)) = () + +let mod_mul (x y z: Core.Base_interface.Int.t_U16) + : Lemma Prims.l_True + (ensures + Core.Base.Pos.haxint_lt Core.Base.Spec.Constants.v_WORDSIZE_16_ + (Core.Base.Pos.haxint_mul (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base_interface.Int.t_U16 + #FStar.Tactics.Typeclasses.solve + x + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base_interface.Int.t_U16 + #FStar.Tactics.Typeclasses.solve + y + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) || + (((Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U16) *! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base_interface.Int.t_U16) %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base_interface.Int.t_U16) =. + ((((x %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U16 + #FStar.Tactics.Typeclasses.solve + z + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base_interface.Int.t_U16) *! + y + <: + Core.Base_interface.Int.t_U16) %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base_interface.Int.t_U16) %! + z + <: + Core.Base_interface.Int.t_U16)) = () + +let mod_one (x: Core.Base_interface.Int.t_U16) + : Lemma Prims.l_True + (ensures + (x %! + (Core.Base_interface.Int.f_ONE #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base_interface.Int.t_U16) =. + (Core.Base_interface.Int.f_ZERO #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U16)) = () + +let mod_small (x y: Core.Base_interface.Int.t_U16) + : Lemma Prims.l_True + (ensures + (Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U16) >=. + (Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U16) || + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U16) %! + y + <: + Core.Base_interface.Int.t_U16) =. + x) = () + +let mulA (x y z: Core.Base_interface.Int.t_U16) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U16) *! + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U16) *! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base_interface.Int.t_U16) =. + ((x *! y <: Core.Base_interface.Int.t_U16) *! z <: Core.Base_interface.Int.t_U16)) = () + +let mulC (x y: Core.Base_interface.Int.t_U16) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U16) *! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base_interface.Int.t_U16) =. + (y *! x <: Core.Base_interface.Int.t_U16)) = () + +let mul_1_l (x: Core.Base_interface.Int.t_U16) + : Lemma Prims.l_True + (ensures + ((Core.Base_interface.Int.f_ONE #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U16) *! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base_interface.Int.t_U16) =. + x) = () + +let mul_1_r (x: Core.Base_interface.Int.t_U16) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U16) *! + (Core.Base_interface.Int.f_ONE #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base_interface.Int.t_U16) =. + x) = () + +let mul_distr (x y z: Core.Base_interface.Int.t_U16) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U16) *! + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U16) +! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base_interface.Int.t_U16) =. + (((Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U16) *! + y + <: + Core.Base_interface.Int.t_U16) +! + (x *! z <: Core.Base_interface.Int.t_U16) + <: + Core.Base_interface.Int.t_U16)) = () + +let mul_opp (x: Core.Base_interface.Int.t_U16) + : Lemma Prims.l_True + (ensures + (Core.Ops.Arith.f_neg #Core.Base_interface.Int.t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base_interface.Int.t_U16) =. + ((Core.Ops.Arith.f_neg #Core.Base_interface.Int.t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Int.f_ONE #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base_interface.Int.t_U16) *! + x + <: + Core.Base_interface.Int.t_U16)) = () + +let neg_idemp (x: Core.Base_interface.Int.t_U16) + : Lemma Prims.l_True + (ensures + (Core.Ops.Arith.f_neg #Core.Base_interface.Int.t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Ops.Arith.f_neg #Core.Base_interface.Int.t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base_interface.Int.t_U16 + #FStar.Tactics.Typeclasses.solve + x + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base_interface.Int.t_U16) =. + x) = () + +let shl_1_ (x: Core.Base_interface.Int.t_U16) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U16) <>! + (Core.Base_interface.Int.f_ONE #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base_interface.Int.t_U16) =. + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U16) /! + ((Core.Base_interface.Int.f_ONE #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U16) +! + (Core.Base_interface.Int.f_ONE #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base_interface.Int.t_U16)) = () + +let addN (x: Core.Base_interface.Int.t_U16) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U16) -! + x + <: + Core.Base_interface.Int.t_U16) =. + (Core.Base_interface.Int.f_ZERO #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U16)) = () + +let mod_sub (x y z: Core.Base_interface.Int.t_U16) + : Lemma Prims.l_True + (ensures + (Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U16) <. + (Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U16) || + (Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U16) <=. + (Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U16) || + (((Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U16) -! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base_interface.Int.t_U16) %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base_interface.Int.t_U16) =. + (((x %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base_interface.Int.t_U16) -! + (y %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base_interface.Int.t_U16) %! + z + <: + Core.Base_interface.Int.t_U16)) = () + +let sub_distr (x y z: Core.Base_interface.Int.t_U16) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U16) -! + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U16) +! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base_interface.Int.t_U16) =. + (x +! + ((Core.Ops.Arith.f_neg #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U16) +! + (Core.Ops.Arith.f_neg #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base_interface.Int.t_U16)) = () + +let sub_is (x y: Core.Base_interface.Int.t_U16) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U16) -! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base_interface.Int.t_U16) =. + (x +! + (Core.Ops.Arith.f_neg #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U16) + <: + Core.Base_interface.Int.t_U16)) = () diff --git a/proof-libs/fstar/generated_core/Core.Base_interface.Int.U32_proofs.fst b/proof-libs/fstar/generated_core/Core.Base_interface.Int.U32_proofs.fst new file mode 100644 index 000000000..11f6c7daf --- /dev/null +++ b/proof-libs/fstar/generated_core/Core.Base_interface.Int.U32_proofs.fst @@ -0,0 +1,519 @@ +module Core.Base_interface.Int.U32_proofs +#set-options "--fuel 0 --ifuel 1 --z3rlimit 15" +open Core +open FStar.Mul + +let int_range (x: Core.Base_interface.Int.t_U32) + : Lemma Prims.l_True + (ensures + (Core.Base_interface.Int.f_MIN #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U32) <=. + (Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U32) && + x <=. + (Core.Base_interface.Int.f_MAX #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U32)) = () + +let abstract_concretize_cancel (x: Core.Base_interface.Int.t_U32) + : Lemma Prims.l_True + (ensures + (Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #Core.Base_interface.Int.t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base_interface.Int.t_U32 + #FStar.Tactics.Typeclasses.solve + x + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base_interface.Int.t_U32) =. + x) = () + +let addA (x y z: Core.Base_interface.Int.t_U32) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U32) +! + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U32) +! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base_interface.Int.t_U32) =. + ((x +! y <: Core.Base_interface.Int.t_U32) +! z <: Core.Base_interface.Int.t_U32)) = () + +let addC (x y: Core.Base_interface.Int.t_U32) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U32) +! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base_interface.Int.t_U32) =. + (y +! x <: Core.Base_interface.Int.t_U32)) = () + +let add_0_l (x y z: Core.Base_interface.Int.t_U32) + : Lemma Prims.l_True + (ensures + ((Core.Base_interface.Int.f_ZERO #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U32) +! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base_interface.Int.t_U32) =. + x) = () + +let add_0_r (x y z: Core.Base_interface.Int.t_U32) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U32) +! + (Core.Base_interface.Int.f_ZERO #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base_interface.Int.t_U32) =. + x) = () + +let div_1_r (x y: Core.Base_interface.Int.t_U32) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U32) /! + (Core.Base_interface.Int.f_ONE #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base_interface.Int.t_U32) =. + x) = () + +let mod_add (x y z: Core.Base_interface.Int.t_U32) + : Lemma Prims.l_True + (ensures + Core.Base.Pos.haxint_le Core.Base.Spec.Constants.v_WORDSIZE_32_ + (Core.Base.Pos.haxint_add (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base_interface.Int.t_U32 + #FStar.Tactics.Typeclasses.solve + x + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base_interface.Int.t_U32 + #FStar.Tactics.Typeclasses.solve + y + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) || + (((Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U32) +! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base_interface.Int.t_U32) %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base_interface.Int.t_U32) =. + (((x %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base_interface.Int.t_U32) +! + (y %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base_interface.Int.t_U32) %! + z + <: + Core.Base_interface.Int.t_U32)) = () + +let mod_mul (x y z: Core.Base_interface.Int.t_U32) + : Lemma Prims.l_True + (ensures + Core.Base.Pos.haxint_lt Core.Base.Spec.Constants.v_WORDSIZE_32_ + (Core.Base.Pos.haxint_mul (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base_interface.Int.t_U32 + #FStar.Tactics.Typeclasses.solve + x + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base_interface.Int.t_U32 + #FStar.Tactics.Typeclasses.solve + y + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) || + (((Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U32) *! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base_interface.Int.t_U32) %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base_interface.Int.t_U32) =. + ((((x %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U32 + #FStar.Tactics.Typeclasses.solve + z + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base_interface.Int.t_U32) *! + y + <: + Core.Base_interface.Int.t_U32) %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base_interface.Int.t_U32) %! + z + <: + Core.Base_interface.Int.t_U32)) = () + +let mod_one (x: Core.Base_interface.Int.t_U32) + : Lemma Prims.l_True + (ensures + (x %! + (Core.Base_interface.Int.f_ONE #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base_interface.Int.t_U32) =. + (Core.Base_interface.Int.f_ZERO #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U32)) = () + +let mod_small (x y: Core.Base_interface.Int.t_U32) + : Lemma Prims.l_True + (ensures + (Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U32) >=. + (Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U32) || + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U32) %! + y + <: + Core.Base_interface.Int.t_U32) =. + x) = () + +let mulA (x y z: Core.Base_interface.Int.t_U32) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U32) *! + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U32) *! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base_interface.Int.t_U32) =. + ((x *! y <: Core.Base_interface.Int.t_U32) *! z <: Core.Base_interface.Int.t_U32)) = () + +let mulC (x y: Core.Base_interface.Int.t_U32) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U32) *! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base_interface.Int.t_U32) =. + (y *! x <: Core.Base_interface.Int.t_U32)) = () + +let mul_1_l (x: Core.Base_interface.Int.t_U32) + : Lemma Prims.l_True + (ensures + ((Core.Base_interface.Int.f_ONE #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U32) *! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base_interface.Int.t_U32) =. + x) = () + +let mul_1_r (x: Core.Base_interface.Int.t_U32) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U32) *! + (Core.Base_interface.Int.f_ONE #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base_interface.Int.t_U32) =. + x) = () + +let mul_distr (x y z: Core.Base_interface.Int.t_U32) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U32) *! + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U32) +! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base_interface.Int.t_U32) =. + (((Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U32) *! + y + <: + Core.Base_interface.Int.t_U32) +! + (x *! z <: Core.Base_interface.Int.t_U32) + <: + Core.Base_interface.Int.t_U32)) = () + +let mul_opp (x: Core.Base_interface.Int.t_U32) + : Lemma Prims.l_True + (ensures + (Core.Ops.Arith.f_neg #Core.Base_interface.Int.t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base_interface.Int.t_U32) =. + ((Core.Ops.Arith.f_neg #Core.Base_interface.Int.t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Int.f_ONE #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base_interface.Int.t_U32) *! + x + <: + Core.Base_interface.Int.t_U32)) = () + +let neg_idemp (x: Core.Base_interface.Int.t_U32) + : Lemma Prims.l_True + (ensures + (Core.Ops.Arith.f_neg #Core.Base_interface.Int.t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Ops.Arith.f_neg #Core.Base_interface.Int.t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base_interface.Int.t_U32 + #FStar.Tactics.Typeclasses.solve + x + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base_interface.Int.t_U32) =. + x) = () + +let shl_1_ (x: Core.Base_interface.Int.t_U32) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U32) <>! + (Core.Base_interface.Int.f_ONE #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base_interface.Int.t_U32) =. + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U32) /! + ((Core.Base_interface.Int.f_ONE #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U32) +! + (Core.Base_interface.Int.f_ONE #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base_interface.Int.t_U32)) = () + +let addN (x: Core.Base_interface.Int.t_U32) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U32) -! + x + <: + Core.Base_interface.Int.t_U32) =. + (Core.Base_interface.Int.f_ZERO #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U32)) = () + +let mod_sub (x y z: Core.Base_interface.Int.t_U32) + : Lemma Prims.l_True + (ensures + (Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U32) <. + (Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U32) || + (Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U32) <=. + (Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U32) || + (((Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U32) -! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base_interface.Int.t_U32) %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base_interface.Int.t_U32) =. + (((x %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base_interface.Int.t_U32) -! + (y %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base_interface.Int.t_U32) %! + z + <: + Core.Base_interface.Int.t_U32)) = () + +let sub_distr (x y z: Core.Base_interface.Int.t_U32) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U32) -! + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U32) +! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base_interface.Int.t_U32) =. + (x +! + ((Core.Ops.Arith.f_neg #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U32) +! + (Core.Ops.Arith.f_neg #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base_interface.Int.t_U32)) = () + +let sub_is (x y: Core.Base_interface.Int.t_U32) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U32) -! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base_interface.Int.t_U32) =. + (x +! + (Core.Ops.Arith.f_neg #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U32) + <: + Core.Base_interface.Int.t_U32)) = () diff --git a/proof-libs/fstar/generated_core/Core.Base_interface.Int.U64_proofs.fst b/proof-libs/fstar/generated_core/Core.Base_interface.Int.U64_proofs.fst new file mode 100644 index 000000000..09bd2c346 --- /dev/null +++ b/proof-libs/fstar/generated_core/Core.Base_interface.Int.U64_proofs.fst @@ -0,0 +1,519 @@ +module Core.Base_interface.Int.U64_proofs +#set-options "--fuel 0 --ifuel 1 --z3rlimit 15" +open Core +open FStar.Mul + +let int_range (x: Core.Base_interface.Int.t_U64) + : Lemma Prims.l_True + (ensures + (Core.Base_interface.Int.f_MIN #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U64) <=. + (Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U64) && + x <=. + (Core.Base_interface.Int.f_MAX #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U64)) = () + +let abstract_concretize_cancel (x: Core.Base_interface.Int.t_U64) + : Lemma Prims.l_True + (ensures + (Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + x + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base_interface.Int.t_U64) =. + x) = () + +let addA (x y z: Core.Base_interface.Int.t_U64) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U64) +! + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U64) +! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base_interface.Int.t_U64) =. + ((x +! y <: Core.Base_interface.Int.t_U64) +! z <: Core.Base_interface.Int.t_U64)) = () + +let addC (x y: Core.Base_interface.Int.t_U64) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U64) +! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base_interface.Int.t_U64) =. + (y +! x <: Core.Base_interface.Int.t_U64)) = () + +let add_0_l (x y z: Core.Base_interface.Int.t_U64) + : Lemma Prims.l_True + (ensures + ((Core.Base_interface.Int.f_ZERO #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U64) +! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base_interface.Int.t_U64) =. + x) = () + +let add_0_r (x y z: Core.Base_interface.Int.t_U64) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U64) +! + (Core.Base_interface.Int.f_ZERO #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base_interface.Int.t_U64) =. + x) = () + +let div_1_r (x y: Core.Base_interface.Int.t_U64) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U64) /! + (Core.Base_interface.Int.f_ONE #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base_interface.Int.t_U64) =. + x) = () + +let mod_add (x y z: Core.Base_interface.Int.t_U64) + : Lemma Prims.l_True + (ensures + Core.Base.Pos.haxint_le Core.Base.Spec.Constants.v_WORDSIZE_64_ + (Core.Base.Pos.haxint_add (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + x + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + y + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) || + (((Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U64) +! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base_interface.Int.t_U64) %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base_interface.Int.t_U64) =. + (((x %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base_interface.Int.t_U64) +! + (y %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base_interface.Int.t_U64) %! + z + <: + Core.Base_interface.Int.t_U64)) = () + +let mod_mul (x y z: Core.Base_interface.Int.t_U64) + : Lemma Prims.l_True + (ensures + Core.Base.Pos.haxint_lt Core.Base.Spec.Constants.v_WORDSIZE_64_ + (Core.Base.Pos.haxint_mul (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + x + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + y + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) || + (((Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U64) *! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base_interface.Int.t_U64) %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base_interface.Int.t_U64) =. + ((((x %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + z + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base_interface.Int.t_U64) *! + y + <: + Core.Base_interface.Int.t_U64) %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base_interface.Int.t_U64) %! + z + <: + Core.Base_interface.Int.t_U64)) = () + +let mod_one (x: Core.Base_interface.Int.t_U64) + : Lemma Prims.l_True + (ensures + (x %! + (Core.Base_interface.Int.f_ONE #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base_interface.Int.t_U64) =. + (Core.Base_interface.Int.f_ZERO #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U64)) = () + +let mod_small (x y: Core.Base_interface.Int.t_U64) + : Lemma Prims.l_True + (ensures + (Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U64) >=. + (Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U64) || + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U64) %! + y + <: + Core.Base_interface.Int.t_U64) =. + x) = () + +let mulA (x y z: Core.Base_interface.Int.t_U64) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U64) *! + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U64) *! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base_interface.Int.t_U64) =. + ((x *! y <: Core.Base_interface.Int.t_U64) *! z <: Core.Base_interface.Int.t_U64)) = () + +let mulC (x y: Core.Base_interface.Int.t_U64) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U64) *! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base_interface.Int.t_U64) =. + (y *! x <: Core.Base_interface.Int.t_U64)) = () + +let mul_1_l (x: Core.Base_interface.Int.t_U64) + : Lemma Prims.l_True + (ensures + ((Core.Base_interface.Int.f_ONE #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U64) *! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base_interface.Int.t_U64) =. + x) = () + +let mul_1_r (x: Core.Base_interface.Int.t_U64) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U64) *! + (Core.Base_interface.Int.f_ONE #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base_interface.Int.t_U64) =. + x) = () + +let mul_distr (x y z: Core.Base_interface.Int.t_U64) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U64) *! + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U64) +! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base_interface.Int.t_U64) =. + (((Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U64) *! + y + <: + Core.Base_interface.Int.t_U64) +! + (x *! z <: Core.Base_interface.Int.t_U64) + <: + Core.Base_interface.Int.t_U64)) = () + +let mul_opp (x: Core.Base_interface.Int.t_U64) + : Lemma Prims.l_True + (ensures + (Core.Ops.Arith.f_neg #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base_interface.Int.t_U64) =. + ((Core.Ops.Arith.f_neg #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Int.f_ONE #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base_interface.Int.t_U64) *! + x + <: + Core.Base_interface.Int.t_U64)) = () + +let neg_idemp (x: Core.Base_interface.Int.t_U64) + : Lemma Prims.l_True + (ensures + (Core.Ops.Arith.f_neg #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Ops.Arith.f_neg #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + x + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base_interface.Int.t_U64) =. + x) = () + +let shl_1_ (x: Core.Base_interface.Int.t_U64) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U64) <>! + (Core.Base_interface.Int.f_ONE #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base_interface.Int.t_U64) =. + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U64) /! + ((Core.Base_interface.Int.f_ONE #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U64) +! + (Core.Base_interface.Int.f_ONE #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base_interface.Int.t_U64)) = () + +let addN (x: Core.Base_interface.Int.t_U64) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U64) -! + x + <: + Core.Base_interface.Int.t_U64) =. + (Core.Base_interface.Int.f_ZERO #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U64)) = () + +let mod_sub (x y z: Core.Base_interface.Int.t_U64) + : Lemma Prims.l_True + (ensures + (Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U64) <. + (Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U64) || + (Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U64) <=. + (Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U64) || + (((Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U64) -! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base_interface.Int.t_U64) %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base_interface.Int.t_U64) =. + (((x %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base_interface.Int.t_U64) -! + (y %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base_interface.Int.t_U64) %! + z + <: + Core.Base_interface.Int.t_U64)) = () + +let sub_distr (x y z: Core.Base_interface.Int.t_U64) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U64) -! + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U64) +! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base_interface.Int.t_U64) =. + (x +! + ((Core.Ops.Arith.f_neg #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U64) +! + (Core.Ops.Arith.f_neg #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base_interface.Int.t_U64)) = () + +let sub_is (x y: Core.Base_interface.Int.t_U64) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U64) -! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base_interface.Int.t_U64) =. + (x +! + (Core.Ops.Arith.f_neg #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U64) + <: + Core.Base_interface.Int.t_U64)) = () diff --git a/proof-libs/fstar/generated_core/Core.Base_interface.Int.U8_proofs.fst b/proof-libs/fstar/generated_core/Core.Base_interface.Int.U8_proofs.fst new file mode 100644 index 000000000..82e6c98f3 --- /dev/null +++ b/proof-libs/fstar/generated_core/Core.Base_interface.Int.U8_proofs.fst @@ -0,0 +1,513 @@ +module Core.Base_interface.Int.U8_proofs +#set-options "--fuel 0 --ifuel 1 --z3rlimit 15" +open Core +open FStar.Mul + +let int_range (x: Core.Base_interface.Int.t_U8) + : Lemma Prims.l_True + (ensures + (Core.Base_interface.Int.f_MIN #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U8) <=. + (Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U8) && + x <=. + (Core.Base_interface.Int.f_MAX #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U8)) = () + +let abstract_concretize_cancel (x: Core.Base_interface.Int.t_U8) + : Lemma Prims.l_True + (ensures + (Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #Core.Base_interface.Int.t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base_interface.Int.t_U8) =. + x) = () + +let addA (x y z: Core.Base_interface.Int.t_U8) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U8) +! + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U8) +! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base_interface.Int.t_U8) =. + ((x +! y <: Core.Base_interface.Int.t_U8) +! z <: Core.Base_interface.Int.t_U8)) = () + +let addC (x y: Core.Base_interface.Int.t_U8) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U8) +! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base_interface.Int.t_U8) =. + (y +! x <: Core.Base_interface.Int.t_U8)) = () + +let add_0_l (x y z: Core.Base_interface.Int.t_U8) + : Lemma Prims.l_True + (ensures + ((Core.Base_interface.Int.f_ZERO #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U8) +! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base_interface.Int.t_U8) =. + x) = () + +let add_0_r (x y z: Core.Base_interface.Int.t_U8) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U8) +! + (Core.Base_interface.Int.f_ZERO #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base_interface.Int.t_U8) =. + x) = () + +let div_1_r (x y: Core.Base_interface.Int.t_U8) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U8) /! + (Core.Base_interface.Int.f_ONE #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base_interface.Int.t_U8) =. + x) = () + +let mod_add (x y z: Core.Base_interface.Int.t_U8) + : Lemma Prims.l_True + (ensures + Core.Base.Pos.haxint_le Core.Base.Spec.Constants.v_WORDSIZE_8_ + (Core.Base.Pos.haxint_add (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base_interface.Int.t_U8 + #FStar.Tactics.Typeclasses.solve + x + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base_interface.Int.t_U8 + #FStar.Tactics.Typeclasses.solve + y + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) || + (((Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U8) +! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base_interface.Int.t_U8) %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base_interface.Int.t_U8) =. + (((x %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base_interface.Int.t_U8) +! + (y %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base_interface.Int.t_U8) %! + z + <: + Core.Base_interface.Int.t_U8)) = () + +let mod_mul (x y z: Core.Base_interface.Int.t_U8) + : Lemma Prims.l_True + (ensures + Core.Base.Pos.haxint_lt Core.Base.Spec.Constants.v_WORDSIZE_8_ + (Core.Base.Pos.haxint_mul (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base_interface.Int.t_U8 + #FStar.Tactics.Typeclasses.solve + x + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base_interface.Int.t_U8 + #FStar.Tactics.Typeclasses.solve + y + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) || + (((Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U8) *! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base_interface.Int.t_U8) %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base_interface.Int.t_U8) =. + ((((x %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base_interface.Int.t_U8) *! + y + <: + Core.Base_interface.Int.t_U8) %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base_interface.Int.t_U8) %! + z + <: + Core.Base_interface.Int.t_U8)) = () + +let mod_one (x: Core.Base_interface.Int.t_U8) + : Lemma Prims.l_True + (ensures + (x %! + (Core.Base_interface.Int.f_ONE #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base_interface.Int.t_U8) =. + (Core.Base_interface.Int.f_ZERO #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U8)) = () + +let mod_small (x y: Core.Base_interface.Int.t_U8) + : Lemma Prims.l_True + (ensures + (Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U8) >=. + (Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U8) || + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U8) %! + y + <: + Core.Base_interface.Int.t_U8) =. + x) = () + +let mulA (x y z: Core.Base_interface.Int.t_U8) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U8) *! + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U8) *! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base_interface.Int.t_U8) =. + ((x *! y <: Core.Base_interface.Int.t_U8) *! z <: Core.Base_interface.Int.t_U8)) = () + +let mulC (x y: Core.Base_interface.Int.t_U8) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U8) *! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base_interface.Int.t_U8) =. + (y *! x <: Core.Base_interface.Int.t_U8)) = () + +let mul_1_l (x: Core.Base_interface.Int.t_U8) + : Lemma Prims.l_True + (ensures + ((Core.Base_interface.Int.f_ONE #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U8) *! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base_interface.Int.t_U8) =. + x) = () + +let mul_1_r (x: Core.Base_interface.Int.t_U8) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U8) *! + (Core.Base_interface.Int.f_ONE #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base_interface.Int.t_U8) =. + x) = () + +let mul_distr (x y z: Core.Base_interface.Int.t_U8) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U8) *! + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U8) +! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base_interface.Int.t_U8) =. + (((Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U8) *! + y + <: + Core.Base_interface.Int.t_U8) +! + (x *! z <: Core.Base_interface.Int.t_U8) + <: + Core.Base_interface.Int.t_U8)) = () + +let mul_opp (x: Core.Base_interface.Int.t_U8) + : Lemma Prims.l_True + (ensures + (Core.Ops.Arith.f_neg #Core.Base_interface.Int.t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base_interface.Int.t_U8) =. + ((Core.Ops.Arith.f_neg #Core.Base_interface.Int.t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Int.f_ONE #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base_interface.Int.t_U8) *! + x + <: + Core.Base_interface.Int.t_U8)) = () + +let neg_idemp (x: Core.Base_interface.Int.t_U8) + : Lemma Prims.l_True + (ensures + (Core.Ops.Arith.f_neg #Core.Base_interface.Int.t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Ops.Arith.f_neg #Core.Base_interface.Int.t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base_interface.Int.t_U8) =. + x) = () + +let shl_1_ (x: Core.Base_interface.Int.t_U8) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U8) <>! + (Core.Base_interface.Int.f_ONE #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base_interface.Int.t_U8) =. + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U8) /! + ((Core.Base_interface.Int.f_ONE #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U8) +! + (Core.Base_interface.Int.f_ONE #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base_interface.Int.t_U8)) = () + +let addN (x: Core.Base_interface.Int.t_U8) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U8) -! + x + <: + Core.Base_interface.Int.t_U8) =. + (Core.Base_interface.Int.f_ZERO #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U8)) = () + +let mod_sub (x y z: Core.Base_interface.Int.t_U8) + : Lemma Prims.l_True + (ensures + (Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U8) <. + (Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U8) || + (Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U8) <=. + (Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U8) || + (((Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U8) -! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base_interface.Int.t_U8) %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base_interface.Int.t_U8) =. + (((x %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base_interface.Int.t_U8) -! + (y %! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base_interface.Int.t_U8) %! + z + <: + Core.Base_interface.Int.t_U8)) = () + +let sub_distr (x y z: Core.Base_interface.Int.t_U8) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U8) -! + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U8) +! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base_interface.Int.t_U8) =. + (x +! + ((Core.Ops.Arith.f_neg #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U8) +! + (Core.Ops.Arith.f_neg #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve z + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base_interface.Int.t_U8)) = () + +let sub_is (x y: Core.Base_interface.Int.t_U8) + : Lemma Prims.l_True + (ensures + ((Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base_interface.Int.t_U8) -! + (Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base_interface.Int.t_U8) =. + (x +! + (Core.Ops.Arith.f_neg #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve y + <: + Core.Base_interface.Int.t_U8) + <: + Core.Base_interface.Int.t_U8)) = () diff --git a/proof-libs/fstar/generated_core/Core.Base_interface.Int.fst b/proof-libs/fstar/generated_core/Core.Base_interface.Int.fst new file mode 100644 index 000000000..59f365830 --- /dev/null +++ b/proof-libs/fstar/generated_core/Core.Base_interface.Int.fst @@ -0,0 +1,7241 @@ +module Core.Base_interface.Int +#set-options "--fuel 0 --ifuel 1 --z3rlimit 15" +open Core +open FStar.Mul + +class t_Constants (v_Self: Type0) = { + f_ZERO:v_Self; + f_ONE:v_Self; + f_MIN:v_Self; + f_MAX:v_Self +} + +type t_I128 = { f_v:Core.Base.Spec.Z.t_Z } + +type t_I16 = { f_v:Core.Base.Spec.Z.t_Z } + +type t_I32 = { f_v:Core.Base.Spec.Z.t_Z } + +type t_I64 = { f_v:Core.Base.Spec.Z.t_Z } + +type t_I8 = { f_v:Core.Base.Spec.Z.t_Z } + +type t_U128 = { f_v:Core.Base.Spec.Haxint.t_HaxInt } + +type t_U16 = { f_v:Core.Base.Spec.Haxint.t_HaxInt } + +type t_U32 = { f_v:Core.Base.Spec.Haxint.t_HaxInt } + +type t_U64 = { f_v:Core.Base.Spec.Haxint.t_HaxInt } + +type t_U8 = { f_v:Core.Base.Spec.Haxint.t_HaxInt } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_43: Core.Base_interface.Coerce.t_Concretization Core.Base.Spec.Z.t_Z t_I128 = + { + f_concretize_pre = (fun (self: Core.Base.Spec.Z.t_Z) -> true); + f_concretize_post = (fun (self: Core.Base.Spec.Z.t_Z) (out: t_I128) -> true); + f_concretize = fun (self: Core.Base.Spec.Z.t_Z) -> { f_v = self } <: t_I128 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_64: Core.Clone.t_Clone t_I128 = + { + f_clone_pre = (fun (self: t_I128) -> true); + f_clone_post = (fun (self: t_I128) (out: t_I128) -> true); + f_clone + = + fun (self: t_I128) -> + { f_v = Core.Clone.f_clone #Core.Base.Spec.Z.t_Z #FStar.Tactics.Typeclasses.solve self.f_v } + <: + t_I128 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_70: Core.Base_interface.Coerce.t_Concretization Core.Base.Spec.Z.t_Z t_I64 = + { + f_concretize_pre = (fun (self: Core.Base.Spec.Z.t_Z) -> true); + f_concretize_post = (fun (self: Core.Base.Spec.Z.t_Z) (out: t_I64) -> true); + f_concretize = fun (self: Core.Base.Spec.Z.t_Z) -> { f_v = self } <: t_I64 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_91: Core.Clone.t_Clone t_I64 = + { + f_clone_pre = (fun (self: t_I64) -> true); + f_clone_post = (fun (self: t_I64) (out: t_I64) -> true); + f_clone + = + fun (self: t_I64) -> + { f_v = Core.Clone.f_clone #Core.Base.Spec.Z.t_Z #FStar.Tactics.Typeclasses.solve self.f_v } + <: + t_I64 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_97: Core.Base_interface.Coerce.t_Concretization Core.Base.Spec.Z.t_Z t_I32 = + { + f_concretize_pre = (fun (self: Core.Base.Spec.Z.t_Z) -> true); + f_concretize_post = (fun (self: Core.Base.Spec.Z.t_Z) (out: t_I32) -> true); + f_concretize = fun (self: Core.Base.Spec.Z.t_Z) -> { f_v = self } <: t_I32 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_118: Core.Clone.t_Clone t_I32 = + { + f_clone_pre = (fun (self: t_I32) -> true); + f_clone_post = (fun (self: t_I32) (out: t_I32) -> true); + f_clone + = + fun (self: t_I32) -> + { f_v = Core.Clone.f_clone #Core.Base.Spec.Z.t_Z #FStar.Tactics.Typeclasses.solve self.f_v } + <: + t_I32 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_124: Core.Base_interface.Coerce.t_Concretization Core.Base.Spec.Z.t_Z t_I16 = + { + f_concretize_pre = (fun (self: Core.Base.Spec.Z.t_Z) -> true); + f_concretize_post = (fun (self: Core.Base.Spec.Z.t_Z) (out: t_I16) -> true); + f_concretize = fun (self: Core.Base.Spec.Z.t_Z) -> { f_v = self } <: t_I16 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_145: Core.Clone.t_Clone t_I16 = + { + f_clone_pre = (fun (self: t_I16) -> true); + f_clone_post = (fun (self: t_I16) (out: t_I16) -> true); + f_clone + = + fun (self: t_I16) -> + { f_v = Core.Clone.f_clone #Core.Base.Spec.Z.t_Z #FStar.Tactics.Typeclasses.solve self.f_v } + <: + t_I16 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_151: Core.Base_interface.Coerce.t_Concretization Core.Base.Spec.Z.t_Z t_I8 = + { + f_concretize_pre = (fun (self: Core.Base.Spec.Z.t_Z) -> true); + f_concretize_post = (fun (self: Core.Base.Spec.Z.t_Z) (out: t_I8) -> true); + f_concretize = fun (self: Core.Base.Spec.Z.t_Z) -> { f_v = self } <: t_I8 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_172: Core.Clone.t_Clone t_I8 = + { + f_clone_pre = (fun (self: t_I8) -> true); + f_clone_post = (fun (self: t_I8) (out: t_I8) -> true); + f_clone + = + fun (self: t_I8) -> + { f_v = Core.Clone.f_clone #Core.Base.Spec.Z.t_Z #FStar.Tactics.Typeclasses.solve self.f_v } + <: + t_I8 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_40: t_Constants t_I128 = + { + f_ZERO = { f_v = Core.Base.Spec.Z.Z_ZERO <: Core.Base.Spec.Z.t_Z } <: t_I128; + f_ONE + = + { f_v = Core.Base.Spec.Z.Z_POS Core.Base.Spec.Binary.Positive.xH <: Core.Base.Spec.Z.t_Z } + <: + t_I128; + f_MIN = { f_v = Core.Base.Spec.Constants.v_NEG_WORDSIZE_128_ } <: t_I128; + f_MAX = { f_v = Core.Base.Spec.Constants.v_POS_WORDSIZE_128_ } <: t_I128 + } + +let impl_41__BITS: t_U32 = { f_v = Core.Base.Spec.Constants.v_BITS_128_ } <: t_U32 + +let impl_41__WORDSIZE: Core.Base.Spec.Haxint.t_HaxInt = Core.Base.Spec.Constants.v_WORDSIZE_128_ + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_67: t_Constants t_I64 = + { + f_ZERO = { f_v = Core.Base.Spec.Z.Z_ZERO <: Core.Base.Spec.Z.t_Z } <: t_I64; + f_ONE + = + { f_v = Core.Base.Spec.Z.Z_POS Core.Base.Spec.Binary.Positive.xH <: Core.Base.Spec.Z.t_Z } + <: + t_I64; + f_MIN = { f_v = Core.Base.Spec.Constants.v_NEG_WORDSIZE_64_ } <: t_I64; + f_MAX = { f_v = Core.Base.Spec.Constants.v_POS_WORDSIZE_64_ } <: t_I64 + } + +let impl_68__BITS: t_U32 = { f_v = Core.Base.Spec.Constants.v_BITS_64_ } <: t_U32 + +let impl_68__WORDSIZE: Core.Base.Spec.Haxint.t_HaxInt = Core.Base.Spec.Constants.v_WORDSIZE_64_ + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_94: t_Constants t_I32 = + { + f_ZERO = { f_v = Core.Base.Spec.Z.Z_ZERO <: Core.Base.Spec.Z.t_Z } <: t_I32; + f_ONE + = + { f_v = Core.Base.Spec.Z.Z_POS Core.Base.Spec.Binary.Positive.xH <: Core.Base.Spec.Z.t_Z } + <: + t_I32; + f_MIN = { f_v = Core.Base.Spec.Constants.v_NEG_WORDSIZE_32_ } <: t_I32; + f_MAX = { f_v = Core.Base.Spec.Constants.v_POS_WORDSIZE_32_ } <: t_I32 + } + +let impl_95__BITS: t_U32 = { f_v = Core.Base.Spec.Constants.v_BITS_32_ } <: t_U32 + +let impl_95__WORDSIZE: Core.Base.Spec.Haxint.t_HaxInt = Core.Base.Spec.Constants.v_WORDSIZE_32_ + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_121: t_Constants t_I16 = + { + f_ZERO = { f_v = Core.Base.Spec.Z.Z_ZERO <: Core.Base.Spec.Z.t_Z } <: t_I16; + f_ONE + = + { f_v = Core.Base.Spec.Z.Z_POS Core.Base.Spec.Binary.Positive.xH <: Core.Base.Spec.Z.t_Z } + <: + t_I16; + f_MIN = { f_v = Core.Base.Spec.Constants.v_NEG_WORDSIZE_16_ } <: t_I16; + f_MAX = { f_v = Core.Base.Spec.Constants.v_POS_WORDSIZE_16_ } <: t_I16 + } + +let impl_122__BITS: t_U32 = { f_v = Core.Base.Spec.Constants.v_BITS_16_ } <: t_U32 + +let impl_122__WORDSIZE: Core.Base.Spec.Haxint.t_HaxInt = Core.Base.Spec.Constants.v_WORDSIZE_16_ + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_148: t_Constants t_I8 = + { + f_ZERO = { f_v = Core.Base.Spec.Z.Z_ZERO <: Core.Base.Spec.Z.t_Z } <: t_I8; + f_ONE + = + { f_v = Core.Base.Spec.Z.Z_POS Core.Base.Spec.Binary.Positive.xH <: Core.Base.Spec.Z.t_Z } + <: + t_I8; + f_MIN = { f_v = Core.Base.Spec.Constants.v_NEG_WORDSIZE_8_ } <: t_I8; + f_MAX = { f_v = Core.Base.Spec.Constants.v_POS_WORDSIZE_8_ } <: t_I8 + } + +let impl_149__BITS: t_U32 = { f_v = Core.Base.Spec.Constants.v_BITS_8_ } <: t_U32 + +let impl_149__WORDSIZE: Core.Base.Spec.Haxint.t_HaxInt = Core.Base.Spec.Constants.v_WORDSIZE_8_ + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_175: t_Constants t_U128 = + { + f_ZERO = { f_v = Core.Base.Spec.Haxint.v_HaxInt_ZERO } <: t_U128; + f_ONE = { f_v = Core.Base.Spec.Haxint.v_HaxInt_ONE } <: t_U128; + f_MIN = { f_v = Core.Base.Spec.Haxint.v_HaxInt_ZERO } <: t_U128; + f_MAX = { f_v = Core.Base.Spec.Constants.v_WORDSIZE_128_SUB_1_ } <: t_U128 + } + +let impl_176__BITS: t_U32 = { f_v = Core.Base.Spec.Constants.v_BITS_128_ } <: t_U32 + +let impl_176__WORDSIZE: Core.Base.Spec.Haxint.t_HaxInt = Core.Base.Spec.Constants.v_WORDSIZE_128_ + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_202: t_Constants t_U64 = + { + f_ZERO = { f_v = Core.Base.Spec.Haxint.v_HaxInt_ZERO } <: t_U64; + f_ONE = { f_v = Core.Base.Spec.Haxint.v_HaxInt_ONE } <: t_U64; + f_MIN = { f_v = Core.Base.Spec.Haxint.v_HaxInt_ZERO } <: t_U64; + f_MAX = { f_v = Core.Base.Spec.Constants.v_WORDSIZE_64_SUB_1_ } <: t_U64 + } + +let impl_203__BITS: t_U32 = { f_v = Core.Base.Spec.Constants.v_BITS_64_ } <: t_U32 + +let impl_203__WORDSIZE: Core.Base.Spec.Haxint.t_HaxInt = Core.Base.Spec.Constants.v_WORDSIZE_64_ + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_229: t_Constants t_U32 = + { + f_ZERO = { f_v = Core.Base.Spec.Haxint.v_HaxInt_ZERO } <: t_U32; + f_ONE = { f_v = Core.Base.Spec.Haxint.v_HaxInt_ONE } <: t_U32; + f_MIN = { f_v = Core.Base.Spec.Haxint.v_HaxInt_ZERO } <: t_U32; + f_MAX = { f_v = Core.Base.Spec.Constants.v_WORDSIZE_32_SUB_1_ } <: t_U32 + } + +let impl_230__BITS: t_U32 = { f_v = Core.Base.Spec.Constants.v_BITS_32_ } <: t_U32 + +let impl_230__WORDSIZE: Core.Base.Spec.Haxint.t_HaxInt = Core.Base.Spec.Constants.v_WORDSIZE_32_ + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_256: t_Constants t_U16 = + { + f_ZERO = { f_v = Core.Base.Spec.Haxint.v_HaxInt_ZERO } <: t_U16; + f_ONE = { f_v = Core.Base.Spec.Haxint.v_HaxInt_ONE } <: t_U16; + f_MIN = { f_v = Core.Base.Spec.Haxint.v_HaxInt_ZERO } <: t_U16; + f_MAX = { f_v = Core.Base.Spec.Constants.v_WORDSIZE_16_SUB_1_ } <: t_U16 + } + +let impl_257__BITS: t_U32 = { f_v = Core.Base.Spec.Constants.v_BITS_16_ } <: t_U32 + +let impl_257__WORDSIZE: Core.Base.Spec.Haxint.t_HaxInt = Core.Base.Spec.Constants.v_WORDSIZE_16_ + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_283: t_Constants t_U8 = + { + f_ZERO = { f_v = Core.Base.Spec.Haxint.v_HaxInt_ZERO } <: t_U8; + f_ONE = { f_v = Core.Base.Spec.Haxint.v_HaxInt_ONE } <: t_U8; + f_MIN = { f_v = Core.Base.Spec.Haxint.v_HaxInt_ZERO } <: t_U8; + f_MAX = { f_v = Core.Base.Spec.Constants.v_WORDSIZE_8_SUB_1_ } <: t_U8 + } + +let impl_284__BITS: t_U32 = { f_v = Core.Base.Spec.Constants.v_BITS_8_ } <: t_U32 + +let impl_284__WORDSIZE: Core.Base.Spec.Haxint.t_HaxInt = Core.Base.Spec.Constants.v_WORDSIZE_8_ + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_199: Core.Clone.t_Clone t_U128 = + { + f_clone_pre = (fun (self: t_U128) -> true); + f_clone_post = (fun (self: t_U128) (out: t_U128) -> true); + f_clone + = + fun (self: t_U128) -> + { + f_v + = + Core.Clone.f_clone #Core.Base.Spec.Haxint.t_HaxInt #FStar.Tactics.Typeclasses.solve self.f_v + } + <: + t_U128 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_226: Core.Clone.t_Clone t_U64 = + { + f_clone_pre = (fun (self: t_U64) -> true); + f_clone_post = (fun (self: t_U64) (out: t_U64) -> true); + f_clone + = + fun (self: t_U64) -> + { + f_v + = + Core.Clone.f_clone #Core.Base.Spec.Haxint.t_HaxInt #FStar.Tactics.Typeclasses.solve self.f_v + } + <: + t_U64 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_253: Core.Clone.t_Clone t_U32 = + { + f_clone_pre = (fun (self: t_U32) -> true); + f_clone_post = (fun (self: t_U32) (out: t_U32) -> true); + f_clone + = + fun (self: t_U32) -> + { + f_v + = + Core.Clone.f_clone #Core.Base.Spec.Haxint.t_HaxInt #FStar.Tactics.Typeclasses.solve self.f_v + } + <: + t_U32 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_280: Core.Clone.t_Clone t_U16 = + { + f_clone_pre = (fun (self: t_U16) -> true); + f_clone_post = (fun (self: t_U16) (out: t_U16) -> true); + f_clone + = + fun (self: t_U16) -> + { + f_v + = + Core.Clone.f_clone #Core.Base.Spec.Haxint.t_HaxInt #FStar.Tactics.Typeclasses.solve self.f_v + } + <: + t_U16 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_307: Core.Clone.t_Clone t_U8 = + { + f_clone_pre = (fun (self: t_U8) -> true); + f_clone_post = (fun (self: t_U8) (out: t_U8) -> true); + f_clone + = + fun (self: t_U8) -> + { + f_v + = + Core.Clone.f_clone #Core.Base.Spec.Haxint.t_HaxInt #FStar.Tactics.Typeclasses.solve self.f_v + } + <: + t_U8 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_42: Core.Base_interface.Coerce.t_Abstraction t_I128 = + { + f_AbstractType = Core.Base.Spec.Z.t_Z; + f_lift_pre = (fun (self: t_I128) -> true); + f_lift_post = (fun (self: t_I128) (out: Core.Base.Spec.Z.t_Z) -> true); + f_lift = fun (self: t_I128) -> self.f_v + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_36: Core.Convert.t_From t_I8 t_I128 = + { + f_from_pre = (fun (x: t_I128) -> true); + f_from_post = (fun (x: t_I128) (out: t_I8) -> true); + f_from + = + fun (x: t_I128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I8 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #t_I128 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_37: Core.Convert.t_From t_I16 t_I128 = + { + f_from_pre = (fun (x: t_I128) -> true); + f_from_post = (fun (x: t_I128) (out: t_I16) -> true); + f_from + = + fun (x: t_I128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I16 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #t_I128 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_38: Core.Convert.t_From t_I32 t_I128 = + { + f_from_pre = (fun (x: t_I128) -> true); + f_from_post = (fun (x: t_I128) (out: t_I32) -> true); + f_from + = + fun (x: t_I128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I32 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #t_I128 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_39: Core.Convert.t_From t_I64 t_I128 = + { + f_from_pre = (fun (x: t_I128) -> true); + f_from_post = (fun (x: t_I128) (out: t_I64) -> true); + f_from + = + fun (x: t_I128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I64 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #t_I128 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_65: Core.Cmp.t_PartialEq t_I128 t_I128 = + { + f_eq_pre = (fun (self: t_I128) (rhs: t_I128) -> true); + f_eq_post = (fun (self: t_I128) (rhs: t_I128) (out: bool) -> true); + f_eq + = + (fun (self: t_I128) (rhs: t_I128) -> + (Core.Base.Z.z_cmp (Core.Base_interface.Coerce.f_lift #t_I128 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I128 #FStar.Tactics.Typeclasses.solve self <: t_I128) + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I128 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I128 #FStar.Tactics.Typeclasses.solve rhs <: t_I128) + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Cmp.t_Ordering) =. + (Core.Cmp.Ordering_Equal <: Core.Cmp.t_Ordering)); + f_ne_pre = (fun (self: t_I128) (rhs: t_I128) -> true); + f_ne_post = (fun (self: t_I128) (rhs: t_I128) (out: bool) -> true); + f_ne + = + fun (self: t_I128) (rhs: t_I128) -> + (Core.Base.Z.z_cmp (Core.Base_interface.Coerce.f_lift #t_I128 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I128 #FStar.Tactics.Typeclasses.solve self <: t_I128) + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I128 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I128 #FStar.Tactics.Typeclasses.solve rhs <: t_I128) + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Cmp.t_Ordering) <>. + (Core.Cmp.Ordering_Equal <: Core.Cmp.t_Ordering) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_66: Core.Cmp.t_PartialOrd t_I128 t_I128 = + { + _super_9014672428308350468 = FStar.Tactics.Typeclasses.solve; + f_partial_cmp_pre = (fun (self: t_I128) (rhs: t_I128) -> true); + f_partial_cmp_post + = + (fun (self: t_I128) (rhs: t_I128) (out: Core.Option.t_Option Core.Cmp.t_Ordering) -> true); + f_partial_cmp + = + (fun (self: t_I128) (rhs: t_I128) -> + Core.Option.Option_Some + (Core.Base.Z.z_cmp (Core.Base_interface.Coerce.f_lift #t_I128 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I128 #FStar.Tactics.Typeclasses.solve self <: t_I128) + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I128 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I128 #FStar.Tactics.Typeclasses.solve rhs <: t_I128) + <: + Core.Base.Spec.Z.t_Z)) + <: + Core.Option.t_Option Core.Cmp.t_Ordering); + f_lt_pre = (fun (self: t_I128) (rhs: t_I128) -> true); + f_lt_post = (fun (self: t_I128) (rhs: t_I128) (out: bool) -> true); + f_lt + = + (fun (self: t_I128) (rhs: t_I128) -> + match + Core.Base.Z.z_cmp (Core.Base_interface.Coerce.f_lift #t_I128 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I128 #FStar.Tactics.Typeclasses.solve self <: t_I128) + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I128 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I128 #FStar.Tactics.Typeclasses.solve rhs <: t_I128) + <: + Core.Base.Spec.Z.t_Z) + with + | Core.Cmp.Ordering_Less -> true + | _ -> false); + f_le_pre = (fun (self: t_I128) (rhs: t_I128) -> true); + f_le_post = (fun (self: t_I128) (rhs: t_I128) (out: bool) -> true); + f_le + = + (fun (self: t_I128) (rhs: t_I128) -> + match + Core.Base.Z.z_cmp (Core.Base_interface.Coerce.f_lift #t_I128 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I128 #FStar.Tactics.Typeclasses.solve self <: t_I128) + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I128 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I128 #FStar.Tactics.Typeclasses.solve rhs <: t_I128) + <: + Core.Base.Spec.Z.t_Z) + with + | Core.Cmp.Ordering_Less | Core.Cmp.Ordering_Equal -> true + | _ -> false); + f_gt_pre = (fun (self: t_I128) (rhs: t_I128) -> true); + f_gt_post = (fun (self: t_I128) (rhs: t_I128) (out: bool) -> true); + f_gt + = + (fun (self: t_I128) (rhs: t_I128) -> + match + Core.Base.Z.z_cmp (Core.Base_interface.Coerce.f_lift #t_I128 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I128 #FStar.Tactics.Typeclasses.solve self <: t_I128) + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I128 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I128 #FStar.Tactics.Typeclasses.solve rhs <: t_I128) + <: + Core.Base.Spec.Z.t_Z) + with + | Core.Cmp.Ordering_Greater -> true + | _ -> false); + f_ge_pre = (fun (self: t_I128) (rhs: t_I128) -> true); + f_ge_post = (fun (self: t_I128) (rhs: t_I128) (out: bool) -> true); + f_ge + = + fun (self: t_I128) (rhs: t_I128) -> + match + Core.Base.Z.z_cmp (Core.Base_interface.Coerce.f_lift #t_I128 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I128 #FStar.Tactics.Typeclasses.solve self <: t_I128) + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I128 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I128 #FStar.Tactics.Typeclasses.solve rhs <: t_I128) + <: + Core.Base.Spec.Z.t_Z) + with + | Core.Cmp.Ordering_Greater | Core.Cmp.Ordering_Equal -> true + | _ -> false + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_69: Core.Base_interface.Coerce.t_Abstraction t_I64 = + { + f_AbstractType = Core.Base.Spec.Z.t_Z; + f_lift_pre = (fun (self: t_I64) -> true); + f_lift_post = (fun (self: t_I64) (out: Core.Base.Spec.Z.t_Z) -> true); + f_lift = fun (self: t_I64) -> self.f_v + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_32: Core.Convert.t_From t_I8 t_I64 = + { + f_from_pre = (fun (x: t_I64) -> true); + f_from_post = (fun (x: t_I64) (out: t_I8) -> true); + f_from + = + fun (x: t_I64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I8 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #t_I64 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_33: Core.Convert.t_From t_I16 t_I64 = + { + f_from_pre = (fun (x: t_I64) -> true); + f_from_post = (fun (x: t_I64) (out: t_I16) -> true); + f_from + = + fun (x: t_I64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I16 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #t_I64 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_34: Core.Convert.t_From t_I32 t_I64 = + { + f_from_pre = (fun (x: t_I64) -> true); + f_from_post = (fun (x: t_I64) (out: t_I32) -> true); + f_from + = + fun (x: t_I64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I32 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #t_I64 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_35: Core.Convert.t_From t_I128 t_I64 = + { + f_from_pre = (fun (x: t_I64) -> true); + f_from_post = (fun (x: t_I64) (out: t_I128) -> true); + f_from + = + fun (x: t_I64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I128 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #t_I64 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_92: Core.Cmp.t_PartialEq t_I64 t_I64 = + { + f_eq_pre = (fun (self: t_I64) (rhs: t_I64) -> true); + f_eq_post = (fun (self: t_I64) (rhs: t_I64) (out: bool) -> true); + f_eq + = + (fun (self: t_I64) (rhs: t_I64) -> + (Core.Base.Z.z_cmp (Core.Base_interface.Coerce.f_lift #t_I64 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I64 #FStar.Tactics.Typeclasses.solve self <: t_I64) + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I64 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I64 #FStar.Tactics.Typeclasses.solve rhs <: t_I64) + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Cmp.t_Ordering) =. + (Core.Cmp.Ordering_Equal <: Core.Cmp.t_Ordering)); + f_ne_pre = (fun (self: t_I64) (rhs: t_I64) -> true); + f_ne_post = (fun (self: t_I64) (rhs: t_I64) (out: bool) -> true); + f_ne + = + fun (self: t_I64) (rhs: t_I64) -> + (Core.Base.Z.z_cmp (Core.Base_interface.Coerce.f_lift #t_I64 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I64 #FStar.Tactics.Typeclasses.solve self <: t_I64) + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I64 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I64 #FStar.Tactics.Typeclasses.solve rhs <: t_I64) + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Cmp.t_Ordering) <>. + (Core.Cmp.Ordering_Equal <: Core.Cmp.t_Ordering) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_93: Core.Cmp.t_PartialOrd t_I64 t_I64 = + { + _super_9014672428308350468 = FStar.Tactics.Typeclasses.solve; + f_partial_cmp_pre = (fun (self: t_I64) (rhs: t_I64) -> true); + f_partial_cmp_post + = + (fun (self: t_I64) (rhs: t_I64) (out: Core.Option.t_Option Core.Cmp.t_Ordering) -> true); + f_partial_cmp + = + (fun (self: t_I64) (rhs: t_I64) -> + Core.Option.Option_Some + (Core.Base.Z.z_cmp (Core.Base_interface.Coerce.f_lift #t_I64 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I64 #FStar.Tactics.Typeclasses.solve self <: t_I64) + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I64 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I64 #FStar.Tactics.Typeclasses.solve rhs <: t_I64) + <: + Core.Base.Spec.Z.t_Z)) + <: + Core.Option.t_Option Core.Cmp.t_Ordering); + f_lt_pre = (fun (self: t_I64) (rhs: t_I64) -> true); + f_lt_post = (fun (self: t_I64) (rhs: t_I64) (out: bool) -> true); + f_lt + = + (fun (self: t_I64) (rhs: t_I64) -> + match + Core.Base.Z.z_cmp (Core.Base_interface.Coerce.f_lift #t_I64 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I64 #FStar.Tactics.Typeclasses.solve self <: t_I64) + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I64 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I64 #FStar.Tactics.Typeclasses.solve rhs <: t_I64) + <: + Core.Base.Spec.Z.t_Z) + with + | Core.Cmp.Ordering_Less -> true + | _ -> false); + f_le_pre = (fun (self: t_I64) (rhs: t_I64) -> true); + f_le_post = (fun (self: t_I64) (rhs: t_I64) (out: bool) -> true); + f_le + = + (fun (self: t_I64) (rhs: t_I64) -> + match + Core.Base.Z.z_cmp (Core.Base_interface.Coerce.f_lift #t_I64 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I64 #FStar.Tactics.Typeclasses.solve self <: t_I64) + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I64 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I64 #FStar.Tactics.Typeclasses.solve rhs <: t_I64) + <: + Core.Base.Spec.Z.t_Z) + with + | Core.Cmp.Ordering_Less | Core.Cmp.Ordering_Equal -> true + | _ -> false); + f_gt_pre = (fun (self: t_I64) (rhs: t_I64) -> true); + f_gt_post = (fun (self: t_I64) (rhs: t_I64) (out: bool) -> true); + f_gt + = + (fun (self: t_I64) (rhs: t_I64) -> + match + Core.Base.Z.z_cmp (Core.Base_interface.Coerce.f_lift #t_I64 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I64 #FStar.Tactics.Typeclasses.solve self <: t_I64) + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I64 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I64 #FStar.Tactics.Typeclasses.solve rhs <: t_I64) + <: + Core.Base.Spec.Z.t_Z) + with + | Core.Cmp.Ordering_Greater -> true + | _ -> false); + f_ge_pre = (fun (self: t_I64) (rhs: t_I64) -> true); + f_ge_post = (fun (self: t_I64) (rhs: t_I64) (out: bool) -> true); + f_ge + = + fun (self: t_I64) (rhs: t_I64) -> + match + Core.Base.Z.z_cmp (Core.Base_interface.Coerce.f_lift #t_I64 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I64 #FStar.Tactics.Typeclasses.solve self <: t_I64) + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I64 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I64 #FStar.Tactics.Typeclasses.solve rhs <: t_I64) + <: + Core.Base.Spec.Z.t_Z) + with + | Core.Cmp.Ordering_Greater | Core.Cmp.Ordering_Equal -> true + | _ -> false + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_96: Core.Base_interface.Coerce.t_Abstraction t_I32 = + { + f_AbstractType = Core.Base.Spec.Z.t_Z; + f_lift_pre = (fun (self: t_I32) -> true); + f_lift_post = (fun (self: t_I32) (out: Core.Base.Spec.Z.t_Z) -> true); + f_lift = fun (self: t_I32) -> self.f_v + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_28: Core.Convert.t_From t_I8 t_I32 = + { + f_from_pre = (fun (x: t_I32) -> true); + f_from_post = (fun (x: t_I32) (out: t_I8) -> true); + f_from + = + fun (x: t_I32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I8 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #t_I32 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_29: Core.Convert.t_From t_I16 t_I32 = + { + f_from_pre = (fun (x: t_I32) -> true); + f_from_post = (fun (x: t_I32) (out: t_I16) -> true); + f_from + = + fun (x: t_I32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I16 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #t_I32 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_30: Core.Convert.t_From t_I64 t_I32 = + { + f_from_pre = (fun (x: t_I32) -> true); + f_from_post = (fun (x: t_I32) (out: t_I64) -> true); + f_from + = + fun (x: t_I32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I64 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #t_I32 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_31: Core.Convert.t_From t_I128 t_I32 = + { + f_from_pre = (fun (x: t_I32) -> true); + f_from_post = (fun (x: t_I32) (out: t_I128) -> true); + f_from + = + fun (x: t_I32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I128 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #t_I32 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_119: Core.Cmp.t_PartialEq t_I32 t_I32 = + { + f_eq_pre = (fun (self: t_I32) (rhs: t_I32) -> true); + f_eq_post = (fun (self: t_I32) (rhs: t_I32) (out: bool) -> true); + f_eq + = + (fun (self: t_I32) (rhs: t_I32) -> + (Core.Base.Z.z_cmp (Core.Base_interface.Coerce.f_lift #t_I32 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I32 #FStar.Tactics.Typeclasses.solve self <: t_I32) + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I32 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I32 #FStar.Tactics.Typeclasses.solve rhs <: t_I32) + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Cmp.t_Ordering) =. + (Core.Cmp.Ordering_Equal <: Core.Cmp.t_Ordering)); + f_ne_pre = (fun (self: t_I32) (rhs: t_I32) -> true); + f_ne_post = (fun (self: t_I32) (rhs: t_I32) (out: bool) -> true); + f_ne + = + fun (self: t_I32) (rhs: t_I32) -> + (Core.Base.Z.z_cmp (Core.Base_interface.Coerce.f_lift #t_I32 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I32 #FStar.Tactics.Typeclasses.solve self <: t_I32) + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I32 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I32 #FStar.Tactics.Typeclasses.solve rhs <: t_I32) + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Cmp.t_Ordering) <>. + (Core.Cmp.Ordering_Equal <: Core.Cmp.t_Ordering) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_120: Core.Cmp.t_PartialOrd t_I32 t_I32 = + { + _super_9014672428308350468 = FStar.Tactics.Typeclasses.solve; + f_partial_cmp_pre = (fun (self: t_I32) (rhs: t_I32) -> true); + f_partial_cmp_post + = + (fun (self: t_I32) (rhs: t_I32) (out: Core.Option.t_Option Core.Cmp.t_Ordering) -> true); + f_partial_cmp + = + (fun (self: t_I32) (rhs: t_I32) -> + Core.Option.Option_Some + (Core.Base.Z.z_cmp (Core.Base_interface.Coerce.f_lift #t_I32 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I32 #FStar.Tactics.Typeclasses.solve self <: t_I32) + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I32 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I32 #FStar.Tactics.Typeclasses.solve rhs <: t_I32) + <: + Core.Base.Spec.Z.t_Z)) + <: + Core.Option.t_Option Core.Cmp.t_Ordering); + f_lt_pre = (fun (self: t_I32) (rhs: t_I32) -> true); + f_lt_post = (fun (self: t_I32) (rhs: t_I32) (out: bool) -> true); + f_lt + = + (fun (self: t_I32) (rhs: t_I32) -> + match + Core.Base.Z.z_cmp (Core.Base_interface.Coerce.f_lift #t_I32 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I32 #FStar.Tactics.Typeclasses.solve self <: t_I32) + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I32 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I32 #FStar.Tactics.Typeclasses.solve rhs <: t_I32) + <: + Core.Base.Spec.Z.t_Z) + with + | Core.Cmp.Ordering_Less -> true + | _ -> false); + f_le_pre = (fun (self: t_I32) (rhs: t_I32) -> true); + f_le_post = (fun (self: t_I32) (rhs: t_I32) (out: bool) -> true); + f_le + = + (fun (self: t_I32) (rhs: t_I32) -> + match + Core.Base.Z.z_cmp (Core.Base_interface.Coerce.f_lift #t_I32 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I32 #FStar.Tactics.Typeclasses.solve self <: t_I32) + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I32 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I32 #FStar.Tactics.Typeclasses.solve rhs <: t_I32) + <: + Core.Base.Spec.Z.t_Z) + with + | Core.Cmp.Ordering_Less | Core.Cmp.Ordering_Equal -> true + | _ -> false); + f_gt_pre = (fun (self: t_I32) (rhs: t_I32) -> true); + f_gt_post = (fun (self: t_I32) (rhs: t_I32) (out: bool) -> true); + f_gt + = + (fun (self: t_I32) (rhs: t_I32) -> + match + Core.Base.Z.z_cmp (Core.Base_interface.Coerce.f_lift #t_I32 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I32 #FStar.Tactics.Typeclasses.solve self <: t_I32) + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I32 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I32 #FStar.Tactics.Typeclasses.solve rhs <: t_I32) + <: + Core.Base.Spec.Z.t_Z) + with + | Core.Cmp.Ordering_Greater -> true + | _ -> false); + f_ge_pre = (fun (self: t_I32) (rhs: t_I32) -> true); + f_ge_post = (fun (self: t_I32) (rhs: t_I32) (out: bool) -> true); + f_ge + = + fun (self: t_I32) (rhs: t_I32) -> + match + Core.Base.Z.z_cmp (Core.Base_interface.Coerce.f_lift #t_I32 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I32 #FStar.Tactics.Typeclasses.solve self <: t_I32) + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I32 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I32 #FStar.Tactics.Typeclasses.solve rhs <: t_I32) + <: + Core.Base.Spec.Z.t_Z) + with + | Core.Cmp.Ordering_Greater | Core.Cmp.Ordering_Equal -> true + | _ -> false + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_123: Core.Base_interface.Coerce.t_Abstraction t_I16 = + { + f_AbstractType = Core.Base.Spec.Z.t_Z; + f_lift_pre = (fun (self: t_I16) -> true); + f_lift_post = (fun (self: t_I16) (out: Core.Base.Spec.Z.t_Z) -> true); + f_lift = fun (self: t_I16) -> self.f_v + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_24: Core.Convert.t_From t_I8 t_I16 = + { + f_from_pre = (fun (x: t_I16) -> true); + f_from_post = (fun (x: t_I16) (out: t_I8) -> true); + f_from + = + fun (x: t_I16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I8 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #t_I16 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_25: Core.Convert.t_From t_I32 t_I16 = + { + f_from_pre = (fun (x: t_I16) -> true); + f_from_post = (fun (x: t_I16) (out: t_I32) -> true); + f_from + = + fun (x: t_I16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I32 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #t_I16 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_26: Core.Convert.t_From t_I64 t_I16 = + { + f_from_pre = (fun (x: t_I16) -> true); + f_from_post = (fun (x: t_I16) (out: t_I64) -> true); + f_from + = + fun (x: t_I16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I64 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #t_I16 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_27: Core.Convert.t_From t_I128 t_I16 = + { + f_from_pre = (fun (x: t_I16) -> true); + f_from_post = (fun (x: t_I16) (out: t_I128) -> true); + f_from + = + fun (x: t_I16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I128 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #t_I16 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_146: Core.Cmp.t_PartialEq t_I16 t_I16 = + { + f_eq_pre = (fun (self: t_I16) (rhs: t_I16) -> true); + f_eq_post = (fun (self: t_I16) (rhs: t_I16) (out: bool) -> true); + f_eq + = + (fun (self: t_I16) (rhs: t_I16) -> + (Core.Base.Z.z_cmp (Core.Base_interface.Coerce.f_lift #t_I16 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I16 #FStar.Tactics.Typeclasses.solve self <: t_I16) + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I16 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I16 #FStar.Tactics.Typeclasses.solve rhs <: t_I16) + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Cmp.t_Ordering) =. + (Core.Cmp.Ordering_Equal <: Core.Cmp.t_Ordering)); + f_ne_pre = (fun (self: t_I16) (rhs: t_I16) -> true); + f_ne_post = (fun (self: t_I16) (rhs: t_I16) (out: bool) -> true); + f_ne + = + fun (self: t_I16) (rhs: t_I16) -> + (Core.Base.Z.z_cmp (Core.Base_interface.Coerce.f_lift #t_I16 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I16 #FStar.Tactics.Typeclasses.solve self <: t_I16) + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I16 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I16 #FStar.Tactics.Typeclasses.solve rhs <: t_I16) + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Cmp.t_Ordering) <>. + (Core.Cmp.Ordering_Equal <: Core.Cmp.t_Ordering) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_147: Core.Cmp.t_PartialOrd t_I16 t_I16 = + { + _super_9014672428308350468 = FStar.Tactics.Typeclasses.solve; + f_partial_cmp_pre = (fun (self: t_I16) (rhs: t_I16) -> true); + f_partial_cmp_post + = + (fun (self: t_I16) (rhs: t_I16) (out: Core.Option.t_Option Core.Cmp.t_Ordering) -> true); + f_partial_cmp + = + (fun (self: t_I16) (rhs: t_I16) -> + Core.Option.Option_Some + (Core.Base.Z.z_cmp (Core.Base_interface.Coerce.f_lift #t_I16 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I16 #FStar.Tactics.Typeclasses.solve self <: t_I16) + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I16 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I16 #FStar.Tactics.Typeclasses.solve rhs <: t_I16) + <: + Core.Base.Spec.Z.t_Z)) + <: + Core.Option.t_Option Core.Cmp.t_Ordering); + f_lt_pre = (fun (self: t_I16) (rhs: t_I16) -> true); + f_lt_post = (fun (self: t_I16) (rhs: t_I16) (out: bool) -> true); + f_lt + = + (fun (self: t_I16) (rhs: t_I16) -> + match + Core.Base.Z.z_cmp (Core.Base_interface.Coerce.f_lift #t_I16 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I16 #FStar.Tactics.Typeclasses.solve self <: t_I16) + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I16 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I16 #FStar.Tactics.Typeclasses.solve rhs <: t_I16) + <: + Core.Base.Spec.Z.t_Z) + with + | Core.Cmp.Ordering_Less -> true + | _ -> false); + f_le_pre = (fun (self: t_I16) (rhs: t_I16) -> true); + f_le_post = (fun (self: t_I16) (rhs: t_I16) (out: bool) -> true); + f_le + = + (fun (self: t_I16) (rhs: t_I16) -> + match + Core.Base.Z.z_cmp (Core.Base_interface.Coerce.f_lift #t_I16 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I16 #FStar.Tactics.Typeclasses.solve self <: t_I16) + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I16 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I16 #FStar.Tactics.Typeclasses.solve rhs <: t_I16) + <: + Core.Base.Spec.Z.t_Z) + with + | Core.Cmp.Ordering_Less | Core.Cmp.Ordering_Equal -> true + | _ -> false); + f_gt_pre = (fun (self: t_I16) (rhs: t_I16) -> true); + f_gt_post = (fun (self: t_I16) (rhs: t_I16) (out: bool) -> true); + f_gt + = + (fun (self: t_I16) (rhs: t_I16) -> + match + Core.Base.Z.z_cmp (Core.Base_interface.Coerce.f_lift #t_I16 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I16 #FStar.Tactics.Typeclasses.solve self <: t_I16) + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I16 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I16 #FStar.Tactics.Typeclasses.solve rhs <: t_I16) + <: + Core.Base.Spec.Z.t_Z) + with + | Core.Cmp.Ordering_Greater -> true + | _ -> false); + f_ge_pre = (fun (self: t_I16) (rhs: t_I16) -> true); + f_ge_post = (fun (self: t_I16) (rhs: t_I16) (out: bool) -> true); + f_ge + = + fun (self: t_I16) (rhs: t_I16) -> + match + Core.Base.Z.z_cmp (Core.Base_interface.Coerce.f_lift #t_I16 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I16 #FStar.Tactics.Typeclasses.solve self <: t_I16) + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I16 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I16 #FStar.Tactics.Typeclasses.solve rhs <: t_I16) + <: + Core.Base.Spec.Z.t_Z) + with + | Core.Cmp.Ordering_Greater | Core.Cmp.Ordering_Equal -> true + | _ -> false + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_150: Core.Base_interface.Coerce.t_Abstraction t_I8 = + { + f_AbstractType = Core.Base.Spec.Z.t_Z; + f_lift_pre = (fun (self: t_I8) -> true); + f_lift_post = (fun (self: t_I8) (out: Core.Base.Spec.Z.t_Z) -> true); + f_lift = fun (self: t_I8) -> self.f_v + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_20: Core.Convert.t_From t_I16 t_I8 = + { + f_from_pre = (fun (x: t_I8) -> true); + f_from_post = (fun (x: t_I8) (out: t_I16) -> true); + f_from + = + fun (x: t_I8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I16 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #t_I8 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_21: Core.Convert.t_From t_I32 t_I8 = + { + f_from_pre = (fun (x: t_I8) -> true); + f_from_post = (fun (x: t_I8) (out: t_I32) -> true); + f_from + = + fun (x: t_I8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I32 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #t_I8 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_22: Core.Convert.t_From t_I64 t_I8 = + { + f_from_pre = (fun (x: t_I8) -> true); + f_from_post = (fun (x: t_I8) (out: t_I64) -> true); + f_from + = + fun (x: t_I8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I64 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #t_I8 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_23: Core.Convert.t_From t_I128 t_I8 = + { + f_from_pre = (fun (x: t_I8) -> true); + f_from_post = (fun (x: t_I8) (out: t_I128) -> true); + f_from + = + fun (x: t_I8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I128 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #t_I8 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_173: Core.Cmp.t_PartialEq t_I8 t_I8 = + { + f_eq_pre = (fun (self: t_I8) (rhs: t_I8) -> true); + f_eq_post = (fun (self: t_I8) (rhs: t_I8) (out: bool) -> true); + f_eq + = + (fun (self: t_I8) (rhs: t_I8) -> + (Core.Base.Z.z_cmp (Core.Base_interface.Coerce.f_lift #t_I8 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I8 #FStar.Tactics.Typeclasses.solve self <: t_I8) + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I8 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I8 #FStar.Tactics.Typeclasses.solve rhs <: t_I8) + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Cmp.t_Ordering) =. + (Core.Cmp.Ordering_Equal <: Core.Cmp.t_Ordering)); + f_ne_pre = (fun (self: t_I8) (rhs: t_I8) -> true); + f_ne_post = (fun (self: t_I8) (rhs: t_I8) (out: bool) -> true); + f_ne + = + fun (self: t_I8) (rhs: t_I8) -> + (Core.Base.Z.z_cmp (Core.Base_interface.Coerce.f_lift #t_I8 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I8 #FStar.Tactics.Typeclasses.solve self <: t_I8) + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I8 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I8 #FStar.Tactics.Typeclasses.solve rhs <: t_I8) + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Cmp.t_Ordering) <>. + (Core.Cmp.Ordering_Equal <: Core.Cmp.t_Ordering) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_174: Core.Cmp.t_PartialOrd t_I8 t_I8 = + { + _super_9014672428308350468 = FStar.Tactics.Typeclasses.solve; + f_partial_cmp_pre = (fun (self: t_I8) (rhs: t_I8) -> true); + f_partial_cmp_post + = + (fun (self: t_I8) (rhs: t_I8) (out: Core.Option.t_Option Core.Cmp.t_Ordering) -> true); + f_partial_cmp + = + (fun (self: t_I8) (rhs: t_I8) -> + Core.Option.Option_Some + (Core.Base.Z.z_cmp (Core.Base_interface.Coerce.f_lift #t_I8 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I8 #FStar.Tactics.Typeclasses.solve self <: t_I8) + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I8 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I8 #FStar.Tactics.Typeclasses.solve rhs <: t_I8) + <: + Core.Base.Spec.Z.t_Z)) + <: + Core.Option.t_Option Core.Cmp.t_Ordering); + f_lt_pre = (fun (self: t_I8) (rhs: t_I8) -> true); + f_lt_post = (fun (self: t_I8) (rhs: t_I8) (out: bool) -> true); + f_lt + = + (fun (self: t_I8) (rhs: t_I8) -> + match + Core.Base.Z.z_cmp (Core.Base_interface.Coerce.f_lift #t_I8 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I8 #FStar.Tactics.Typeclasses.solve self <: t_I8) + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I8 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I8 #FStar.Tactics.Typeclasses.solve rhs <: t_I8) + <: + Core.Base.Spec.Z.t_Z) + with + | Core.Cmp.Ordering_Less -> true + | _ -> false); + f_le_pre = (fun (self: t_I8) (rhs: t_I8) -> true); + f_le_post = (fun (self: t_I8) (rhs: t_I8) (out: bool) -> true); + f_le + = + (fun (self: t_I8) (rhs: t_I8) -> + match + Core.Base.Z.z_cmp (Core.Base_interface.Coerce.f_lift #t_I8 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I8 #FStar.Tactics.Typeclasses.solve self <: t_I8) + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I8 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I8 #FStar.Tactics.Typeclasses.solve rhs <: t_I8) + <: + Core.Base.Spec.Z.t_Z) + with + | Core.Cmp.Ordering_Less | Core.Cmp.Ordering_Equal -> true + | _ -> false); + f_gt_pre = (fun (self: t_I8) (rhs: t_I8) -> true); + f_gt_post = (fun (self: t_I8) (rhs: t_I8) (out: bool) -> true); + f_gt + = + (fun (self: t_I8) (rhs: t_I8) -> + match + Core.Base.Z.z_cmp (Core.Base_interface.Coerce.f_lift #t_I8 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I8 #FStar.Tactics.Typeclasses.solve self <: t_I8) + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I8 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I8 #FStar.Tactics.Typeclasses.solve rhs <: t_I8) + <: + Core.Base.Spec.Z.t_Z) + with + | Core.Cmp.Ordering_Greater -> true + | _ -> false); + f_ge_pre = (fun (self: t_I8) (rhs: t_I8) -> true); + f_ge_post = (fun (self: t_I8) (rhs: t_I8) (out: bool) -> true); + f_ge + = + fun (self: t_I8) (rhs: t_I8) -> + match + Core.Base.Z.z_cmp (Core.Base_interface.Coerce.f_lift #t_I8 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I8 #FStar.Tactics.Typeclasses.solve self <: t_I8) + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I8 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_I8 #FStar.Tactics.Typeclasses.solve rhs <: t_I8) + <: + Core.Base.Spec.Z.t_Z) + with + | Core.Cmp.Ordering_Greater | Core.Cmp.Ordering_Equal -> true + | _ -> false + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_177: Core.Base_interface.Coerce.t_Abstraction t_U128 = + { + f_AbstractType = Core.Base.Spec.Haxint.t_HaxInt; + f_lift_pre = (fun (self: t_U128) -> true); + f_lift_post = (fun (self: t_U128) (out: Core.Base.Spec.Haxint.t_HaxInt) -> true); + f_lift = fun (self: t_U128) -> self.f_v + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_200: Core.Cmp.t_PartialEq t_U128 t_U128 = + { + f_eq_pre = (fun (self: t_U128) (rhs: t_U128) -> true); + f_eq_post = (fun (self: t_U128) (rhs: t_U128) (out: bool) -> true); + f_eq + = + (fun (self: t_U128) (rhs: t_U128) -> + (Core.Base.Pos.haxint_cmp (Core.Base_interface.Coerce.f_lift #t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U128 #FStar.Tactics.Typeclasses.solve self <: t_U128) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U128 #FStar.Tactics.Typeclasses.solve rhs <: t_U128) + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Cmp.t_Ordering) =. + (Core.Cmp.Ordering_Equal <: Core.Cmp.t_Ordering)); + f_ne_pre = (fun (self: t_U128) (rhs: t_U128) -> true); + f_ne_post = (fun (self: t_U128) (rhs: t_U128) (out: bool) -> true); + f_ne + = + fun (self: t_U128) (rhs: t_U128) -> + (Core.Base.Pos.haxint_cmp (Core.Base_interface.Coerce.f_lift #t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U128 #FStar.Tactics.Typeclasses.solve self <: t_U128) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U128 #FStar.Tactics.Typeclasses.solve rhs <: t_U128) + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Cmp.t_Ordering) <>. + (Core.Cmp.Ordering_Equal <: Core.Cmp.t_Ordering) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_201: Core.Cmp.t_PartialOrd t_U128 t_U128 = + { + _super_9014672428308350468 = FStar.Tactics.Typeclasses.solve; + f_partial_cmp_pre = (fun (self: t_U128) (rhs: t_U128) -> true); + f_partial_cmp_post + = + (fun (self: t_U128) (rhs: t_U128) (out: Core.Option.t_Option Core.Cmp.t_Ordering) -> true); + f_partial_cmp + = + (fun (self: t_U128) (rhs: t_U128) -> + Core.Option.Option_Some + (Core.Base.Pos.haxint_cmp (Core.Base_interface.Coerce.f_lift #t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U128 #FStar.Tactics.Typeclasses.solve self <: t_U128) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U128 #FStar.Tactics.Typeclasses.solve rhs <: t_U128) + <: + Core.Base.Spec.Haxint.t_HaxInt)) + <: + Core.Option.t_Option Core.Cmp.t_Ordering); + f_lt_pre = (fun (self: t_U128) (rhs: t_U128) -> true); + f_lt_post = (fun (self: t_U128) (rhs: t_U128) (out: bool) -> true); + f_lt + = + (fun (self: t_U128) (rhs: t_U128) -> + match + Core.Base.Pos.haxint_cmp (Core.Base_interface.Coerce.f_lift #t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U128 #FStar.Tactics.Typeclasses.solve self <: t_U128) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U128 #FStar.Tactics.Typeclasses.solve rhs <: t_U128) + <: + Core.Base.Spec.Haxint.t_HaxInt) + with + | Core.Cmp.Ordering_Less -> true + | _ -> false); + f_le_pre = (fun (self: t_U128) (rhs: t_U128) -> true); + f_le_post = (fun (self: t_U128) (rhs: t_U128) (out: bool) -> true); + f_le + = + (fun (self: t_U128) (rhs: t_U128) -> + match + Core.Base.Pos.haxint_cmp (Core.Base_interface.Coerce.f_lift #t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U128 #FStar.Tactics.Typeclasses.solve self <: t_U128) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U128 #FStar.Tactics.Typeclasses.solve rhs <: t_U128) + <: + Core.Base.Spec.Haxint.t_HaxInt) + with + | Core.Cmp.Ordering_Less | Core.Cmp.Ordering_Equal -> true + | _ -> false); + f_gt_pre = (fun (self: t_U128) (rhs: t_U128) -> true); + f_gt_post = (fun (self: t_U128) (rhs: t_U128) (out: bool) -> true); + f_gt + = + (fun (self: t_U128) (rhs: t_U128) -> + match + Core.Base.Pos.haxint_cmp (Core.Base_interface.Coerce.f_lift #t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U128 #FStar.Tactics.Typeclasses.solve self <: t_U128) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U128 #FStar.Tactics.Typeclasses.solve rhs <: t_U128) + <: + Core.Base.Spec.Haxint.t_HaxInt) + with + | Core.Cmp.Ordering_Greater -> true + | _ -> false); + f_ge_pre = (fun (self: t_U128) (rhs: t_U128) -> true); + f_ge_post = (fun (self: t_U128) (rhs: t_U128) (out: bool) -> true); + f_ge + = + fun (self: t_U128) (rhs: t_U128) -> + match + Core.Base.Pos.haxint_cmp (Core.Base_interface.Coerce.f_lift #t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U128 #FStar.Tactics.Typeclasses.solve self <: t_U128) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U128 #FStar.Tactics.Typeclasses.solve rhs <: t_U128) + <: + Core.Base.Spec.Haxint.t_HaxInt) + with + | Core.Cmp.Ordering_Greater | Core.Cmp.Ordering_Equal -> true + | _ -> false + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_204: Core.Base_interface.Coerce.t_Abstraction t_U64 = + { + f_AbstractType = Core.Base.Spec.Haxint.t_HaxInt; + f_lift_pre = (fun (self: t_U64) -> true); + f_lift_post = (fun (self: t_U64) (out: Core.Base.Spec.Haxint.t_HaxInt) -> true); + f_lift = fun (self: t_U64) -> self.f_v + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_227: Core.Cmp.t_PartialEq t_U64 t_U64 = + { + f_eq_pre = (fun (self: t_U64) (rhs: t_U64) -> true); + f_eq_post = (fun (self: t_U64) (rhs: t_U64) (out: bool) -> true); + f_eq + = + (fun (self: t_U64) (rhs: t_U64) -> + (Core.Base.Pos.haxint_cmp (Core.Base_interface.Coerce.f_lift #t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U64 #FStar.Tactics.Typeclasses.solve self <: t_U64) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U64 #FStar.Tactics.Typeclasses.solve rhs <: t_U64) + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Cmp.t_Ordering) =. + (Core.Cmp.Ordering_Equal <: Core.Cmp.t_Ordering)); + f_ne_pre = (fun (self: t_U64) (rhs: t_U64) -> true); + f_ne_post = (fun (self: t_U64) (rhs: t_U64) (out: bool) -> true); + f_ne + = + fun (self: t_U64) (rhs: t_U64) -> + (Core.Base.Pos.haxint_cmp (Core.Base_interface.Coerce.f_lift #t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U64 #FStar.Tactics.Typeclasses.solve self <: t_U64) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U64 #FStar.Tactics.Typeclasses.solve rhs <: t_U64) + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Cmp.t_Ordering) <>. + (Core.Cmp.Ordering_Equal <: Core.Cmp.t_Ordering) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_228: Core.Cmp.t_PartialOrd t_U64 t_U64 = + { + _super_9014672428308350468 = FStar.Tactics.Typeclasses.solve; + f_partial_cmp_pre = (fun (self: t_U64) (rhs: t_U64) -> true); + f_partial_cmp_post + = + (fun (self: t_U64) (rhs: t_U64) (out: Core.Option.t_Option Core.Cmp.t_Ordering) -> true); + f_partial_cmp + = + (fun (self: t_U64) (rhs: t_U64) -> + Core.Option.Option_Some + (Core.Base.Pos.haxint_cmp (Core.Base_interface.Coerce.f_lift #t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U64 #FStar.Tactics.Typeclasses.solve self <: t_U64) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U64 #FStar.Tactics.Typeclasses.solve rhs <: t_U64) + <: + Core.Base.Spec.Haxint.t_HaxInt)) + <: + Core.Option.t_Option Core.Cmp.t_Ordering); + f_lt_pre = (fun (self: t_U64) (rhs: t_U64) -> true); + f_lt_post = (fun (self: t_U64) (rhs: t_U64) (out: bool) -> true); + f_lt + = + (fun (self: t_U64) (rhs: t_U64) -> + match + Core.Base.Pos.haxint_cmp (Core.Base_interface.Coerce.f_lift #t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U64 #FStar.Tactics.Typeclasses.solve self <: t_U64) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U64 #FStar.Tactics.Typeclasses.solve rhs <: t_U64) + <: + Core.Base.Spec.Haxint.t_HaxInt) + with + | Core.Cmp.Ordering_Less -> true + | _ -> false); + f_le_pre = (fun (self: t_U64) (rhs: t_U64) -> true); + f_le_post = (fun (self: t_U64) (rhs: t_U64) (out: bool) -> true); + f_le + = + (fun (self: t_U64) (rhs: t_U64) -> + match + Core.Base.Pos.haxint_cmp (Core.Base_interface.Coerce.f_lift #t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U64 #FStar.Tactics.Typeclasses.solve self <: t_U64) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U64 #FStar.Tactics.Typeclasses.solve rhs <: t_U64) + <: + Core.Base.Spec.Haxint.t_HaxInt) + with + | Core.Cmp.Ordering_Less | Core.Cmp.Ordering_Equal -> true + | _ -> false); + f_gt_pre = (fun (self: t_U64) (rhs: t_U64) -> true); + f_gt_post = (fun (self: t_U64) (rhs: t_U64) (out: bool) -> true); + f_gt + = + (fun (self: t_U64) (rhs: t_U64) -> + match + Core.Base.Pos.haxint_cmp (Core.Base_interface.Coerce.f_lift #t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U64 #FStar.Tactics.Typeclasses.solve self <: t_U64) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U64 #FStar.Tactics.Typeclasses.solve rhs <: t_U64) + <: + Core.Base.Spec.Haxint.t_HaxInt) + with + | Core.Cmp.Ordering_Greater -> true + | _ -> false); + f_ge_pre = (fun (self: t_U64) (rhs: t_U64) -> true); + f_ge_post = (fun (self: t_U64) (rhs: t_U64) (out: bool) -> true); + f_ge + = + fun (self: t_U64) (rhs: t_U64) -> + match + Core.Base.Pos.haxint_cmp (Core.Base_interface.Coerce.f_lift #t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U64 #FStar.Tactics.Typeclasses.solve self <: t_U64) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U64 #FStar.Tactics.Typeclasses.solve rhs <: t_U64) + <: + Core.Base.Spec.Haxint.t_HaxInt) + with + | Core.Cmp.Ordering_Greater | Core.Cmp.Ordering_Equal -> true + | _ -> false + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_231: Core.Base_interface.Coerce.t_Abstraction t_U32 = + { + f_AbstractType = Core.Base.Spec.Haxint.t_HaxInt; + f_lift_pre = (fun (self: t_U32) -> true); + f_lift_post = (fun (self: t_U32) (out: Core.Base.Spec.Haxint.t_HaxInt) -> true); + f_lift = fun (self: t_U32) -> self.f_v + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_254: Core.Cmp.t_PartialEq t_U32 t_U32 = + { + f_eq_pre = (fun (self: t_U32) (rhs: t_U32) -> true); + f_eq_post = (fun (self: t_U32) (rhs: t_U32) (out: bool) -> true); + f_eq + = + (fun (self: t_U32) (rhs: t_U32) -> + (Core.Base.Pos.haxint_cmp (Core.Base_interface.Coerce.f_lift #t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U32 #FStar.Tactics.Typeclasses.solve self <: t_U32) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U32 #FStar.Tactics.Typeclasses.solve rhs <: t_U32) + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Cmp.t_Ordering) =. + (Core.Cmp.Ordering_Equal <: Core.Cmp.t_Ordering)); + f_ne_pre = (fun (self: t_U32) (rhs: t_U32) -> true); + f_ne_post = (fun (self: t_U32) (rhs: t_U32) (out: bool) -> true); + f_ne + = + fun (self: t_U32) (rhs: t_U32) -> + (Core.Base.Pos.haxint_cmp (Core.Base_interface.Coerce.f_lift #t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U32 #FStar.Tactics.Typeclasses.solve self <: t_U32) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U32 #FStar.Tactics.Typeclasses.solve rhs <: t_U32) + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Cmp.t_Ordering) <>. + (Core.Cmp.Ordering_Equal <: Core.Cmp.t_Ordering) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_255: Core.Cmp.t_PartialOrd t_U32 t_U32 = + { + _super_9014672428308350468 = FStar.Tactics.Typeclasses.solve; + f_partial_cmp_pre = (fun (self: t_U32) (rhs: t_U32) -> true); + f_partial_cmp_post + = + (fun (self: t_U32) (rhs: t_U32) (out: Core.Option.t_Option Core.Cmp.t_Ordering) -> true); + f_partial_cmp + = + (fun (self: t_U32) (rhs: t_U32) -> + Core.Option.Option_Some + (Core.Base.Pos.haxint_cmp (Core.Base_interface.Coerce.f_lift #t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U32 #FStar.Tactics.Typeclasses.solve self <: t_U32) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U32 #FStar.Tactics.Typeclasses.solve rhs <: t_U32) + <: + Core.Base.Spec.Haxint.t_HaxInt)) + <: + Core.Option.t_Option Core.Cmp.t_Ordering); + f_lt_pre = (fun (self: t_U32) (rhs: t_U32) -> true); + f_lt_post = (fun (self: t_U32) (rhs: t_U32) (out: bool) -> true); + f_lt + = + (fun (self: t_U32) (rhs: t_U32) -> + match + Core.Base.Pos.haxint_cmp (Core.Base_interface.Coerce.f_lift #t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U32 #FStar.Tactics.Typeclasses.solve self <: t_U32) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U32 #FStar.Tactics.Typeclasses.solve rhs <: t_U32) + <: + Core.Base.Spec.Haxint.t_HaxInt) + with + | Core.Cmp.Ordering_Less -> true + | _ -> false); + f_le_pre = (fun (self: t_U32) (rhs: t_U32) -> true); + f_le_post = (fun (self: t_U32) (rhs: t_U32) (out: bool) -> true); + f_le + = + (fun (self: t_U32) (rhs: t_U32) -> + match + Core.Base.Pos.haxint_cmp (Core.Base_interface.Coerce.f_lift #t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U32 #FStar.Tactics.Typeclasses.solve self <: t_U32) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U32 #FStar.Tactics.Typeclasses.solve rhs <: t_U32) + <: + Core.Base.Spec.Haxint.t_HaxInt) + with + | Core.Cmp.Ordering_Less | Core.Cmp.Ordering_Equal -> true + | _ -> false); + f_gt_pre = (fun (self: t_U32) (rhs: t_U32) -> true); + f_gt_post = (fun (self: t_U32) (rhs: t_U32) (out: bool) -> true); + f_gt + = + (fun (self: t_U32) (rhs: t_U32) -> + match + Core.Base.Pos.haxint_cmp (Core.Base_interface.Coerce.f_lift #t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U32 #FStar.Tactics.Typeclasses.solve self <: t_U32) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U32 #FStar.Tactics.Typeclasses.solve rhs <: t_U32) + <: + Core.Base.Spec.Haxint.t_HaxInt) + with + | Core.Cmp.Ordering_Greater -> true + | _ -> false); + f_ge_pre = (fun (self: t_U32) (rhs: t_U32) -> true); + f_ge_post = (fun (self: t_U32) (rhs: t_U32) (out: bool) -> true); + f_ge + = + fun (self: t_U32) (rhs: t_U32) -> + match + Core.Base.Pos.haxint_cmp (Core.Base_interface.Coerce.f_lift #t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U32 #FStar.Tactics.Typeclasses.solve self <: t_U32) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U32 #FStar.Tactics.Typeclasses.solve rhs <: t_U32) + <: + Core.Base.Spec.Haxint.t_HaxInt) + with + | Core.Cmp.Ordering_Greater | Core.Cmp.Ordering_Equal -> true + | _ -> false + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_258: Core.Base_interface.Coerce.t_Abstraction t_U16 = + { + f_AbstractType = Core.Base.Spec.Haxint.t_HaxInt; + f_lift_pre = (fun (self: t_U16) -> true); + f_lift_post = (fun (self: t_U16) (out: Core.Base.Spec.Haxint.t_HaxInt) -> true); + f_lift = fun (self: t_U16) -> self.f_v + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_281: Core.Cmp.t_PartialEq t_U16 t_U16 = + { + f_eq_pre = (fun (self: t_U16) (rhs: t_U16) -> true); + f_eq_post = (fun (self: t_U16) (rhs: t_U16) (out: bool) -> true); + f_eq + = + (fun (self: t_U16) (rhs: t_U16) -> + (Core.Base.Pos.haxint_cmp (Core.Base_interface.Coerce.f_lift #t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U16 #FStar.Tactics.Typeclasses.solve self <: t_U16) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U16 #FStar.Tactics.Typeclasses.solve rhs <: t_U16) + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Cmp.t_Ordering) =. + (Core.Cmp.Ordering_Equal <: Core.Cmp.t_Ordering)); + f_ne_pre = (fun (self: t_U16) (rhs: t_U16) -> true); + f_ne_post = (fun (self: t_U16) (rhs: t_U16) (out: bool) -> true); + f_ne + = + fun (self: t_U16) (rhs: t_U16) -> + (Core.Base.Pos.haxint_cmp (Core.Base_interface.Coerce.f_lift #t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U16 #FStar.Tactics.Typeclasses.solve self <: t_U16) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U16 #FStar.Tactics.Typeclasses.solve rhs <: t_U16) + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Cmp.t_Ordering) <>. + (Core.Cmp.Ordering_Equal <: Core.Cmp.t_Ordering) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_282: Core.Cmp.t_PartialOrd t_U16 t_U16 = + { + _super_9014672428308350468 = FStar.Tactics.Typeclasses.solve; + f_partial_cmp_pre = (fun (self: t_U16) (rhs: t_U16) -> true); + f_partial_cmp_post + = + (fun (self: t_U16) (rhs: t_U16) (out: Core.Option.t_Option Core.Cmp.t_Ordering) -> true); + f_partial_cmp + = + (fun (self: t_U16) (rhs: t_U16) -> + Core.Option.Option_Some + (Core.Base.Pos.haxint_cmp (Core.Base_interface.Coerce.f_lift #t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U16 #FStar.Tactics.Typeclasses.solve self <: t_U16) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U16 #FStar.Tactics.Typeclasses.solve rhs <: t_U16) + <: + Core.Base.Spec.Haxint.t_HaxInt)) + <: + Core.Option.t_Option Core.Cmp.t_Ordering); + f_lt_pre = (fun (self: t_U16) (rhs: t_U16) -> true); + f_lt_post = (fun (self: t_U16) (rhs: t_U16) (out: bool) -> true); + f_lt + = + (fun (self: t_U16) (rhs: t_U16) -> + match + Core.Base.Pos.haxint_cmp (Core.Base_interface.Coerce.f_lift #t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U16 #FStar.Tactics.Typeclasses.solve self <: t_U16) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U16 #FStar.Tactics.Typeclasses.solve rhs <: t_U16) + <: + Core.Base.Spec.Haxint.t_HaxInt) + with + | Core.Cmp.Ordering_Less -> true + | _ -> false); + f_le_pre = (fun (self: t_U16) (rhs: t_U16) -> true); + f_le_post = (fun (self: t_U16) (rhs: t_U16) (out: bool) -> true); + f_le + = + (fun (self: t_U16) (rhs: t_U16) -> + match + Core.Base.Pos.haxint_cmp (Core.Base_interface.Coerce.f_lift #t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U16 #FStar.Tactics.Typeclasses.solve self <: t_U16) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U16 #FStar.Tactics.Typeclasses.solve rhs <: t_U16) + <: + Core.Base.Spec.Haxint.t_HaxInt) + with + | Core.Cmp.Ordering_Less | Core.Cmp.Ordering_Equal -> true + | _ -> false); + f_gt_pre = (fun (self: t_U16) (rhs: t_U16) -> true); + f_gt_post = (fun (self: t_U16) (rhs: t_U16) (out: bool) -> true); + f_gt + = + (fun (self: t_U16) (rhs: t_U16) -> + match + Core.Base.Pos.haxint_cmp (Core.Base_interface.Coerce.f_lift #t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U16 #FStar.Tactics.Typeclasses.solve self <: t_U16) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U16 #FStar.Tactics.Typeclasses.solve rhs <: t_U16) + <: + Core.Base.Spec.Haxint.t_HaxInt) + with + | Core.Cmp.Ordering_Greater -> true + | _ -> false); + f_ge_pre = (fun (self: t_U16) (rhs: t_U16) -> true); + f_ge_post = (fun (self: t_U16) (rhs: t_U16) (out: bool) -> true); + f_ge + = + fun (self: t_U16) (rhs: t_U16) -> + match + Core.Base.Pos.haxint_cmp (Core.Base_interface.Coerce.f_lift #t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U16 #FStar.Tactics.Typeclasses.solve self <: t_U16) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U16 #FStar.Tactics.Typeclasses.solve rhs <: t_U16) + <: + Core.Base.Spec.Haxint.t_HaxInt) + with + | Core.Cmp.Ordering_Greater | Core.Cmp.Ordering_Equal -> true + | _ -> false + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_285: Core.Base_interface.Coerce.t_Abstraction t_U8 = + { + f_AbstractType = Core.Base.Spec.Haxint.t_HaxInt; + f_lift_pre = (fun (self: t_U8) -> true); + f_lift_post = (fun (self: t_U8) (out: Core.Base.Spec.Haxint.t_HaxInt) -> true); + f_lift = fun (self: t_U8) -> self.f_v + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_308: Core.Cmp.t_PartialEq t_U8 t_U8 = + { + f_eq_pre = (fun (self: t_U8) (rhs: t_U8) -> true); + f_eq_post = (fun (self: t_U8) (rhs: t_U8) (out: bool) -> true); + f_eq + = + (fun (self: t_U8) (rhs: t_U8) -> + (Core.Base.Pos.haxint_cmp (Core.Base_interface.Coerce.f_lift #t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U8 #FStar.Tactics.Typeclasses.solve self <: t_U8) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U8 #FStar.Tactics.Typeclasses.solve rhs <: t_U8) + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Cmp.t_Ordering) =. + (Core.Cmp.Ordering_Equal <: Core.Cmp.t_Ordering)); + f_ne_pre = (fun (self: t_U8) (rhs: t_U8) -> true); + f_ne_post = (fun (self: t_U8) (rhs: t_U8) (out: bool) -> true); + f_ne + = + fun (self: t_U8) (rhs: t_U8) -> + (Core.Base.Pos.haxint_cmp (Core.Base_interface.Coerce.f_lift #t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U8 #FStar.Tactics.Typeclasses.solve self <: t_U8) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U8 #FStar.Tactics.Typeclasses.solve rhs <: t_U8) + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Cmp.t_Ordering) <>. + (Core.Cmp.Ordering_Equal <: Core.Cmp.t_Ordering) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_309: Core.Cmp.t_PartialOrd t_U8 t_U8 = + { + _super_9014672428308350468 = FStar.Tactics.Typeclasses.solve; + f_partial_cmp_pre = (fun (self: t_U8) (rhs: t_U8) -> true); + f_partial_cmp_post + = + (fun (self: t_U8) (rhs: t_U8) (out: Core.Option.t_Option Core.Cmp.t_Ordering) -> true); + f_partial_cmp + = + (fun (self: t_U8) (rhs: t_U8) -> + Core.Option.Option_Some + (Core.Base.Pos.haxint_cmp (Core.Base_interface.Coerce.f_lift #t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U8 #FStar.Tactics.Typeclasses.solve self <: t_U8) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U8 #FStar.Tactics.Typeclasses.solve rhs <: t_U8) + <: + Core.Base.Spec.Haxint.t_HaxInt)) + <: + Core.Option.t_Option Core.Cmp.t_Ordering); + f_lt_pre = (fun (self: t_U8) (rhs: t_U8) -> true); + f_lt_post = (fun (self: t_U8) (rhs: t_U8) (out: bool) -> true); + f_lt + = + (fun (self: t_U8) (rhs: t_U8) -> + match + Core.Base.Pos.haxint_cmp (Core.Base_interface.Coerce.f_lift #t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U8 #FStar.Tactics.Typeclasses.solve self <: t_U8) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U8 #FStar.Tactics.Typeclasses.solve rhs <: t_U8) + <: + Core.Base.Spec.Haxint.t_HaxInt) + with + | Core.Cmp.Ordering_Less -> true + | _ -> false); + f_le_pre = (fun (self: t_U8) (rhs: t_U8) -> true); + f_le_post = (fun (self: t_U8) (rhs: t_U8) (out: bool) -> true); + f_le + = + (fun (self: t_U8) (rhs: t_U8) -> + match + Core.Base.Pos.haxint_cmp (Core.Base_interface.Coerce.f_lift #t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U8 #FStar.Tactics.Typeclasses.solve self <: t_U8) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U8 #FStar.Tactics.Typeclasses.solve rhs <: t_U8) + <: + Core.Base.Spec.Haxint.t_HaxInt) + with + | Core.Cmp.Ordering_Less | Core.Cmp.Ordering_Equal -> true + | _ -> false); + f_gt_pre = (fun (self: t_U8) (rhs: t_U8) -> true); + f_gt_post = (fun (self: t_U8) (rhs: t_U8) (out: bool) -> true); + f_gt + = + (fun (self: t_U8) (rhs: t_U8) -> + match + Core.Base.Pos.haxint_cmp (Core.Base_interface.Coerce.f_lift #t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U8 #FStar.Tactics.Typeclasses.solve self <: t_U8) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U8 #FStar.Tactics.Typeclasses.solve rhs <: t_U8) + <: + Core.Base.Spec.Haxint.t_HaxInt) + with + | Core.Cmp.Ordering_Greater -> true + | _ -> false); + f_ge_pre = (fun (self: t_U8) (rhs: t_U8) -> true); + f_ge_post = (fun (self: t_U8) (rhs: t_U8) (out: bool) -> true); + f_ge + = + fun (self: t_U8) (rhs: t_U8) -> + match + Core.Base.Pos.haxint_cmp (Core.Base_interface.Coerce.f_lift #t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U8 #FStar.Tactics.Typeclasses.solve self <: t_U8) + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #t_U8 #FStar.Tactics.Typeclasses.solve rhs <: t_U8) + <: + Core.Base.Spec.Haxint.t_HaxInt) + with + | Core.Cmp.Ordering_Greater | Core.Cmp.Ordering_Equal -> true + | _ -> false + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_49: Core.Ops.Arith.t_Neg t_I128 = + { + f_Output = t_I128; + f_neg_pre = (fun (self: t_I128) -> true); + f_neg_post = (fun (self: t_I128) (out: t_I128) -> true); + f_neg + = + fun (self: t_I128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I128 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_neg (Core.Base_interface.Coerce.f_lift #t_I128 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_51: Core.Ops.Bit.t_Shl t_I128 t_I8 = + { + f_Output = t_I128; + f_shl_pre = (fun (self: t_I128) (rhs: t_I8) -> true); + f_shl_post = (fun (self: t_I128) (rhs: t_I8) (out: t_I128) -> true); + f_shl + = + fun (self: t_I128) (rhs: t_I8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I128 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shl (Core.Base_interface.Coerce.f_lift #t_I128 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I8 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_52: Core.Ops.Bit.t_Shl t_I128 t_I16 = + { + f_Output = t_I128; + f_shl_pre = (fun (self: t_I128) (rhs: t_I16) -> true); + f_shl_post = (fun (self: t_I128) (rhs: t_I16) (out: t_I128) -> true); + f_shl + = + fun (self: t_I128) (rhs: t_I16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I128 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shl (Core.Base_interface.Coerce.f_lift #t_I128 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I16 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_53: Core.Ops.Bit.t_Shl t_I128 t_I32 = + { + f_Output = t_I128; + f_shl_pre = (fun (self: t_I128) (rhs: t_I32) -> true); + f_shl_post = (fun (self: t_I128) (rhs: t_I32) (out: t_I128) -> true); + f_shl + = + fun (self: t_I128) (rhs: t_I32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I128 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shl (Core.Base_interface.Coerce.f_lift #t_I128 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I32 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_54: Core.Ops.Bit.t_Shl t_I128 t_I64 = + { + f_Output = t_I128; + f_shl_pre = (fun (self: t_I128) (rhs: t_I64) -> true); + f_shl_post = (fun (self: t_I128) (rhs: t_I64) (out: t_I128) -> true); + f_shl + = + fun (self: t_I128) (rhs: t_I64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I128 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shl (Core.Base_interface.Coerce.f_lift #t_I128 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I64 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_55: Core.Ops.Bit.t_Shl t_I128 t_I128 = + { + f_Output = t_I128; + f_shl_pre = (fun (self: t_I128) (rhs: t_I128) -> true); + f_shl_post = (fun (self: t_I128) (rhs: t_I128) (out: t_I128) -> true); + f_shl + = + fun (self: t_I128) (rhs: t_I128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I128 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shl (Core.Base_interface.Coerce.f_lift #t_I128 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I128 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_56: Core.Ops.Bit.t_Shr t_I128 t_I8 = + { + f_Output = t_I128; + f_shr_pre = (fun (self: t_I128) (rhs: t_I8) -> true); + f_shr_post = (fun (self: t_I128) (rhs: t_I8) (out: t_I128) -> true); + f_shr + = + fun (self: t_I128) (rhs: t_I8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I128 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shr (Core.Base_interface.Coerce.f_lift #t_I128 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I8 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_57: Core.Ops.Bit.t_Shr t_I128 t_I16 = + { + f_Output = t_I128; + f_shr_pre = (fun (self: t_I128) (rhs: t_I16) -> true); + f_shr_post = (fun (self: t_I128) (rhs: t_I16) (out: t_I128) -> true); + f_shr + = + fun (self: t_I128) (rhs: t_I16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I128 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shr (Core.Base_interface.Coerce.f_lift #t_I128 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I16 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_58: Core.Ops.Bit.t_Shr t_I128 t_I32 = + { + f_Output = t_I128; + f_shr_pre = (fun (self: t_I128) (rhs: t_I32) -> true); + f_shr_post = (fun (self: t_I128) (rhs: t_I32) (out: t_I128) -> true); + f_shr + = + fun (self: t_I128) (rhs: t_I32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I128 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shr (Core.Base_interface.Coerce.f_lift #t_I128 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I32 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_59: Core.Ops.Bit.t_Shr t_I128 t_I64 = + { + f_Output = t_I128; + f_shr_pre = (fun (self: t_I128) (rhs: t_I64) -> true); + f_shr_post = (fun (self: t_I128) (rhs: t_I64) (out: t_I128) -> true); + f_shr + = + fun (self: t_I128) (rhs: t_I64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I128 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shr (Core.Base_interface.Coerce.f_lift #t_I128 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I64 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_60: Core.Ops.Bit.t_Shr t_I128 t_I128 = + { + f_Output = t_I128; + f_shr_pre = (fun (self: t_I128) (rhs: t_I128) -> true); + f_shr_post = (fun (self: t_I128) (rhs: t_I128) (out: t_I128) -> true); + f_shr + = + fun (self: t_I128) (rhs: t_I128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I128 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shr (Core.Base_interface.Coerce.f_lift #t_I128 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I128 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_61: Core.Ops.Bit.t_BitXor t_I128 t_I128 = + { + f_Output = t_I128; + f_bitxor_pre = (fun (self: t_I128) (rhs: t_I128) -> true); + f_bitxor_post = (fun (self: t_I128) (rhs: t_I128) (out: t_I128) -> true); + f_bitxor + = + fun (self: t_I128) (rhs: t_I128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I128 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_bitxor (Core.Base_interface.Coerce.f_lift #t_I128 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I128 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_62: Core.Ops.Bit.t_BitAnd t_I128 t_I128 = + { + f_Output = t_I128; + f_bitand_pre = (fun (self: t_I128) (rhs: t_I128) -> true); + f_bitand_post = (fun (self: t_I128) (rhs: t_I128) (out: t_I128) -> true); + f_bitand + = + fun (self: t_I128) (rhs: t_I128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I128 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_bitand (Core.Base_interface.Coerce.f_lift #t_I128 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I128 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_63: Core.Ops.Bit.t_BitOr t_I128 t_I128 = + { + f_Output = t_I128; + f_bitor_pre = (fun (self: t_I128) (rhs: t_I128) -> true); + f_bitor_post = (fun (self: t_I128) (rhs: t_I128) (out: t_I128) -> true); + f_bitor + = + fun (self: t_I128) (rhs: t_I128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I128 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_bitor (Core.Base_interface.Coerce.f_lift #t_I128 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I128 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_76: Core.Ops.Arith.t_Neg t_I64 = + { + f_Output = t_I64; + f_neg_pre = (fun (self: t_I64) -> true); + f_neg_post = (fun (self: t_I64) (out: t_I64) -> true); + f_neg + = + fun (self: t_I64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I64 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_neg (Core.Base_interface.Coerce.f_lift #t_I64 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_78: Core.Ops.Bit.t_Shl t_I64 t_I8 = + { + f_Output = t_I64; + f_shl_pre = (fun (self: t_I64) (rhs: t_I8) -> true); + f_shl_post = (fun (self: t_I64) (rhs: t_I8) (out: t_I64) -> true); + f_shl + = + fun (self: t_I64) (rhs: t_I8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I64 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shl (Core.Base_interface.Coerce.f_lift #t_I64 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I8 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_79: Core.Ops.Bit.t_Shl t_I64 t_I16 = + { + f_Output = t_I64; + f_shl_pre = (fun (self: t_I64) (rhs: t_I16) -> true); + f_shl_post = (fun (self: t_I64) (rhs: t_I16) (out: t_I64) -> true); + f_shl + = + fun (self: t_I64) (rhs: t_I16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I64 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shl (Core.Base_interface.Coerce.f_lift #t_I64 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I16 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_80: Core.Ops.Bit.t_Shl t_I64 t_I32 = + { + f_Output = t_I64; + f_shl_pre = (fun (self: t_I64) (rhs: t_I32) -> true); + f_shl_post = (fun (self: t_I64) (rhs: t_I32) (out: t_I64) -> true); + f_shl + = + fun (self: t_I64) (rhs: t_I32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I64 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shl (Core.Base_interface.Coerce.f_lift #t_I64 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I32 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_81: Core.Ops.Bit.t_Shl t_I64 t_I64 = + { + f_Output = t_I64; + f_shl_pre = (fun (self: t_I64) (rhs: t_I64) -> true); + f_shl_post = (fun (self: t_I64) (rhs: t_I64) (out: t_I64) -> true); + f_shl + = + fun (self: t_I64) (rhs: t_I64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I64 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shl (Core.Base_interface.Coerce.f_lift #t_I64 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I64 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_82: Core.Ops.Bit.t_Shl t_I64 t_I128 = + { + f_Output = t_I64; + f_shl_pre = (fun (self: t_I64) (rhs: t_I128) -> true); + f_shl_post = (fun (self: t_I64) (rhs: t_I128) (out: t_I64) -> true); + f_shl + = + fun (self: t_I64) (rhs: t_I128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I64 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shl (Core.Base_interface.Coerce.f_lift #t_I64 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I128 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_83: Core.Ops.Bit.t_Shr t_I64 t_I8 = + { + f_Output = t_I64; + f_shr_pre = (fun (self: t_I64) (rhs: t_I8) -> true); + f_shr_post = (fun (self: t_I64) (rhs: t_I8) (out: t_I64) -> true); + f_shr + = + fun (self: t_I64) (rhs: t_I8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I64 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shr (Core.Base_interface.Coerce.f_lift #t_I64 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I8 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_84: Core.Ops.Bit.t_Shr t_I64 t_I16 = + { + f_Output = t_I64; + f_shr_pre = (fun (self: t_I64) (rhs: t_I16) -> true); + f_shr_post = (fun (self: t_I64) (rhs: t_I16) (out: t_I64) -> true); + f_shr + = + fun (self: t_I64) (rhs: t_I16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I64 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shr (Core.Base_interface.Coerce.f_lift #t_I64 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I16 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_85: Core.Ops.Bit.t_Shr t_I64 t_I32 = + { + f_Output = t_I64; + f_shr_pre = (fun (self: t_I64) (rhs: t_I32) -> true); + f_shr_post = (fun (self: t_I64) (rhs: t_I32) (out: t_I64) -> true); + f_shr + = + fun (self: t_I64) (rhs: t_I32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I64 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shr (Core.Base_interface.Coerce.f_lift #t_I64 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I32 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_86: Core.Ops.Bit.t_Shr t_I64 t_I64 = + { + f_Output = t_I64; + f_shr_pre = (fun (self: t_I64) (rhs: t_I64) -> true); + f_shr_post = (fun (self: t_I64) (rhs: t_I64) (out: t_I64) -> true); + f_shr + = + fun (self: t_I64) (rhs: t_I64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I64 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shr (Core.Base_interface.Coerce.f_lift #t_I64 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I64 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_87: Core.Ops.Bit.t_Shr t_I64 t_I128 = + { + f_Output = t_I64; + f_shr_pre = (fun (self: t_I64) (rhs: t_I128) -> true); + f_shr_post = (fun (self: t_I64) (rhs: t_I128) (out: t_I64) -> true); + f_shr + = + fun (self: t_I64) (rhs: t_I128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I64 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shr (Core.Base_interface.Coerce.f_lift #t_I64 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I128 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_88: Core.Ops.Bit.t_BitXor t_I64 t_I64 = + { + f_Output = t_I64; + f_bitxor_pre = (fun (self: t_I64) (rhs: t_I64) -> true); + f_bitxor_post = (fun (self: t_I64) (rhs: t_I64) (out: t_I64) -> true); + f_bitxor + = + fun (self: t_I64) (rhs: t_I64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I64 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_bitxor (Core.Base_interface.Coerce.f_lift #t_I64 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I64 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_89: Core.Ops.Bit.t_BitAnd t_I64 t_I64 = + { + f_Output = t_I64; + f_bitand_pre = (fun (self: t_I64) (rhs: t_I64) -> true); + f_bitand_post = (fun (self: t_I64) (rhs: t_I64) (out: t_I64) -> true); + f_bitand + = + fun (self: t_I64) (rhs: t_I64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I64 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_bitand (Core.Base_interface.Coerce.f_lift #t_I64 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I64 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_90: Core.Ops.Bit.t_BitOr t_I64 t_I64 = + { + f_Output = t_I64; + f_bitor_pre = (fun (self: t_I64) (rhs: t_I64) -> true); + f_bitor_post = (fun (self: t_I64) (rhs: t_I64) (out: t_I64) -> true); + f_bitor + = + fun (self: t_I64) (rhs: t_I64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I64 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_bitor (Core.Base_interface.Coerce.f_lift #t_I64 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I64 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_103: Core.Ops.Arith.t_Neg t_I32 = + { + f_Output = t_I32; + f_neg_pre = (fun (self: t_I32) -> true); + f_neg_post = (fun (self: t_I32) (out: t_I32) -> true); + f_neg + = + fun (self: t_I32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I32 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_neg (Core.Base_interface.Coerce.f_lift #t_I32 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_105: Core.Ops.Bit.t_Shl t_I32 t_I8 = + { + f_Output = t_I32; + f_shl_pre = (fun (self: t_I32) (rhs: t_I8) -> true); + f_shl_post = (fun (self: t_I32) (rhs: t_I8) (out: t_I32) -> true); + f_shl + = + fun (self: t_I32) (rhs: t_I8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I32 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shl (Core.Base_interface.Coerce.f_lift #t_I32 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I8 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_106: Core.Ops.Bit.t_Shl t_I32 t_I16 = + { + f_Output = t_I32; + f_shl_pre = (fun (self: t_I32) (rhs: t_I16) -> true); + f_shl_post = (fun (self: t_I32) (rhs: t_I16) (out: t_I32) -> true); + f_shl + = + fun (self: t_I32) (rhs: t_I16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I32 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shl (Core.Base_interface.Coerce.f_lift #t_I32 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I16 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_107: Core.Ops.Bit.t_Shl t_I32 t_I32 = + { + f_Output = t_I32; + f_shl_pre = (fun (self: t_I32) (rhs: t_I32) -> true); + f_shl_post = (fun (self: t_I32) (rhs: t_I32) (out: t_I32) -> true); + f_shl + = + fun (self: t_I32) (rhs: t_I32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I32 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shl (Core.Base_interface.Coerce.f_lift #t_I32 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I32 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_108: Core.Ops.Bit.t_Shl t_I32 t_I64 = + { + f_Output = t_I32; + f_shl_pre = (fun (self: t_I32) (rhs: t_I64) -> true); + f_shl_post = (fun (self: t_I32) (rhs: t_I64) (out: t_I32) -> true); + f_shl + = + fun (self: t_I32) (rhs: t_I64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I32 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shl (Core.Base_interface.Coerce.f_lift #t_I32 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I64 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_109: Core.Ops.Bit.t_Shl t_I32 t_I128 = + { + f_Output = t_I32; + f_shl_pre = (fun (self: t_I32) (rhs: t_I128) -> true); + f_shl_post = (fun (self: t_I32) (rhs: t_I128) (out: t_I32) -> true); + f_shl + = + fun (self: t_I32) (rhs: t_I128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I32 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shl (Core.Base_interface.Coerce.f_lift #t_I32 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I128 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_110: Core.Ops.Bit.t_Shr t_I32 t_I8 = + { + f_Output = t_I32; + f_shr_pre = (fun (self: t_I32) (rhs: t_I8) -> true); + f_shr_post = (fun (self: t_I32) (rhs: t_I8) (out: t_I32) -> true); + f_shr + = + fun (self: t_I32) (rhs: t_I8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I32 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shr (Core.Base_interface.Coerce.f_lift #t_I32 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I8 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_111: Core.Ops.Bit.t_Shr t_I32 t_I16 = + { + f_Output = t_I32; + f_shr_pre = (fun (self: t_I32) (rhs: t_I16) -> true); + f_shr_post = (fun (self: t_I32) (rhs: t_I16) (out: t_I32) -> true); + f_shr + = + fun (self: t_I32) (rhs: t_I16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I32 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shr (Core.Base_interface.Coerce.f_lift #t_I32 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I16 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_112: Core.Ops.Bit.t_Shr t_I32 t_I32 = + { + f_Output = t_I32; + f_shr_pre = (fun (self: t_I32) (rhs: t_I32) -> true); + f_shr_post = (fun (self: t_I32) (rhs: t_I32) (out: t_I32) -> true); + f_shr + = + fun (self: t_I32) (rhs: t_I32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I32 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shr (Core.Base_interface.Coerce.f_lift #t_I32 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I32 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_113: Core.Ops.Bit.t_Shr t_I32 t_I64 = + { + f_Output = t_I32; + f_shr_pre = (fun (self: t_I32) (rhs: t_I64) -> true); + f_shr_post = (fun (self: t_I32) (rhs: t_I64) (out: t_I32) -> true); + f_shr + = + fun (self: t_I32) (rhs: t_I64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I32 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shr (Core.Base_interface.Coerce.f_lift #t_I32 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I64 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_114: Core.Ops.Bit.t_Shr t_I32 t_I128 = + { + f_Output = t_I32; + f_shr_pre = (fun (self: t_I32) (rhs: t_I128) -> true); + f_shr_post = (fun (self: t_I32) (rhs: t_I128) (out: t_I32) -> true); + f_shr + = + fun (self: t_I32) (rhs: t_I128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I32 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shr (Core.Base_interface.Coerce.f_lift #t_I32 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I128 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_115: Core.Ops.Bit.t_BitXor t_I32 t_I32 = + { + f_Output = t_I32; + f_bitxor_pre = (fun (self: t_I32) (rhs: t_I32) -> true); + f_bitxor_post = (fun (self: t_I32) (rhs: t_I32) (out: t_I32) -> true); + f_bitxor + = + fun (self: t_I32) (rhs: t_I32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I32 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_bitxor (Core.Base_interface.Coerce.f_lift #t_I32 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I32 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_116: Core.Ops.Bit.t_BitAnd t_I32 t_I32 = + { + f_Output = t_I32; + f_bitand_pre = (fun (self: t_I32) (rhs: t_I32) -> true); + f_bitand_post = (fun (self: t_I32) (rhs: t_I32) (out: t_I32) -> true); + f_bitand + = + fun (self: t_I32) (rhs: t_I32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I32 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_bitand (Core.Base_interface.Coerce.f_lift #t_I32 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I32 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_117: Core.Ops.Bit.t_BitOr t_I32 t_I32 = + { + f_Output = t_I32; + f_bitor_pre = (fun (self: t_I32) (rhs: t_I32) -> true); + f_bitor_post = (fun (self: t_I32) (rhs: t_I32) (out: t_I32) -> true); + f_bitor + = + fun (self: t_I32) (rhs: t_I32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I32 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_bitor (Core.Base_interface.Coerce.f_lift #t_I32 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I32 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_130: Core.Ops.Arith.t_Neg t_I16 = + { + f_Output = t_I16; + f_neg_pre = (fun (self: t_I16) -> true); + f_neg_post = (fun (self: t_I16) (out: t_I16) -> true); + f_neg + = + fun (self: t_I16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I16 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_neg (Core.Base_interface.Coerce.f_lift #t_I16 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_132: Core.Ops.Bit.t_Shl t_I16 t_I8 = + { + f_Output = t_I16; + f_shl_pre = (fun (self: t_I16) (rhs: t_I8) -> true); + f_shl_post = (fun (self: t_I16) (rhs: t_I8) (out: t_I16) -> true); + f_shl + = + fun (self: t_I16) (rhs: t_I8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I16 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shl (Core.Base_interface.Coerce.f_lift #t_I16 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I8 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_133: Core.Ops.Bit.t_Shl t_I16 t_I16 = + { + f_Output = t_I16; + f_shl_pre = (fun (self: t_I16) (rhs: t_I16) -> true); + f_shl_post = (fun (self: t_I16) (rhs: t_I16) (out: t_I16) -> true); + f_shl + = + fun (self: t_I16) (rhs: t_I16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I16 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shl (Core.Base_interface.Coerce.f_lift #t_I16 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I16 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_134: Core.Ops.Bit.t_Shl t_I16 t_I32 = + { + f_Output = t_I16; + f_shl_pre = (fun (self: t_I16) (rhs: t_I32) -> true); + f_shl_post = (fun (self: t_I16) (rhs: t_I32) (out: t_I16) -> true); + f_shl + = + fun (self: t_I16) (rhs: t_I32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I16 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shl (Core.Base_interface.Coerce.f_lift #t_I16 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I32 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_135: Core.Ops.Bit.t_Shl t_I16 t_I64 = + { + f_Output = t_I16; + f_shl_pre = (fun (self: t_I16) (rhs: t_I64) -> true); + f_shl_post = (fun (self: t_I16) (rhs: t_I64) (out: t_I16) -> true); + f_shl + = + fun (self: t_I16) (rhs: t_I64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I16 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shl (Core.Base_interface.Coerce.f_lift #t_I16 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I64 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_136: Core.Ops.Bit.t_Shl t_I16 t_I128 = + { + f_Output = t_I16; + f_shl_pre = (fun (self: t_I16) (rhs: t_I128) -> true); + f_shl_post = (fun (self: t_I16) (rhs: t_I128) (out: t_I16) -> true); + f_shl + = + fun (self: t_I16) (rhs: t_I128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I16 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shl (Core.Base_interface.Coerce.f_lift #t_I16 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I128 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_137: Core.Ops.Bit.t_Shr t_I16 t_I8 = + { + f_Output = t_I16; + f_shr_pre = (fun (self: t_I16) (rhs: t_I8) -> true); + f_shr_post = (fun (self: t_I16) (rhs: t_I8) (out: t_I16) -> true); + f_shr + = + fun (self: t_I16) (rhs: t_I8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I16 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shr (Core.Base_interface.Coerce.f_lift #t_I16 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I8 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_138: Core.Ops.Bit.t_Shr t_I16 t_I16 = + { + f_Output = t_I16; + f_shr_pre = (fun (self: t_I16) (rhs: t_I16) -> true); + f_shr_post = (fun (self: t_I16) (rhs: t_I16) (out: t_I16) -> true); + f_shr + = + fun (self: t_I16) (rhs: t_I16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I16 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shr (Core.Base_interface.Coerce.f_lift #t_I16 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I16 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_139: Core.Ops.Bit.t_Shr t_I16 t_I32 = + { + f_Output = t_I16; + f_shr_pre = (fun (self: t_I16) (rhs: t_I32) -> true); + f_shr_post = (fun (self: t_I16) (rhs: t_I32) (out: t_I16) -> true); + f_shr + = + fun (self: t_I16) (rhs: t_I32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I16 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shr (Core.Base_interface.Coerce.f_lift #t_I16 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I32 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_140: Core.Ops.Bit.t_Shr t_I16 t_I64 = + { + f_Output = t_I16; + f_shr_pre = (fun (self: t_I16) (rhs: t_I64) -> true); + f_shr_post = (fun (self: t_I16) (rhs: t_I64) (out: t_I16) -> true); + f_shr + = + fun (self: t_I16) (rhs: t_I64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I16 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shr (Core.Base_interface.Coerce.f_lift #t_I16 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I64 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_141: Core.Ops.Bit.t_Shr t_I16 t_I128 = + { + f_Output = t_I16; + f_shr_pre = (fun (self: t_I16) (rhs: t_I128) -> true); + f_shr_post = (fun (self: t_I16) (rhs: t_I128) (out: t_I16) -> true); + f_shr + = + fun (self: t_I16) (rhs: t_I128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I16 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shr (Core.Base_interface.Coerce.f_lift #t_I16 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I128 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_142: Core.Ops.Bit.t_BitXor t_I16 t_I16 = + { + f_Output = t_I16; + f_bitxor_pre = (fun (self: t_I16) (rhs: t_I16) -> true); + f_bitxor_post = (fun (self: t_I16) (rhs: t_I16) (out: t_I16) -> true); + f_bitxor + = + fun (self: t_I16) (rhs: t_I16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I16 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_bitxor (Core.Base_interface.Coerce.f_lift #t_I16 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I16 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_143: Core.Ops.Bit.t_BitAnd t_I16 t_I16 = + { + f_Output = t_I16; + f_bitand_pre = (fun (self: t_I16) (rhs: t_I16) -> true); + f_bitand_post = (fun (self: t_I16) (rhs: t_I16) (out: t_I16) -> true); + f_bitand + = + fun (self: t_I16) (rhs: t_I16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I16 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_bitand (Core.Base_interface.Coerce.f_lift #t_I16 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I16 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_144: Core.Ops.Bit.t_BitOr t_I16 t_I16 = + { + f_Output = t_I16; + f_bitor_pre = (fun (self: t_I16) (rhs: t_I16) -> true); + f_bitor_post = (fun (self: t_I16) (rhs: t_I16) (out: t_I16) -> true); + f_bitor + = + fun (self: t_I16) (rhs: t_I16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I16 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_bitor (Core.Base_interface.Coerce.f_lift #t_I16 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I16 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_157: Core.Ops.Arith.t_Neg t_I8 = + { + f_Output = t_I8; + f_neg_pre = (fun (self: t_I8) -> true); + f_neg_post = (fun (self: t_I8) (out: t_I8) -> true); + f_neg + = + fun (self: t_I8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I8 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_neg (Core.Base_interface.Coerce.f_lift #t_I8 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_159: Core.Ops.Bit.t_Shl t_I8 t_I8 = + { + f_Output = t_I8; + f_shl_pre = (fun (self: t_I8) (rhs: t_I8) -> true); + f_shl_post = (fun (self: t_I8) (rhs: t_I8) (out: t_I8) -> true); + f_shl + = + fun (self: t_I8) (rhs: t_I8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I8 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shl (Core.Base_interface.Coerce.f_lift #t_I8 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I8 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_160: Core.Ops.Bit.t_Shl t_I8 t_I16 = + { + f_Output = t_I8; + f_shl_pre = (fun (self: t_I8) (rhs: t_I16) -> true); + f_shl_post = (fun (self: t_I8) (rhs: t_I16) (out: t_I8) -> true); + f_shl + = + fun (self: t_I8) (rhs: t_I16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I8 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shl (Core.Base_interface.Coerce.f_lift #t_I8 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I16 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_161: Core.Ops.Bit.t_Shl t_I8 t_I32 = + { + f_Output = t_I8; + f_shl_pre = (fun (self: t_I8) (rhs: t_I32) -> true); + f_shl_post = (fun (self: t_I8) (rhs: t_I32) (out: t_I8) -> true); + f_shl + = + fun (self: t_I8) (rhs: t_I32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I8 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shl (Core.Base_interface.Coerce.f_lift #t_I8 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I32 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_162: Core.Ops.Bit.t_Shl t_I8 t_I64 = + { + f_Output = t_I8; + f_shl_pre = (fun (self: t_I8) (rhs: t_I64) -> true); + f_shl_post = (fun (self: t_I8) (rhs: t_I64) (out: t_I8) -> true); + f_shl + = + fun (self: t_I8) (rhs: t_I64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I8 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shl (Core.Base_interface.Coerce.f_lift #t_I8 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I64 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_163: Core.Ops.Bit.t_Shl t_I8 t_I128 = + { + f_Output = t_I8; + f_shl_pre = (fun (self: t_I8) (rhs: t_I128) -> true); + f_shl_post = (fun (self: t_I8) (rhs: t_I128) (out: t_I8) -> true); + f_shl + = + fun (self: t_I8) (rhs: t_I128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I8 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shl (Core.Base_interface.Coerce.f_lift #t_I8 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I128 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_164: Core.Ops.Bit.t_Shr t_I8 t_I8 = + { + f_Output = t_I8; + f_shr_pre = (fun (self: t_I8) (rhs: t_I8) -> true); + f_shr_post = (fun (self: t_I8) (rhs: t_I8) (out: t_I8) -> true); + f_shr + = + fun (self: t_I8) (rhs: t_I8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I8 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shr (Core.Base_interface.Coerce.f_lift #t_I8 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I8 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_165: Core.Ops.Bit.t_Shr t_I8 t_I16 = + { + f_Output = t_I8; + f_shr_pre = (fun (self: t_I8) (rhs: t_I16) -> true); + f_shr_post = (fun (self: t_I8) (rhs: t_I16) (out: t_I8) -> true); + f_shr + = + fun (self: t_I8) (rhs: t_I16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I8 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shr (Core.Base_interface.Coerce.f_lift #t_I8 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I16 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_166: Core.Ops.Bit.t_Shr t_I8 t_I32 = + { + f_Output = t_I8; + f_shr_pre = (fun (self: t_I8) (rhs: t_I32) -> true); + f_shr_post = (fun (self: t_I8) (rhs: t_I32) (out: t_I8) -> true); + f_shr + = + fun (self: t_I8) (rhs: t_I32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I8 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shr (Core.Base_interface.Coerce.f_lift #t_I8 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I32 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_167: Core.Ops.Bit.t_Shr t_I8 t_I64 = + { + f_Output = t_I8; + f_shr_pre = (fun (self: t_I8) (rhs: t_I64) -> true); + f_shr_post = (fun (self: t_I8) (rhs: t_I64) (out: t_I8) -> true); + f_shr + = + fun (self: t_I8) (rhs: t_I64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I8 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shr (Core.Base_interface.Coerce.f_lift #t_I8 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I64 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_168: Core.Ops.Bit.t_Shr t_I8 t_I128 = + { + f_Output = t_I8; + f_shr_pre = (fun (self: t_I8) (rhs: t_I128) -> true); + f_shr_post = (fun (self: t_I8) (rhs: t_I128) (out: t_I8) -> true); + f_shr + = + fun (self: t_I8) (rhs: t_I128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I8 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_shr (Core.Base_interface.Coerce.f_lift #t_I8 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I128 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_169: Core.Ops.Bit.t_BitXor t_I8 t_I8 = + { + f_Output = t_I8; + f_bitxor_pre = (fun (self: t_I8) (rhs: t_I8) -> true); + f_bitxor_post = (fun (self: t_I8) (rhs: t_I8) (out: t_I8) -> true); + f_bitxor + = + fun (self: t_I8) (rhs: t_I8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I8 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_bitxor (Core.Base_interface.Coerce.f_lift #t_I8 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I8 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_170: Core.Ops.Bit.t_BitAnd t_I8 t_I8 = + { + f_Output = t_I8; + f_bitand_pre = (fun (self: t_I8) (rhs: t_I8) -> true); + f_bitand_post = (fun (self: t_I8) (rhs: t_I8) (out: t_I8) -> true); + f_bitand + = + fun (self: t_I8) (rhs: t_I8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I8 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_bitand (Core.Base_interface.Coerce.f_lift #t_I8 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I8 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_171: Core.Ops.Bit.t_BitOr t_I8 t_I8 = + { + f_Output = t_I8; + f_bitor_pre = (fun (self: t_I8) (rhs: t_I8) -> true); + f_bitor_post = (fun (self: t_I8) (rhs: t_I8) (out: t_I8) -> true); + f_bitor + = + fun (self: t_I8) (rhs: t_I8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I8 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_bitor (Core.Base_interface.Coerce.f_lift #t_I8 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I8 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_44: Core.Ops.Bit.t_Not t_I128 = + { + f_Output = t_I128; + f_not_pre = (fun (self: t_I128) -> true); + f_not_post = (fun (self: t_I128) (out: t_I128) -> true); + f_not + = + fun (self: t_I128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I128 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_sub (Core.Base.Z.z_neg (Core.Base_interface.Coerce.f_lift #t_I128 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + Core.Base.Spec.Z.v_Z_ONE + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_47: Core.Ops.Arith.t_Add t_I128 t_I128 = + { + f_Output = t_I128; + f_add_pre = (fun (self: t_I128) (rhs: t_I128) -> true); + f_add_post = (fun (self: t_I128) (rhs: t_I128) (out: t_I128) -> true); + f_add + = + fun (self: t_I128) (rhs: t_I128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I128 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_add (Core.Base_interface.Coerce.f_lift #t_I128 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I128 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_50: Core.Ops.Arith.t_Sub t_I128 t_I128 = + { + f_Output = t_I128; + f_sub_pre = (fun (self: t_I128) (rhs: t_I128) -> true); + f_sub_post = (fun (self: t_I128) (rhs: t_I128) (out: t_I128) -> true); + f_sub + = + fun (self: t_I128) (rhs: t_I128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I128 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_sub (Core.Base_interface.Coerce.f_lift #t_I128 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I128 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_71: Core.Ops.Bit.t_Not t_I64 = + { + f_Output = t_I64; + f_not_pre = (fun (self: t_I64) -> true); + f_not_post = (fun (self: t_I64) (out: t_I64) -> true); + f_not + = + fun (self: t_I64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I64 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_sub (Core.Base.Z.z_neg (Core.Base_interface.Coerce.f_lift #t_I64 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + Core.Base.Spec.Z.v_Z_ONE + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_74: Core.Ops.Arith.t_Add t_I64 t_I64 = + { + f_Output = t_I64; + f_add_pre = (fun (self: t_I64) (rhs: t_I64) -> true); + f_add_post = (fun (self: t_I64) (rhs: t_I64) (out: t_I64) -> true); + f_add + = + fun (self: t_I64) (rhs: t_I64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I64 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_add (Core.Base_interface.Coerce.f_lift #t_I64 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I64 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_77: Core.Ops.Arith.t_Sub t_I64 t_I64 = + { + f_Output = t_I64; + f_sub_pre = (fun (self: t_I64) (rhs: t_I64) -> true); + f_sub_post = (fun (self: t_I64) (rhs: t_I64) (out: t_I64) -> true); + f_sub + = + fun (self: t_I64) (rhs: t_I64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I64 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_sub (Core.Base_interface.Coerce.f_lift #t_I64 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I64 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_98: Core.Ops.Bit.t_Not t_I32 = + { + f_Output = t_I32; + f_not_pre = (fun (self: t_I32) -> true); + f_not_post = (fun (self: t_I32) (out: t_I32) -> true); + f_not + = + fun (self: t_I32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I32 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_sub (Core.Base.Z.z_neg (Core.Base_interface.Coerce.f_lift #t_I32 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + Core.Base.Spec.Z.v_Z_ONE + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_101: Core.Ops.Arith.t_Add t_I32 t_I32 = + { + f_Output = t_I32; + f_add_pre = (fun (self: t_I32) (rhs: t_I32) -> true); + f_add_post = (fun (self: t_I32) (rhs: t_I32) (out: t_I32) -> true); + f_add + = + fun (self: t_I32) (rhs: t_I32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I32 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_add (Core.Base_interface.Coerce.f_lift #t_I32 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I32 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_104: Core.Ops.Arith.t_Sub t_I32 t_I32 = + { + f_Output = t_I32; + f_sub_pre = (fun (self: t_I32) (rhs: t_I32) -> true); + f_sub_post = (fun (self: t_I32) (rhs: t_I32) (out: t_I32) -> true); + f_sub + = + fun (self: t_I32) (rhs: t_I32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I32 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_sub (Core.Base_interface.Coerce.f_lift #t_I32 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I32 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_125: Core.Ops.Bit.t_Not t_I16 = + { + f_Output = t_I16; + f_not_pre = (fun (self: t_I16) -> true); + f_not_post = (fun (self: t_I16) (out: t_I16) -> true); + f_not + = + fun (self: t_I16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I16 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_sub (Core.Base.Z.z_neg (Core.Base_interface.Coerce.f_lift #t_I16 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + Core.Base.Spec.Z.v_Z_ONE + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_128: Core.Ops.Arith.t_Add t_I16 t_I16 = + { + f_Output = t_I16; + f_add_pre = (fun (self: t_I16) (rhs: t_I16) -> true); + f_add_post = (fun (self: t_I16) (rhs: t_I16) (out: t_I16) -> true); + f_add + = + fun (self: t_I16) (rhs: t_I16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I16 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_add (Core.Base_interface.Coerce.f_lift #t_I16 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I16 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_131: Core.Ops.Arith.t_Sub t_I16 t_I16 = + { + f_Output = t_I16; + f_sub_pre = (fun (self: t_I16) (rhs: t_I16) -> true); + f_sub_post = (fun (self: t_I16) (rhs: t_I16) (out: t_I16) -> true); + f_sub + = + fun (self: t_I16) (rhs: t_I16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I16 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_sub (Core.Base_interface.Coerce.f_lift #t_I16 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I16 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_152: Core.Ops.Bit.t_Not t_I8 = + { + f_Output = t_I8; + f_not_pre = (fun (self: t_I8) -> true); + f_not_post = (fun (self: t_I8) (out: t_I8) -> true); + f_not + = + fun (self: t_I8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I8 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_sub (Core.Base.Z.z_neg (Core.Base_interface.Coerce.f_lift #t_I8 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + Core.Base.Spec.Z.v_Z_ONE + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_155: Core.Ops.Arith.t_Add t_I8 t_I8 = + { + f_Output = t_I8; + f_add_pre = (fun (self: t_I8) (rhs: t_I8) -> true); + f_add_post = (fun (self: t_I8) (rhs: t_I8) (out: t_I8) -> true); + f_add + = + fun (self: t_I8) (rhs: t_I8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I8 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_add (Core.Base_interface.Coerce.f_lift #t_I8 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I8 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_158: Core.Ops.Arith.t_Sub t_I8 t_I8 = + { + f_Output = t_I8; + f_sub_pre = (fun (self: t_I8) (rhs: t_I8) -> true); + f_sub_post = (fun (self: t_I8) (rhs: t_I8) (out: t_I8) -> true); + f_sub + = + fun (self: t_I8) (rhs: t_I8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I8 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_sub (Core.Base_interface.Coerce.f_lift #t_I8 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I8 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_178: Core.Base_interface.Coerce.t_Concretization Core.Base.Spec.Haxint.t_HaxInt t_U128 = + { + f_concretize_pre = (fun (self: Core.Base.Spec.Haxint.t_HaxInt) -> true); + f_concretize_post = (fun (self: Core.Base.Spec.Haxint.t_HaxInt) (out: t_U128) -> true); + f_concretize + = + fun (self: Core.Base.Spec.Haxint.t_HaxInt) -> + { f_v = Core.Base.Pos.haxint_rem self Core.Base.Spec.Constants.v_WORDSIZE_128_ } <: t_U128 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_3: Core.Convert.t_From t_U128 t_U8 = + { + f_from_pre = (fun (x: t_U8) -> true); + f_from_post = (fun (x: t_U8) (out: t_U128) -> true); + f_from + = + fun (x: t_U8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #t_U8 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_7: Core.Convert.t_From t_U128 t_U16 = + { + f_from_pre = (fun (x: t_U16) -> true); + f_from_post = (fun (x: t_U16) (out: t_U128) -> true); + f_from + = + fun (x: t_U16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #t_U16 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_11: Core.Convert.t_From t_U128 t_U32 = + { + f_from_pre = (fun (x: t_U32) -> true); + f_from_post = (fun (x: t_U32) (out: t_U128) -> true); + f_from + = + fun (x: t_U32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #t_U32 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_15: Core.Convert.t_From t_U128 t_U64 = + { + f_from_pre = (fun (x: t_U64) -> true); + f_from_post = (fun (x: t_U64) (out: t_U128) -> true); + f_from + = + fun (x: t_U64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #t_U64 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_205: Core.Base_interface.Coerce.t_Concretization Core.Base.Spec.Haxint.t_HaxInt t_U64 = + { + f_concretize_pre = (fun (self: Core.Base.Spec.Haxint.t_HaxInt) -> true); + f_concretize_post = (fun (self: Core.Base.Spec.Haxint.t_HaxInt) (out: t_U64) -> true); + f_concretize + = + fun (self: Core.Base.Spec.Haxint.t_HaxInt) -> + { f_v = Core.Base.Pos.haxint_rem self Core.Base.Spec.Constants.v_WORDSIZE_64_ } <: t_U64 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_2: Core.Convert.t_From t_U64 t_U8 = + { + f_from_pre = (fun (x: t_U8) -> true); + f_from_post = (fun (x: t_U8) (out: t_U64) -> true); + f_from + = + fun (x: t_U8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #t_U8 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_6: Core.Convert.t_From t_U64 t_U16 = + { + f_from_pre = (fun (x: t_U16) -> true); + f_from_post = (fun (x: t_U16) (out: t_U64) -> true); + f_from + = + fun (x: t_U16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #t_U16 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_10: Core.Convert.t_From t_U64 t_U32 = + { + f_from_pre = (fun (x: t_U32) -> true); + f_from_post = (fun (x: t_U32) (out: t_U64) -> true); + f_from + = + fun (x: t_U32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #t_U32 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_19: Core.Convert.t_From t_U64 t_U128 = + { + f_from_pre = (fun (x: t_U128) -> true); + f_from_post = (fun (x: t_U128) (out: t_U64) -> true); + f_from + = + fun (x: t_U128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #t_U128 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_232: Core.Base_interface.Coerce.t_Concretization Core.Base.Spec.Haxint.t_HaxInt t_U32 = + { + f_concretize_pre = (fun (self: Core.Base.Spec.Haxint.t_HaxInt) -> true); + f_concretize_post = (fun (self: Core.Base.Spec.Haxint.t_HaxInt) (out: t_U32) -> true); + f_concretize + = + fun (self: Core.Base.Spec.Haxint.t_HaxInt) -> + { f_v = Core.Base.Pos.haxint_rem self Core.Base.Spec.Constants.v_WORDSIZE_32_ } <: t_U32 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_1: Core.Convert.t_From t_U32 t_U8 = + { + f_from_pre = (fun (x: t_U8) -> true); + f_from_post = (fun (x: t_U8) (out: t_U32) -> true); + f_from + = + fun (x: t_U8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #t_U8 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_5: Core.Convert.t_From t_U32 t_U16 = + { + f_from_pre = (fun (x: t_U16) -> true); + f_from_post = (fun (x: t_U16) (out: t_U32) -> true); + f_from + = + fun (x: t_U16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #t_U16 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_14: Core.Convert.t_From t_U32 t_U64 = + { + f_from_pre = (fun (x: t_U64) -> true); + f_from_post = (fun (x: t_U64) (out: t_U32) -> true); + f_from + = + fun (x: t_U64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #t_U64 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_18: Core.Convert.t_From t_U32 t_U128 = + { + f_from_pre = (fun (x: t_U128) -> true); + f_from_post = (fun (x: t_U128) (out: t_U32) -> true); + f_from + = + fun (x: t_U128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #t_U128 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_259: Core.Base_interface.Coerce.t_Concretization Core.Base.Spec.Haxint.t_HaxInt t_U16 = + { + f_concretize_pre = (fun (self: Core.Base.Spec.Haxint.t_HaxInt) -> true); + f_concretize_post = (fun (self: Core.Base.Spec.Haxint.t_HaxInt) (out: t_U16) -> true); + f_concretize + = + fun (self: Core.Base.Spec.Haxint.t_HaxInt) -> + { f_v = Core.Base.Pos.haxint_rem self Core.Base.Spec.Constants.v_WORDSIZE_16_ } <: t_U16 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl: Core.Convert.t_From t_U16 t_U8 = + { + f_from_pre = (fun (x: t_U8) -> true); + f_from_post = (fun (x: t_U8) (out: t_U16) -> true); + f_from + = + fun (x: t_U8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #t_U8 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_9: Core.Convert.t_From t_U16 t_U32 = + { + f_from_pre = (fun (x: t_U32) -> true); + f_from_post = (fun (x: t_U32) (out: t_U16) -> true); + f_from + = + fun (x: t_U32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #t_U32 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_13: Core.Convert.t_From t_U16 t_U64 = + { + f_from_pre = (fun (x: t_U64) -> true); + f_from_post = (fun (x: t_U64) (out: t_U16) -> true); + f_from + = + fun (x: t_U64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #t_U64 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_17: Core.Convert.t_From t_U16 t_U128 = + { + f_from_pre = (fun (x: t_U128) -> true); + f_from_post = (fun (x: t_U128) (out: t_U16) -> true); + f_from + = + fun (x: t_U128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #t_U128 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_286: Core.Base_interface.Coerce.t_Concretization Core.Base.Spec.Haxint.t_HaxInt t_U8 = + { + f_concretize_pre = (fun (self: Core.Base.Spec.Haxint.t_HaxInt) -> true); + f_concretize_post = (fun (self: Core.Base.Spec.Haxint.t_HaxInt) (out: t_U8) -> true); + f_concretize + = + fun (self: Core.Base.Spec.Haxint.t_HaxInt) -> + { f_v = Core.Base.Pos.haxint_rem self Core.Base.Spec.Constants.v_WORDSIZE_8_ } <: t_U8 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_4: Core.Convert.t_From t_U8 t_U16 = + { + f_from_pre = (fun (x: t_U16) -> true); + f_from_post = (fun (x: t_U16) (out: t_U8) -> true); + f_from + = + fun (x: t_U16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #t_U16 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_8: Core.Convert.t_From t_U8 t_U32 = + { + f_from_pre = (fun (x: t_U32) -> true); + f_from_post = (fun (x: t_U32) (out: t_U8) -> true); + f_from + = + fun (x: t_U32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #t_U32 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_12: Core.Convert.t_From t_U8 t_U64 = + { + f_from_pre = (fun (x: t_U64) -> true); + f_from_post = (fun (x: t_U64) (out: t_U8) -> true); + f_from + = + fun (x: t_U64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #t_U64 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_16: Core.Convert.t_From t_U8 t_U128 = + { + f_from_pre = (fun (x: t_U128) -> true); + f_from_post = (fun (x: t_U128) (out: t_U8) -> true); + f_from + = + fun (x: t_U128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Base_interface.Coerce.f_lift #t_U128 #FStar.Tactics.Typeclasses.solve x + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_45: Core.Ops.Arith.t_Mul t_I128 t_I128 = + { + f_Output = t_I128; + f_mul_pre = (fun (self: t_I128) (rhs: t_I128) -> true); + f_mul_post = (fun (self: t_I128) (rhs: t_I128) (out: t_I128) -> true); + f_mul + = + fun (self: t_I128) (rhs: t_I128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I128 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_mul (Core.Base_interface.Coerce.f_lift #t_I128 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I128 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_72: Core.Ops.Arith.t_Mul t_I64 t_I64 = + { + f_Output = t_I64; + f_mul_pre = (fun (self: t_I64) (rhs: t_I64) -> true); + f_mul_post = (fun (self: t_I64) (rhs: t_I64) (out: t_I64) -> true); + f_mul + = + fun (self: t_I64) (rhs: t_I64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I64 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_mul (Core.Base_interface.Coerce.f_lift #t_I64 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I64 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_99: Core.Ops.Arith.t_Mul t_I32 t_I32 = + { + f_Output = t_I32; + f_mul_pre = (fun (self: t_I32) (rhs: t_I32) -> true); + f_mul_post = (fun (self: t_I32) (rhs: t_I32) (out: t_I32) -> true); + f_mul + = + fun (self: t_I32) (rhs: t_I32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I32 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_mul (Core.Base_interface.Coerce.f_lift #t_I32 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I32 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_126: Core.Ops.Arith.t_Mul t_I16 t_I16 = + { + f_Output = t_I16; + f_mul_pre = (fun (self: t_I16) (rhs: t_I16) -> true); + f_mul_post = (fun (self: t_I16) (rhs: t_I16) (out: t_I16) -> true); + f_mul + = + fun (self: t_I16) (rhs: t_I16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I16 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_mul (Core.Base_interface.Coerce.f_lift #t_I16 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I16 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_153: Core.Ops.Arith.t_Mul t_I8 t_I8 = + { + f_Output = t_I8; + f_mul_pre = (fun (self: t_I8) (rhs: t_I8) -> true); + f_mul_post = (fun (self: t_I8) (rhs: t_I8) (out: t_I8) -> true); + f_mul + = + fun (self: t_I8) (rhs: t_I8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I8 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_mul (Core.Base_interface.Coerce.f_lift #t_I8 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I8 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_179: Core.Ops.Arith.t_Neg t_U128 = + { + f_Output = t_U128; + f_neg_pre = (fun (self: t_U128) -> true); + f_neg_post = (fun (self: t_U128) (out: t_U128) -> true); + f_neg + = + fun (self: t_U128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_sub Core.Base.Spec.Constants.v_WORDSIZE_128_ + (Core.Base.Pos.haxint_rem (Core.Base_interface.Coerce.f_lift #t_U128 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + Core.Base.Spec.Constants.v_WORDSIZE_128_ + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_182: Core.Ops.Arith.t_Mul t_U128 t_U128 = + { + f_Output = t_U128; + f_mul_pre = (fun (self: t_U128) (rhs: t_U128) -> true); + f_mul_post = (fun (self: t_U128) (rhs: t_U128) (out: t_U128) -> true); + f_mul + = + fun (self: t_U128) (rhs: t_U128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_mul (Core.Base_interface.Coerce.f_lift #t_U128 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U128 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_183: Core.Ops.Arith.t_Rem t_U128 t_U128 = + { + f_Output = t_U128; + f_rem_pre = (fun (self: t_U128) (rhs: t_U128) -> true); + f_rem_post = (fun (self: t_U128) (rhs: t_U128) (out: t_U128) -> true); + f_rem + = + fun (self: t_U128) (rhs: t_U128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_rem (Core.Base_interface.Coerce.f_lift #t_U128 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U128 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_184: Core.Ops.Arith.t_Add t_U128 t_U128 = + { + f_Output = t_U128; + f_add_pre = (fun (self: t_U128) (rhs: t_U128) -> true); + f_add_post = (fun (self: t_U128) (rhs: t_U128) (out: t_U128) -> true); + f_add + = + fun (self: t_U128) (rhs: t_U128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_add (Core.Base_interface.Coerce.f_lift #t_U128 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U128 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_185: Core.Ops.Arith.t_Div t_U128 t_U128 = + { + f_Output = t_U128; + f_div_pre = (fun (self: t_U128) (rhs: t_U128) -> true); + f_div_post = (fun (self: t_U128) (rhs: t_U128) (out: t_U128) -> true); + f_div + = + fun (self: t_U128) (rhs: t_U128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_div (Core.Base_interface.Coerce.f_lift #t_U128 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U128 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_186: Core.Ops.Bit.t_Shl t_U128 t_U8 = + { + f_Output = t_U128; + f_shl_pre = (fun (self: t_U128) (rhs: t_U8) -> true); + f_shl_post = (fun (self: t_U128) (rhs: t_U8) (out: t_U128) -> true); + f_shl + = + fun (self: t_U128) (rhs: t_U8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shl (Core.Base_interface.Coerce.f_lift #t_U128 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U8 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_187: Core.Ops.Bit.t_Shl t_U128 t_U16 = + { + f_Output = t_U128; + f_shl_pre = (fun (self: t_U128) (rhs: t_U16) -> true); + f_shl_post = (fun (self: t_U128) (rhs: t_U16) (out: t_U128) -> true); + f_shl + = + fun (self: t_U128) (rhs: t_U16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shl (Core.Base_interface.Coerce.f_lift #t_U128 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U16 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_188: Core.Ops.Bit.t_Shl t_U128 t_U32 = + { + f_Output = t_U128; + f_shl_pre = (fun (self: t_U128) (rhs: t_U32) -> true); + f_shl_post = (fun (self: t_U128) (rhs: t_U32) (out: t_U128) -> true); + f_shl + = + fun (self: t_U128) (rhs: t_U32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shl (Core.Base_interface.Coerce.f_lift #t_U128 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U32 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_189: Core.Ops.Bit.t_Shl t_U128 t_U64 = + { + f_Output = t_U128; + f_shl_pre = (fun (self: t_U128) (rhs: t_U64) -> true); + f_shl_post = (fun (self: t_U128) (rhs: t_U64) (out: t_U128) -> true); + f_shl + = + fun (self: t_U128) (rhs: t_U64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shl (Core.Base_interface.Coerce.f_lift #t_U128 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U64 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_190: Core.Ops.Bit.t_Shl t_U128 t_U128 = + { + f_Output = t_U128; + f_shl_pre = (fun (self: t_U128) (rhs: t_U128) -> true); + f_shl_post = (fun (self: t_U128) (rhs: t_U128) (out: t_U128) -> true); + f_shl + = + fun (self: t_U128) (rhs: t_U128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shl (Core.Base_interface.Coerce.f_lift #t_U128 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U128 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_191: Core.Ops.Bit.t_Shr t_U128 t_U8 = + { + f_Output = t_U128; + f_shr_pre = (fun (self: t_U128) (rhs: t_U8) -> true); + f_shr_post = (fun (self: t_U128) (rhs: t_U8) (out: t_U128) -> true); + f_shr + = + fun (self: t_U128) (rhs: t_U8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shr (Core.Base_interface.Coerce.f_lift #t_U128 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U8 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_192: Core.Ops.Bit.t_Shr t_U128 t_U16 = + { + f_Output = t_U128; + f_shr_pre = (fun (self: t_U128) (rhs: t_U16) -> true); + f_shr_post = (fun (self: t_U128) (rhs: t_U16) (out: t_U128) -> true); + f_shr + = + fun (self: t_U128) (rhs: t_U16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shr (Core.Base_interface.Coerce.f_lift #t_U128 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U16 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_193: Core.Ops.Bit.t_Shr t_U128 t_U32 = + { + f_Output = t_U128; + f_shr_pre = (fun (self: t_U128) (rhs: t_U32) -> true); + f_shr_post = (fun (self: t_U128) (rhs: t_U32) (out: t_U128) -> true); + f_shr + = + fun (self: t_U128) (rhs: t_U32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shr (Core.Base_interface.Coerce.f_lift #t_U128 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U32 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_194: Core.Ops.Bit.t_Shr t_U128 t_U64 = + { + f_Output = t_U128; + f_shr_pre = (fun (self: t_U128) (rhs: t_U64) -> true); + f_shr_post = (fun (self: t_U128) (rhs: t_U64) (out: t_U128) -> true); + f_shr + = + fun (self: t_U128) (rhs: t_U64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shr (Core.Base_interface.Coerce.f_lift #t_U128 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U64 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_195: Core.Ops.Bit.t_Shr t_U128 t_U128 = + { + f_Output = t_U128; + f_shr_pre = (fun (self: t_U128) (rhs: t_U128) -> true); + f_shr_post = (fun (self: t_U128) (rhs: t_U128) (out: t_U128) -> true); + f_shr + = + fun (self: t_U128) (rhs: t_U128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shr (Core.Base_interface.Coerce.f_lift #t_U128 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U128 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_196: Core.Ops.Bit.t_BitXor t_U128 t_U128 = + { + f_Output = t_U128; + f_bitxor_pre = (fun (self: t_U128) (rhs: t_U128) -> true); + f_bitxor_post = (fun (self: t_U128) (rhs: t_U128) (out: t_U128) -> true); + f_bitxor + = + fun (self: t_U128) (rhs: t_U128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_bitxor (Core.Base_interface.Coerce.f_lift #t_U128 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U128 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_197: Core.Ops.Bit.t_BitAnd t_U128 t_U128 = + { + f_Output = t_U128; + f_bitand_pre = (fun (self: t_U128) (rhs: t_U128) -> true); + f_bitand_post = (fun (self: t_U128) (rhs: t_U128) (out: t_U128) -> true); + f_bitand + = + fun (self: t_U128) (rhs: t_U128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_bitand (Core.Base_interface.Coerce.f_lift #t_U128 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U128 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_198: Core.Ops.Bit.t_BitOr t_U128 t_U128 = + { + f_Output = t_U128; + f_bitor_pre = (fun (self: t_U128) (rhs: t_U128) -> true); + f_bitor_post = (fun (self: t_U128) (rhs: t_U128) (out: t_U128) -> true); + f_bitor + = + fun (self: t_U128) (rhs: t_U128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_bitor (Core.Base_interface.Coerce.f_lift #t_U128 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U128 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_206: Core.Ops.Arith.t_Neg t_U64 = + { + f_Output = t_U64; + f_neg_pre = (fun (self: t_U64) -> true); + f_neg_post = (fun (self: t_U64) (out: t_U64) -> true); + f_neg + = + fun (self: t_U64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_sub Core.Base.Spec.Constants.v_WORDSIZE_64_ + (Core.Base.Pos.haxint_rem (Core.Base_interface.Coerce.f_lift #t_U64 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + Core.Base.Spec.Constants.v_WORDSIZE_64_ + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_209: Core.Ops.Arith.t_Mul t_U64 t_U64 = + { + f_Output = t_U64; + f_mul_pre = (fun (self: t_U64) (rhs: t_U64) -> true); + f_mul_post = (fun (self: t_U64) (rhs: t_U64) (out: t_U64) -> true); + f_mul + = + fun (self: t_U64) (rhs: t_U64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_mul (Core.Base_interface.Coerce.f_lift #t_U64 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U64 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_210: Core.Ops.Arith.t_Rem t_U64 t_U64 = + { + f_Output = t_U64; + f_rem_pre = (fun (self: t_U64) (rhs: t_U64) -> true); + f_rem_post = (fun (self: t_U64) (rhs: t_U64) (out: t_U64) -> true); + f_rem + = + fun (self: t_U64) (rhs: t_U64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_rem (Core.Base_interface.Coerce.f_lift #t_U64 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U64 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_211: Core.Ops.Arith.t_Add t_U64 t_U64 = + { + f_Output = t_U64; + f_add_pre = (fun (self: t_U64) (rhs: t_U64) -> true); + f_add_post = (fun (self: t_U64) (rhs: t_U64) (out: t_U64) -> true); + f_add + = + fun (self: t_U64) (rhs: t_U64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_add (Core.Base_interface.Coerce.f_lift #t_U64 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U64 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_212: Core.Ops.Arith.t_Div t_U64 t_U64 = + { + f_Output = t_U64; + f_div_pre = (fun (self: t_U64) (rhs: t_U64) -> true); + f_div_post = (fun (self: t_U64) (rhs: t_U64) (out: t_U64) -> true); + f_div + = + fun (self: t_U64) (rhs: t_U64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_div (Core.Base_interface.Coerce.f_lift #t_U64 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U64 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_213: Core.Ops.Bit.t_Shl t_U64 t_U8 = + { + f_Output = t_U64; + f_shl_pre = (fun (self: t_U64) (rhs: t_U8) -> true); + f_shl_post = (fun (self: t_U64) (rhs: t_U8) (out: t_U64) -> true); + f_shl + = + fun (self: t_U64) (rhs: t_U8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shl (Core.Base_interface.Coerce.f_lift #t_U64 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U8 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_214: Core.Ops.Bit.t_Shl t_U64 t_U16 = + { + f_Output = t_U64; + f_shl_pre = (fun (self: t_U64) (rhs: t_U16) -> true); + f_shl_post = (fun (self: t_U64) (rhs: t_U16) (out: t_U64) -> true); + f_shl + = + fun (self: t_U64) (rhs: t_U16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shl (Core.Base_interface.Coerce.f_lift #t_U64 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U16 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_215: Core.Ops.Bit.t_Shl t_U64 t_U32 = + { + f_Output = t_U64; + f_shl_pre = (fun (self: t_U64) (rhs: t_U32) -> true); + f_shl_post = (fun (self: t_U64) (rhs: t_U32) (out: t_U64) -> true); + f_shl + = + fun (self: t_U64) (rhs: t_U32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shl (Core.Base_interface.Coerce.f_lift #t_U64 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U32 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_216: Core.Ops.Bit.t_Shl t_U64 t_U64 = + { + f_Output = t_U64; + f_shl_pre = (fun (self: t_U64) (rhs: t_U64) -> true); + f_shl_post = (fun (self: t_U64) (rhs: t_U64) (out: t_U64) -> true); + f_shl + = + fun (self: t_U64) (rhs: t_U64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shl (Core.Base_interface.Coerce.f_lift #t_U64 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U64 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_217: Core.Ops.Bit.t_Shl t_U64 t_U128 = + { + f_Output = t_U64; + f_shl_pre = (fun (self: t_U64) (rhs: t_U128) -> true); + f_shl_post = (fun (self: t_U64) (rhs: t_U128) (out: t_U64) -> true); + f_shl + = + fun (self: t_U64) (rhs: t_U128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shl (Core.Base_interface.Coerce.f_lift #t_U64 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U128 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_218: Core.Ops.Bit.t_Shr t_U64 t_U8 = + { + f_Output = t_U64; + f_shr_pre = (fun (self: t_U64) (rhs: t_U8) -> true); + f_shr_post = (fun (self: t_U64) (rhs: t_U8) (out: t_U64) -> true); + f_shr + = + fun (self: t_U64) (rhs: t_U8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shr (Core.Base_interface.Coerce.f_lift #t_U64 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U8 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_219: Core.Ops.Bit.t_Shr t_U64 t_U16 = + { + f_Output = t_U64; + f_shr_pre = (fun (self: t_U64) (rhs: t_U16) -> true); + f_shr_post = (fun (self: t_U64) (rhs: t_U16) (out: t_U64) -> true); + f_shr + = + fun (self: t_U64) (rhs: t_U16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shr (Core.Base_interface.Coerce.f_lift #t_U64 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U16 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_220: Core.Ops.Bit.t_Shr t_U64 t_U32 = + { + f_Output = t_U64; + f_shr_pre = (fun (self: t_U64) (rhs: t_U32) -> true); + f_shr_post = (fun (self: t_U64) (rhs: t_U32) (out: t_U64) -> true); + f_shr + = + fun (self: t_U64) (rhs: t_U32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shr (Core.Base_interface.Coerce.f_lift #t_U64 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U32 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_221: Core.Ops.Bit.t_Shr t_U64 t_U64 = + { + f_Output = t_U64; + f_shr_pre = (fun (self: t_U64) (rhs: t_U64) -> true); + f_shr_post = (fun (self: t_U64) (rhs: t_U64) (out: t_U64) -> true); + f_shr + = + fun (self: t_U64) (rhs: t_U64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shr (Core.Base_interface.Coerce.f_lift #t_U64 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U64 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_222: Core.Ops.Bit.t_Shr t_U64 t_U128 = + { + f_Output = t_U64; + f_shr_pre = (fun (self: t_U64) (rhs: t_U128) -> true); + f_shr_post = (fun (self: t_U64) (rhs: t_U128) (out: t_U64) -> true); + f_shr + = + fun (self: t_U64) (rhs: t_U128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shr (Core.Base_interface.Coerce.f_lift #t_U64 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U128 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_223: Core.Ops.Bit.t_BitXor t_U64 t_U64 = + { + f_Output = t_U64; + f_bitxor_pre = (fun (self: t_U64) (rhs: t_U64) -> true); + f_bitxor_post = (fun (self: t_U64) (rhs: t_U64) (out: t_U64) -> true); + f_bitxor + = + fun (self: t_U64) (rhs: t_U64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_bitxor (Core.Base_interface.Coerce.f_lift #t_U64 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U64 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_224: Core.Ops.Bit.t_BitAnd t_U64 t_U64 = + { + f_Output = t_U64; + f_bitand_pre = (fun (self: t_U64) (rhs: t_U64) -> true); + f_bitand_post = (fun (self: t_U64) (rhs: t_U64) (out: t_U64) -> true); + f_bitand + = + fun (self: t_U64) (rhs: t_U64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_bitand (Core.Base_interface.Coerce.f_lift #t_U64 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U64 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_225: Core.Ops.Bit.t_BitOr t_U64 t_U64 = + { + f_Output = t_U64; + f_bitor_pre = (fun (self: t_U64) (rhs: t_U64) -> true); + f_bitor_post = (fun (self: t_U64) (rhs: t_U64) (out: t_U64) -> true); + f_bitor + = + fun (self: t_U64) (rhs: t_U64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_bitor (Core.Base_interface.Coerce.f_lift #t_U64 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U64 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_233: Core.Ops.Arith.t_Neg t_U32 = + { + f_Output = t_U32; + f_neg_pre = (fun (self: t_U32) -> true); + f_neg_post = (fun (self: t_U32) (out: t_U32) -> true); + f_neg + = + fun (self: t_U32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_sub Core.Base.Spec.Constants.v_WORDSIZE_32_ + (Core.Base.Pos.haxint_rem (Core.Base_interface.Coerce.f_lift #t_U32 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + Core.Base.Spec.Constants.v_WORDSIZE_32_ + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_236: Core.Ops.Arith.t_Mul t_U32 t_U32 = + { + f_Output = t_U32; + f_mul_pre = (fun (self: t_U32) (rhs: t_U32) -> true); + f_mul_post = (fun (self: t_U32) (rhs: t_U32) (out: t_U32) -> true); + f_mul + = + fun (self: t_U32) (rhs: t_U32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_mul (Core.Base_interface.Coerce.f_lift #t_U32 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U32 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_237: Core.Ops.Arith.t_Rem t_U32 t_U32 = + { + f_Output = t_U32; + f_rem_pre = (fun (self: t_U32) (rhs: t_U32) -> true); + f_rem_post = (fun (self: t_U32) (rhs: t_U32) (out: t_U32) -> true); + f_rem + = + fun (self: t_U32) (rhs: t_U32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_rem (Core.Base_interface.Coerce.f_lift #t_U32 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U32 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_238: Core.Ops.Arith.t_Add t_U32 t_U32 = + { + f_Output = t_U32; + f_add_pre = (fun (self: t_U32) (rhs: t_U32) -> true); + f_add_post = (fun (self: t_U32) (rhs: t_U32) (out: t_U32) -> true); + f_add + = + fun (self: t_U32) (rhs: t_U32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_add (Core.Base_interface.Coerce.f_lift #t_U32 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U32 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_239: Core.Ops.Arith.t_Div t_U32 t_U32 = + { + f_Output = t_U32; + f_div_pre = (fun (self: t_U32) (rhs: t_U32) -> true); + f_div_post = (fun (self: t_U32) (rhs: t_U32) (out: t_U32) -> true); + f_div + = + fun (self: t_U32) (rhs: t_U32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_div (Core.Base_interface.Coerce.f_lift #t_U32 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U32 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_240: Core.Ops.Bit.t_Shl t_U32 t_U8 = + { + f_Output = t_U32; + f_shl_pre = (fun (self: t_U32) (rhs: t_U8) -> true); + f_shl_post = (fun (self: t_U32) (rhs: t_U8) (out: t_U32) -> true); + f_shl + = + fun (self: t_U32) (rhs: t_U8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shl (Core.Base_interface.Coerce.f_lift #t_U32 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U8 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_241: Core.Ops.Bit.t_Shl t_U32 t_U16 = + { + f_Output = t_U32; + f_shl_pre = (fun (self: t_U32) (rhs: t_U16) -> true); + f_shl_post = (fun (self: t_U32) (rhs: t_U16) (out: t_U32) -> true); + f_shl + = + fun (self: t_U32) (rhs: t_U16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shl (Core.Base_interface.Coerce.f_lift #t_U32 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U16 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_242: Core.Ops.Bit.t_Shl t_U32 t_U32 = + { + f_Output = t_U32; + f_shl_pre = (fun (self: t_U32) (rhs: t_U32) -> true); + f_shl_post = (fun (self: t_U32) (rhs: t_U32) (out: t_U32) -> true); + f_shl + = + fun (self: t_U32) (rhs: t_U32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shl (Core.Base_interface.Coerce.f_lift #t_U32 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U32 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_243: Core.Ops.Bit.t_Shl t_U32 t_U64 = + { + f_Output = t_U32; + f_shl_pre = (fun (self: t_U32) (rhs: t_U64) -> true); + f_shl_post = (fun (self: t_U32) (rhs: t_U64) (out: t_U32) -> true); + f_shl + = + fun (self: t_U32) (rhs: t_U64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shl (Core.Base_interface.Coerce.f_lift #t_U32 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U64 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_244: Core.Ops.Bit.t_Shl t_U32 t_U128 = + { + f_Output = t_U32; + f_shl_pre = (fun (self: t_U32) (rhs: t_U128) -> true); + f_shl_post = (fun (self: t_U32) (rhs: t_U128) (out: t_U32) -> true); + f_shl + = + fun (self: t_U32) (rhs: t_U128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shl (Core.Base_interface.Coerce.f_lift #t_U32 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U128 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_245: Core.Ops.Bit.t_Shr t_U32 t_U8 = + { + f_Output = t_U32; + f_shr_pre = (fun (self: t_U32) (rhs: t_U8) -> true); + f_shr_post = (fun (self: t_U32) (rhs: t_U8) (out: t_U32) -> true); + f_shr + = + fun (self: t_U32) (rhs: t_U8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shr (Core.Base_interface.Coerce.f_lift #t_U32 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U8 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_246: Core.Ops.Bit.t_Shr t_U32 t_U16 = + { + f_Output = t_U32; + f_shr_pre = (fun (self: t_U32) (rhs: t_U16) -> true); + f_shr_post = (fun (self: t_U32) (rhs: t_U16) (out: t_U32) -> true); + f_shr + = + fun (self: t_U32) (rhs: t_U16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shr (Core.Base_interface.Coerce.f_lift #t_U32 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U16 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_247: Core.Ops.Bit.t_Shr t_U32 t_U32 = + { + f_Output = t_U32; + f_shr_pre = (fun (self: t_U32) (rhs: t_U32) -> true); + f_shr_post = (fun (self: t_U32) (rhs: t_U32) (out: t_U32) -> true); + f_shr + = + fun (self: t_U32) (rhs: t_U32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shr (Core.Base_interface.Coerce.f_lift #t_U32 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U32 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_248: Core.Ops.Bit.t_Shr t_U32 t_U64 = + { + f_Output = t_U32; + f_shr_pre = (fun (self: t_U32) (rhs: t_U64) -> true); + f_shr_post = (fun (self: t_U32) (rhs: t_U64) (out: t_U32) -> true); + f_shr + = + fun (self: t_U32) (rhs: t_U64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shr (Core.Base_interface.Coerce.f_lift #t_U32 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U64 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_249: Core.Ops.Bit.t_Shr t_U32 t_U128 = + { + f_Output = t_U32; + f_shr_pre = (fun (self: t_U32) (rhs: t_U128) -> true); + f_shr_post = (fun (self: t_U32) (rhs: t_U128) (out: t_U32) -> true); + f_shr + = + fun (self: t_U32) (rhs: t_U128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shr (Core.Base_interface.Coerce.f_lift #t_U32 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U128 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_250: Core.Ops.Bit.t_BitXor t_U32 t_U32 = + { + f_Output = t_U32; + f_bitxor_pre = (fun (self: t_U32) (rhs: t_U32) -> true); + f_bitxor_post = (fun (self: t_U32) (rhs: t_U32) (out: t_U32) -> true); + f_bitxor + = + fun (self: t_U32) (rhs: t_U32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_bitxor (Core.Base_interface.Coerce.f_lift #t_U32 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U32 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_251: Core.Ops.Bit.t_BitAnd t_U32 t_U32 = + { + f_Output = t_U32; + f_bitand_pre = (fun (self: t_U32) (rhs: t_U32) -> true); + f_bitand_post = (fun (self: t_U32) (rhs: t_U32) (out: t_U32) -> true); + f_bitand + = + fun (self: t_U32) (rhs: t_U32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_bitand (Core.Base_interface.Coerce.f_lift #t_U32 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U32 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_252: Core.Ops.Bit.t_BitOr t_U32 t_U32 = + { + f_Output = t_U32; + f_bitor_pre = (fun (self: t_U32) (rhs: t_U32) -> true); + f_bitor_post = (fun (self: t_U32) (rhs: t_U32) (out: t_U32) -> true); + f_bitor + = + fun (self: t_U32) (rhs: t_U32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_bitor (Core.Base_interface.Coerce.f_lift #t_U32 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U32 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_260: Core.Ops.Arith.t_Neg t_U16 = + { + f_Output = t_U16; + f_neg_pre = (fun (self: t_U16) -> true); + f_neg_post = (fun (self: t_U16) (out: t_U16) -> true); + f_neg + = + fun (self: t_U16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_sub Core.Base.Spec.Constants.v_WORDSIZE_16_ + (Core.Base.Pos.haxint_rem (Core.Base_interface.Coerce.f_lift #t_U16 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + Core.Base.Spec.Constants.v_WORDSIZE_16_ + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_263: Core.Ops.Arith.t_Mul t_U16 t_U16 = + { + f_Output = t_U16; + f_mul_pre = (fun (self: t_U16) (rhs: t_U16) -> true); + f_mul_post = (fun (self: t_U16) (rhs: t_U16) (out: t_U16) -> true); + f_mul + = + fun (self: t_U16) (rhs: t_U16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_mul (Core.Base_interface.Coerce.f_lift #t_U16 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U16 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_264: Core.Ops.Arith.t_Rem t_U16 t_U16 = + { + f_Output = t_U16; + f_rem_pre = (fun (self: t_U16) (rhs: t_U16) -> true); + f_rem_post = (fun (self: t_U16) (rhs: t_U16) (out: t_U16) -> true); + f_rem + = + fun (self: t_U16) (rhs: t_U16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_rem (Core.Base_interface.Coerce.f_lift #t_U16 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U16 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_265: Core.Ops.Arith.t_Add t_U16 t_U16 = + { + f_Output = t_U16; + f_add_pre = (fun (self: t_U16) (rhs: t_U16) -> true); + f_add_post = (fun (self: t_U16) (rhs: t_U16) (out: t_U16) -> true); + f_add + = + fun (self: t_U16) (rhs: t_U16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_add (Core.Base_interface.Coerce.f_lift #t_U16 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U16 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_266: Core.Ops.Arith.t_Div t_U16 t_U16 = + { + f_Output = t_U16; + f_div_pre = (fun (self: t_U16) (rhs: t_U16) -> true); + f_div_post = (fun (self: t_U16) (rhs: t_U16) (out: t_U16) -> true); + f_div + = + fun (self: t_U16) (rhs: t_U16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_div (Core.Base_interface.Coerce.f_lift #t_U16 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U16 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_267: Core.Ops.Bit.t_Shl t_U16 t_U8 = + { + f_Output = t_U16; + f_shl_pre = (fun (self: t_U16) (rhs: t_U8) -> true); + f_shl_post = (fun (self: t_U16) (rhs: t_U8) (out: t_U16) -> true); + f_shl + = + fun (self: t_U16) (rhs: t_U8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shl (Core.Base_interface.Coerce.f_lift #t_U16 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U8 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_268: Core.Ops.Bit.t_Shl t_U16 t_U16 = + { + f_Output = t_U16; + f_shl_pre = (fun (self: t_U16) (rhs: t_U16) -> true); + f_shl_post = (fun (self: t_U16) (rhs: t_U16) (out: t_U16) -> true); + f_shl + = + fun (self: t_U16) (rhs: t_U16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shl (Core.Base_interface.Coerce.f_lift #t_U16 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U16 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_269: Core.Ops.Bit.t_Shl t_U16 t_U32 = + { + f_Output = t_U16; + f_shl_pre = (fun (self: t_U16) (rhs: t_U32) -> true); + f_shl_post = (fun (self: t_U16) (rhs: t_U32) (out: t_U16) -> true); + f_shl + = + fun (self: t_U16) (rhs: t_U32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shl (Core.Base_interface.Coerce.f_lift #t_U16 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U32 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_270: Core.Ops.Bit.t_Shl t_U16 t_U64 = + { + f_Output = t_U16; + f_shl_pre = (fun (self: t_U16) (rhs: t_U64) -> true); + f_shl_post = (fun (self: t_U16) (rhs: t_U64) (out: t_U16) -> true); + f_shl + = + fun (self: t_U16) (rhs: t_U64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shl (Core.Base_interface.Coerce.f_lift #t_U16 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U64 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_271: Core.Ops.Bit.t_Shl t_U16 t_U128 = + { + f_Output = t_U16; + f_shl_pre = (fun (self: t_U16) (rhs: t_U128) -> true); + f_shl_post = (fun (self: t_U16) (rhs: t_U128) (out: t_U16) -> true); + f_shl + = + fun (self: t_U16) (rhs: t_U128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shl (Core.Base_interface.Coerce.f_lift #t_U16 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U128 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_272: Core.Ops.Bit.t_Shr t_U16 t_U8 = + { + f_Output = t_U16; + f_shr_pre = (fun (self: t_U16) (rhs: t_U8) -> true); + f_shr_post = (fun (self: t_U16) (rhs: t_U8) (out: t_U16) -> true); + f_shr + = + fun (self: t_U16) (rhs: t_U8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shr (Core.Base_interface.Coerce.f_lift #t_U16 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U8 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_273: Core.Ops.Bit.t_Shr t_U16 t_U16 = + { + f_Output = t_U16; + f_shr_pre = (fun (self: t_U16) (rhs: t_U16) -> true); + f_shr_post = (fun (self: t_U16) (rhs: t_U16) (out: t_U16) -> true); + f_shr + = + fun (self: t_U16) (rhs: t_U16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shr (Core.Base_interface.Coerce.f_lift #t_U16 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U16 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_274: Core.Ops.Bit.t_Shr t_U16 t_U32 = + { + f_Output = t_U16; + f_shr_pre = (fun (self: t_U16) (rhs: t_U32) -> true); + f_shr_post = (fun (self: t_U16) (rhs: t_U32) (out: t_U16) -> true); + f_shr + = + fun (self: t_U16) (rhs: t_U32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shr (Core.Base_interface.Coerce.f_lift #t_U16 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U32 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_275: Core.Ops.Bit.t_Shr t_U16 t_U64 = + { + f_Output = t_U16; + f_shr_pre = (fun (self: t_U16) (rhs: t_U64) -> true); + f_shr_post = (fun (self: t_U16) (rhs: t_U64) (out: t_U16) -> true); + f_shr + = + fun (self: t_U16) (rhs: t_U64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shr (Core.Base_interface.Coerce.f_lift #t_U16 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U64 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_276: Core.Ops.Bit.t_Shr t_U16 t_U128 = + { + f_Output = t_U16; + f_shr_pre = (fun (self: t_U16) (rhs: t_U128) -> true); + f_shr_post = (fun (self: t_U16) (rhs: t_U128) (out: t_U16) -> true); + f_shr + = + fun (self: t_U16) (rhs: t_U128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shr (Core.Base_interface.Coerce.f_lift #t_U16 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U128 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_277: Core.Ops.Bit.t_BitXor t_U16 t_U16 = + { + f_Output = t_U16; + f_bitxor_pre = (fun (self: t_U16) (rhs: t_U16) -> true); + f_bitxor_post = (fun (self: t_U16) (rhs: t_U16) (out: t_U16) -> true); + f_bitxor + = + fun (self: t_U16) (rhs: t_U16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_bitxor (Core.Base_interface.Coerce.f_lift #t_U16 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U16 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_278: Core.Ops.Bit.t_BitAnd t_U16 t_U16 = + { + f_Output = t_U16; + f_bitand_pre = (fun (self: t_U16) (rhs: t_U16) -> true); + f_bitand_post = (fun (self: t_U16) (rhs: t_U16) (out: t_U16) -> true); + f_bitand + = + fun (self: t_U16) (rhs: t_U16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_bitand (Core.Base_interface.Coerce.f_lift #t_U16 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U16 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_279: Core.Ops.Bit.t_BitOr t_U16 t_U16 = + { + f_Output = t_U16; + f_bitor_pre = (fun (self: t_U16) (rhs: t_U16) -> true); + f_bitor_post = (fun (self: t_U16) (rhs: t_U16) (out: t_U16) -> true); + f_bitor + = + fun (self: t_U16) (rhs: t_U16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_bitor (Core.Base_interface.Coerce.f_lift #t_U16 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U16 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_287: Core.Ops.Arith.t_Neg t_U8 = + { + f_Output = t_U8; + f_neg_pre = (fun (self: t_U8) -> true); + f_neg_post = (fun (self: t_U8) (out: t_U8) -> true); + f_neg + = + fun (self: t_U8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_sub Core.Base.Spec.Constants.v_WORDSIZE_8_ + (Core.Base.Pos.haxint_rem (Core.Base_interface.Coerce.f_lift #t_U8 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + Core.Base.Spec.Constants.v_WORDSIZE_8_ + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_290: Core.Ops.Arith.t_Mul t_U8 t_U8 = + { + f_Output = t_U8; + f_mul_pre = (fun (self: t_U8) (rhs: t_U8) -> true); + f_mul_post = (fun (self: t_U8) (rhs: t_U8) (out: t_U8) -> true); + f_mul + = + fun (self: t_U8) (rhs: t_U8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_mul (Core.Base_interface.Coerce.f_lift #t_U8 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U8 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_291: Core.Ops.Arith.t_Rem t_U8 t_U8 = + { + f_Output = t_U8; + f_rem_pre = (fun (self: t_U8) (rhs: t_U8) -> true); + f_rem_post = (fun (self: t_U8) (rhs: t_U8) (out: t_U8) -> true); + f_rem + = + fun (self: t_U8) (rhs: t_U8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_rem (Core.Base_interface.Coerce.f_lift #t_U8 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U8 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_292: Core.Ops.Arith.t_Add t_U8 t_U8 = + { + f_Output = t_U8; + f_add_pre = (fun (self: t_U8) (rhs: t_U8) -> true); + f_add_post = (fun (self: t_U8) (rhs: t_U8) (out: t_U8) -> true); + f_add + = + fun (self: t_U8) (rhs: t_U8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_add (Core.Base_interface.Coerce.f_lift #t_U8 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U8 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_293: Core.Ops.Arith.t_Div t_U8 t_U8 = + { + f_Output = t_U8; + f_div_pre = (fun (self: t_U8) (rhs: t_U8) -> true); + f_div_post = (fun (self: t_U8) (rhs: t_U8) (out: t_U8) -> true); + f_div + = + fun (self: t_U8) (rhs: t_U8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_div (Core.Base_interface.Coerce.f_lift #t_U8 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U8 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_294: Core.Ops.Bit.t_Shl t_U8 t_U8 = + { + f_Output = t_U8; + f_shl_pre = (fun (self: t_U8) (rhs: t_U8) -> true); + f_shl_post = (fun (self: t_U8) (rhs: t_U8) (out: t_U8) -> true); + f_shl + = + fun (self: t_U8) (rhs: t_U8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shl (Core.Base_interface.Coerce.f_lift #t_U8 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U8 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_295: Core.Ops.Bit.t_Shl t_U8 t_U16 = + { + f_Output = t_U8; + f_shl_pre = (fun (self: t_U8) (rhs: t_U16) -> true); + f_shl_post = (fun (self: t_U8) (rhs: t_U16) (out: t_U8) -> true); + f_shl + = + fun (self: t_U8) (rhs: t_U16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shl (Core.Base_interface.Coerce.f_lift #t_U8 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U16 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_296: Core.Ops.Bit.t_Shl t_U8 t_U32 = + { + f_Output = t_U8; + f_shl_pre = (fun (self: t_U8) (rhs: t_U32) -> true); + f_shl_post = (fun (self: t_U8) (rhs: t_U32) (out: t_U8) -> true); + f_shl + = + fun (self: t_U8) (rhs: t_U32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shl (Core.Base_interface.Coerce.f_lift #t_U8 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U32 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_297: Core.Ops.Bit.t_Shl t_U8 t_U64 = + { + f_Output = t_U8; + f_shl_pre = (fun (self: t_U8) (rhs: t_U64) -> true); + f_shl_post = (fun (self: t_U8) (rhs: t_U64) (out: t_U8) -> true); + f_shl + = + fun (self: t_U8) (rhs: t_U64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shl (Core.Base_interface.Coerce.f_lift #t_U8 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U64 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_298: Core.Ops.Bit.t_Shl t_U8 t_U128 = + { + f_Output = t_U8; + f_shl_pre = (fun (self: t_U8) (rhs: t_U128) -> true); + f_shl_post = (fun (self: t_U8) (rhs: t_U128) (out: t_U8) -> true); + f_shl + = + fun (self: t_U8) (rhs: t_U128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shl (Core.Base_interface.Coerce.f_lift #t_U8 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U128 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_299: Core.Ops.Bit.t_Shr t_U8 t_U8 = + { + f_Output = t_U8; + f_shr_pre = (fun (self: t_U8) (rhs: t_U8) -> true); + f_shr_post = (fun (self: t_U8) (rhs: t_U8) (out: t_U8) -> true); + f_shr + = + fun (self: t_U8) (rhs: t_U8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shr (Core.Base_interface.Coerce.f_lift #t_U8 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U8 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_300: Core.Ops.Bit.t_Shr t_U8 t_U16 = + { + f_Output = t_U8; + f_shr_pre = (fun (self: t_U8) (rhs: t_U16) -> true); + f_shr_post = (fun (self: t_U8) (rhs: t_U16) (out: t_U8) -> true); + f_shr + = + fun (self: t_U8) (rhs: t_U16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shr (Core.Base_interface.Coerce.f_lift #t_U8 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U16 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_301: Core.Ops.Bit.t_Shr t_U8 t_U32 = + { + f_Output = t_U8; + f_shr_pre = (fun (self: t_U8) (rhs: t_U32) -> true); + f_shr_post = (fun (self: t_U8) (rhs: t_U32) (out: t_U8) -> true); + f_shr + = + fun (self: t_U8) (rhs: t_U32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shr (Core.Base_interface.Coerce.f_lift #t_U8 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U32 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_302: Core.Ops.Bit.t_Shr t_U8 t_U64 = + { + f_Output = t_U8; + f_shr_pre = (fun (self: t_U8) (rhs: t_U64) -> true); + f_shr_post = (fun (self: t_U8) (rhs: t_U64) (out: t_U8) -> true); + f_shr + = + fun (self: t_U8) (rhs: t_U64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shr (Core.Base_interface.Coerce.f_lift #t_U8 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U64 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_303: Core.Ops.Bit.t_Shr t_U8 t_U128 = + { + f_Output = t_U8; + f_shr_pre = (fun (self: t_U8) (rhs: t_U128) -> true); + f_shr_post = (fun (self: t_U8) (rhs: t_U128) (out: t_U8) -> true); + f_shr + = + fun (self: t_U8) (rhs: t_U128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_shr (Core.Base_interface.Coerce.f_lift #t_U8 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U128 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_304: Core.Ops.Bit.t_BitXor t_U8 t_U8 = + { + f_Output = t_U8; + f_bitxor_pre = (fun (self: t_U8) (rhs: t_U8) -> true); + f_bitxor_post = (fun (self: t_U8) (rhs: t_U8) (out: t_U8) -> true); + f_bitxor + = + fun (self: t_U8) (rhs: t_U8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_bitxor (Core.Base_interface.Coerce.f_lift #t_U8 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U8 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_305: Core.Ops.Bit.t_BitAnd t_U8 t_U8 = + { + f_Output = t_U8; + f_bitand_pre = (fun (self: t_U8) (rhs: t_U8) -> true); + f_bitand_post = (fun (self: t_U8) (rhs: t_U8) (out: t_U8) -> true); + f_bitand + = + fun (self: t_U8) (rhs: t_U8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_bitand (Core.Base_interface.Coerce.f_lift #t_U8 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U8 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_306: Core.Ops.Bit.t_BitOr t_U8 t_U8 = + { + f_Output = t_U8; + f_bitor_pre = (fun (self: t_U8) (rhs: t_U8) -> true); + f_bitor_post = (fun (self: t_U8) (rhs: t_U8) (out: t_U8) -> true); + f_bitor + = + fun (self: t_U8) (rhs: t_U8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Pos.haxint_bitor (Core.Base_interface.Coerce.f_lift #t_U8 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #t_U8 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Haxint.t_HaxInt) + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_46: Core.Ops.Arith.t_Rem t_I128 t_I128 = + { + f_Output = t_I128; + f_rem_pre = (fun (self: t_I128) (rhs: t_I128) -> true); + f_rem_post = (fun (self: t_I128) (rhs: t_I128) (out: t_I128) -> true); + f_rem + = + fun (self: t_I128) (rhs: t_I128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I128 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_rem (Core.Base_interface.Coerce.f_lift #t_I128 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I128 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_48: Core.Ops.Arith.t_Div t_I128 t_I128 = + { + f_Output = t_I128; + f_div_pre = (fun (self: t_I128) (rhs: t_I128) -> true); + f_div_post = (fun (self: t_I128) (rhs: t_I128) (out: t_I128) -> true); + f_div + = + fun (self: t_I128) (rhs: t_I128) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I128 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_div (Core.Base_interface.Coerce.f_lift #t_I128 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I128 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_73: Core.Ops.Arith.t_Rem t_I64 t_I64 = + { + f_Output = t_I64; + f_rem_pre = (fun (self: t_I64) (rhs: t_I64) -> true); + f_rem_post = (fun (self: t_I64) (rhs: t_I64) (out: t_I64) -> true); + f_rem + = + fun (self: t_I64) (rhs: t_I64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I64 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_rem (Core.Base_interface.Coerce.f_lift #t_I64 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I64 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_75: Core.Ops.Arith.t_Div t_I64 t_I64 = + { + f_Output = t_I64; + f_div_pre = (fun (self: t_I64) (rhs: t_I64) -> true); + f_div_post = (fun (self: t_I64) (rhs: t_I64) (out: t_I64) -> true); + f_div + = + fun (self: t_I64) (rhs: t_I64) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I64 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_div (Core.Base_interface.Coerce.f_lift #t_I64 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I64 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_100: Core.Ops.Arith.t_Rem t_I32 t_I32 = + { + f_Output = t_I32; + f_rem_pre = (fun (self: t_I32) (rhs: t_I32) -> true); + f_rem_post = (fun (self: t_I32) (rhs: t_I32) (out: t_I32) -> true); + f_rem + = + fun (self: t_I32) (rhs: t_I32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I32 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_rem (Core.Base_interface.Coerce.f_lift #t_I32 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I32 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_102: Core.Ops.Arith.t_Div t_I32 t_I32 = + { + f_Output = t_I32; + f_div_pre = (fun (self: t_I32) (rhs: t_I32) -> true); + f_div_post = (fun (self: t_I32) (rhs: t_I32) (out: t_I32) -> true); + f_div + = + fun (self: t_I32) (rhs: t_I32) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I32 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_div (Core.Base_interface.Coerce.f_lift #t_I32 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I32 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_127: Core.Ops.Arith.t_Rem t_I16 t_I16 = + { + f_Output = t_I16; + f_rem_pre = (fun (self: t_I16) (rhs: t_I16) -> true); + f_rem_post = (fun (self: t_I16) (rhs: t_I16) (out: t_I16) -> true); + f_rem + = + fun (self: t_I16) (rhs: t_I16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I16 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_rem (Core.Base_interface.Coerce.f_lift #t_I16 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I16 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_129: Core.Ops.Arith.t_Div t_I16 t_I16 = + { + f_Output = t_I16; + f_div_pre = (fun (self: t_I16) (rhs: t_I16) -> true); + f_div_post = (fun (self: t_I16) (rhs: t_I16) (out: t_I16) -> true); + f_div + = + fun (self: t_I16) (rhs: t_I16) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I16 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_div (Core.Base_interface.Coerce.f_lift #t_I16 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I16 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_154: Core.Ops.Arith.t_Rem t_I8 t_I8 = + { + f_Output = t_I8; + f_rem_pre = (fun (self: t_I8) (rhs: t_I8) -> true); + f_rem_post = (fun (self: t_I8) (rhs: t_I8) (out: t_I8) -> true); + f_rem + = + fun (self: t_I8) (rhs: t_I8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I8 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_rem (Core.Base_interface.Coerce.f_lift #t_I8 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I8 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_156: Core.Ops.Arith.t_Div t_I8 t_I8 = + { + f_Output = t_I8; + f_div_pre = (fun (self: t_I8) (rhs: t_I8) -> true); + f_div_post = (fun (self: t_I8) (rhs: t_I8) (out: t_I8) -> true); + f_div + = + fun (self: t_I8) (rhs: t_I8) -> + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #t_I8 + #FStar.Tactics.Typeclasses.solve + (Core.Base.Z.z_div (Core.Base_interface.Coerce.f_lift #t_I8 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #t_I8 #FStar.Tactics.Typeclasses.solve rhs + <: + Core.Base.Spec.Z.t_Z) + <: + Core.Base.Spec.Z.t_Z) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_180: Core.Ops.Arith.t_Sub t_U128 t_U128 = + { + f_Output = t_U128; + f_sub_pre = (fun (self: t_U128) (rhs: t_U128) -> true); + f_sub_post = (fun (self: t_U128) (rhs: t_U128) (out: t_U128) -> true); + f_sub + = + fun (self: t_U128) (rhs: t_U128) -> + self +! (Core.Ops.Arith.f_neg #t_U128 #FStar.Tactics.Typeclasses.solve rhs <: t_U128) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_181: Core.Ops.Bit.t_Not t_U128 = + { + f_Output = t_U128; + f_not_pre = (fun (self: t_U128) -> true); + f_not_post = (fun (self: t_U128) (out: t_U128) -> true); + f_not = fun (self: t_U128) -> self ^. (f_MAX #FStar.Tactics.Typeclasses.solve <: t_U128) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_207: Core.Ops.Arith.t_Sub t_U64 t_U64 = + { + f_Output = t_U64; + f_sub_pre = (fun (self: t_U64) (rhs: t_U64) -> true); + f_sub_post = (fun (self: t_U64) (rhs: t_U64) (out: t_U64) -> true); + f_sub + = + fun (self: t_U64) (rhs: t_U64) -> + self +! (Core.Ops.Arith.f_neg #t_U64 #FStar.Tactics.Typeclasses.solve rhs <: t_U64) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_208: Core.Ops.Bit.t_Not t_U64 = + { + f_Output = t_U64; + f_not_pre = (fun (self: t_U64) -> true); + f_not_post = (fun (self: t_U64) (out: t_U64) -> true); + f_not = fun (self: t_U64) -> self ^. (f_MAX #FStar.Tactics.Typeclasses.solve <: t_U64) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_234: Core.Ops.Arith.t_Sub t_U32 t_U32 = + { + f_Output = t_U32; + f_sub_pre = (fun (self: t_U32) (rhs: t_U32) -> true); + f_sub_post = (fun (self: t_U32) (rhs: t_U32) (out: t_U32) -> true); + f_sub + = + fun (self: t_U32) (rhs: t_U32) -> + self +! (Core.Ops.Arith.f_neg #t_U32 #FStar.Tactics.Typeclasses.solve rhs <: t_U32) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_235: Core.Ops.Bit.t_Not t_U32 = + { + f_Output = t_U32; + f_not_pre = (fun (self: t_U32) -> true); + f_not_post = (fun (self: t_U32) (out: t_U32) -> true); + f_not = fun (self: t_U32) -> self ^. (f_MAX #FStar.Tactics.Typeclasses.solve <: t_U32) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_261: Core.Ops.Arith.t_Sub t_U16 t_U16 = + { + f_Output = t_U16; + f_sub_pre = (fun (self: t_U16) (rhs: t_U16) -> true); + f_sub_post = (fun (self: t_U16) (rhs: t_U16) (out: t_U16) -> true); + f_sub + = + fun (self: t_U16) (rhs: t_U16) -> + self +! (Core.Ops.Arith.f_neg #t_U16 #FStar.Tactics.Typeclasses.solve rhs <: t_U16) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_262: Core.Ops.Bit.t_Not t_U16 = + { + f_Output = t_U16; + f_not_pre = (fun (self: t_U16) -> true); + f_not_post = (fun (self: t_U16) (out: t_U16) -> true); + f_not = fun (self: t_U16) -> self ^. (f_MAX #FStar.Tactics.Typeclasses.solve <: t_U16) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_288: Core.Ops.Arith.t_Sub t_U8 t_U8 = + { + f_Output = t_U8; + f_sub_pre = (fun (self: t_U8) (rhs: t_U8) -> true); + f_sub_post = (fun (self: t_U8) (rhs: t_U8) (out: t_U8) -> true); + f_sub + = + fun (self: t_U8) (rhs: t_U8) -> + self +! (Core.Ops.Arith.f_neg #t_U8 #FStar.Tactics.Typeclasses.solve rhs <: t_U8) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_289: Core.Ops.Bit.t_Not t_U8 = + { + f_Output = t_U8; + f_not_pre = (fun (self: t_U8) -> true); + f_not_post = (fun (self: t_U8) (out: t_U8) -> true); + f_not = fun (self: t_U8) -> self ^. (f_MAX #FStar.Tactics.Typeclasses.solve <: t_U8) + } diff --git a/proof-libs/fstar/generated_core/Core.Clone.fst b/proof-libs/fstar/generated_core/Core.Clone.fst new file mode 100644 index 000000000..712181f8c --- /dev/null +++ b/proof-libs/fstar/generated_core/Core.Clone.fst @@ -0,0 +1,10 @@ +module Core.Clone +#set-options "--fuel 0 --ifuel 1 --z3rlimit 15" +open Core +open FStar.Mul + +class t_Clone (v_Self: Type0) = { + f_clone_pre:v_Self -> Type0; + f_clone_post:v_Self -> v_Self -> Type0; + f_clone:x0: v_Self -> Prims.Pure v_Self (f_clone_pre x0) (fun result -> f_clone_post x0 result) +} diff --git a/proof-libs/fstar/generated_core/Core.Cmp.fst b/proof-libs/fstar/generated_core/Core.Cmp.fst new file mode 100644 index 000000000..8d576fc51 --- /dev/null +++ b/proof-libs/fstar/generated_core/Core.Cmp.fst @@ -0,0 +1,135 @@ +module Core.Cmp +#set-options "--fuel 0 --ifuel 1 --z3rlimit 15" +open Core +open FStar.Mul + +let discriminant_Ordering_Equal: i8 = 0y + +let discriminant_Ordering_Greater: i8 = 1y + +type t_Ordering = + | Ordering_Less : t_Ordering + | Ordering_Equal : t_Ordering + | Ordering_Greater : t_Ordering + +let impl__Ordering__is_eq (self: t_Ordering) : bool = + match self with + | Ordering_Equal -> true + | _ -> false + +let impl__Ordering__is_gt (self: t_Ordering) : bool = + match self with + | Ordering_Greater -> true + | _ -> false + +let impl__Ordering__is_lt (self: t_Ordering) : bool = + match self with + | Ordering_Less -> true + | _ -> false + +let impl__Ordering__reverse (self: t_Ordering) : t_Ordering = + match self with + | Ordering_Less -> Ordering_Greater <: t_Ordering + | Ordering_Equal -> Ordering_Equal <: t_Ordering + | Ordering_Greater -> Ordering_Less <: t_Ordering + +let discriminant_Ordering_Less: i8 = (-1y) + +let t_Ordering_cast_to_repr (x: t_Ordering) : i8 = + match x with + | Ordering_Less -> discriminant_Ordering_Less + | Ordering_Equal -> discriminant_Ordering_Equal + | Ordering_Greater -> discriminant_Ordering_Greater + +class t_PartialEq (v_Self: Type0) (v_Rhs: Type0) = { + f_eq_pre:v_Self -> v_Rhs -> Type0; + f_eq_post:v_Self -> v_Rhs -> bool -> Type0; + f_eq:x0: v_Self -> x1: v_Rhs + -> Prims.Pure bool (f_eq_pre x0 x1) (fun result -> f_eq_post x0 x1 result); + f_ne_pre:v_Self -> v_Rhs -> Type0; + f_ne_post:v_Self -> v_Rhs -> bool -> Type0; + f_ne:x0: v_Self -> x1: v_Rhs + -> Prims.Pure bool (f_ne_pre x0 x1) (fun result -> f_ne_post x0 x1 result) +} + +let impl__Ordering__is_ge (self: t_Ordering) : bool = + ~.(match self with + | Ordering_Less -> true + | _ -> false) + +let impl__Ordering__is_le (self: t_Ordering) : bool = + ~.(match self with + | Ordering_Greater -> true + | _ -> false) + +let impl__Ordering__is_ne (self: t_Ordering) : bool = + ~.(match self with + | Ordering_Equal -> true + | _ -> false) + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_1: t_PartialEq t_Ordering t_Ordering = + { + f_eq_pre = (fun (self: t_Ordering) (other: t_Ordering) -> true); + f_eq_post = (fun (self: t_Ordering) (other: t_Ordering) (out: bool) -> true); + f_eq + = + (fun (self: t_Ordering) (other: t_Ordering) -> + match self with + | Ordering_Less -> + (match other with + | Ordering_Less -> true + | _ -> false) + | Ordering_Equal -> + (match other with + | Ordering_Equal -> true + | _ -> false) + | Ordering_Greater -> + match other with + | Ordering_Greater -> true + | _ -> false); + f_ne_pre = (fun (self: t_Ordering) (other: t_Ordering) -> true); + f_ne_post = (fun (self: t_Ordering) (other: t_Ordering) (out: bool) -> true); + f_ne + = + fun (self: t_Ordering) (other: t_Ordering) -> + ~.(match self with + | Ordering_Less -> + (match other with + | Ordering_Less -> true + | _ -> false) + | Ordering_Equal -> + (match other with + | Ordering_Equal -> true + | _ -> false) + | Ordering_Greater -> + match other with + | Ordering_Greater -> true + | _ -> false) + } + +class t_PartialOrd (v_Self: Type0) (v_Rhs: Type0) = { + [@@@ FStar.Tactics.Typeclasses.no_method]_super_9014672428308350468:t_PartialEq v_Self v_Rhs; + f_partial_cmp_pre:v_Self -> v_Rhs -> Type0; + f_partial_cmp_post:v_Self -> v_Rhs -> Core.Option.t_Option t_Ordering -> Type0; + f_partial_cmp:x0: v_Self -> x1: v_Rhs + -> Prims.Pure (Core.Option.t_Option t_Ordering) + (f_partial_cmp_pre x0 x1) + (fun result -> f_partial_cmp_post x0 x1 result); + f_lt_pre:v_Self -> v_Rhs -> Type0; + f_lt_post:v_Self -> v_Rhs -> bool -> Type0; + f_lt:x0: v_Self -> x1: v_Rhs + -> Prims.Pure bool (f_lt_pre x0 x1) (fun result -> f_lt_post x0 x1 result); + f_le_pre:v_Self -> v_Rhs -> Type0; + f_le_post:v_Self -> v_Rhs -> bool -> Type0; + f_le:x0: v_Self -> x1: v_Rhs + -> Prims.Pure bool (f_le_pre x0 x1) (fun result -> f_le_post x0 x1 result); + f_gt_pre:v_Self -> v_Rhs -> Type0; + f_gt_post:v_Self -> v_Rhs -> bool -> Type0; + f_gt:x0: v_Self -> x1: v_Rhs + -> Prims.Pure bool (f_gt_pre x0 x1) (fun result -> f_gt_post x0 x1 result); + f_ge_pre:v_Self -> v_Rhs -> Type0; + f_ge_post:v_Self -> v_Rhs -> bool -> Type0; + f_ge:x0: v_Self -> x1: v_Rhs + -> Prims.Pure bool (f_ge_pre x0 x1) (fun result -> f_ge_post x0 x1 result) +} diff --git a/proof-libs/fstar/generated_core/Core.Convert.fst b/proof-libs/fstar/generated_core/Core.Convert.fst new file mode 100644 index 000000000..1262e975d --- /dev/null +++ b/proof-libs/fstar/generated_core/Core.Convert.fst @@ -0,0 +1,33 @@ +module Core.Convert +#set-options "--fuel 0 --ifuel 1 --z3rlimit 15" +open Core +open FStar.Mul + +class t_From (v_Self: Type0) (v_T: Type0) = { + f_from_pre:v_T -> Type0; + f_from_post:v_T -> v_Self -> Type0; + f_from:x0: v_T -> Prims.Pure v_Self (f_from_pre x0) (fun result -> f_from_post x0 result) +} + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_1 (#v_T: Type0) : t_From v_T v_T = + { + f_from_pre = (fun (t: v_T) -> true); + f_from_post = (fun (t: v_T) (out: v_T) -> true); + f_from = fun (t: v_T) -> t + } + +class t_Into (v_Self: Type0) (v_T: Type0) = { + f_into_pre:v_Self -> Type0; + f_into_post:v_Self -> v_T -> Type0; + f_into:x0: v_Self -> Prims.Pure v_T (f_into_pre x0) (fun result -> f_into_post x0 result) +} + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl (#v_T #v_U: Type0) (#[FStar.Tactics.Typeclasses.tcresolve ()] i2: t_From v_U v_T) + : t_Into v_T v_U = + { + f_into_pre = (fun (self: v_T) -> true); + f_into_post = (fun (self: v_T) (out: v_U) -> true); + f_into = fun (self: v_T) -> f_from #v_U #v_T #FStar.Tactics.Typeclasses.solve self + } diff --git a/proof-libs/fstar/generated_core/Core.Intrinsics.Rec_bundle_253787241.fst b/proof-libs/fstar/generated_core/Core.Intrinsics.Rec_bundle_253787241.fst new file mode 100644 index 000000000..edef9409c --- /dev/null +++ b/proof-libs/fstar/generated_core/Core.Intrinsics.Rec_bundle_253787241.fst @@ -0,0 +1,5865 @@ +module Core.Intrinsics.Rec_bundle_253787241 +#set-options "--fuel 0 --ifuel 1 --z3rlimit 15" +open Core +open FStar.Mul + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_31: Core.Convert.t_From Core.Primitive.t_isize Core.Primitive.t_i64 = + { + f_from_pre = (fun (x: Core.Primitive.t_i64) -> true); + f_from_post = (fun (x: Core.Primitive.t_i64) (out: Core.Primitive.t_isize) -> true); + f_from + = + fun (x: Core.Primitive.t_i64) -> + Core.Primitive.C_isize + (Core.Convert.f_into #Core.Base_interface.Int.t_I64 + #Core.Base_interface.Int.t_I64 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_isize + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_40: Core.Convert.t_From Core.Primitive.t_i64 Core.Primitive.t_isize = + { + f_from_pre = (fun (x: Core.Primitive.t_isize) -> true); + f_from_post = (fun (x: Core.Primitive.t_isize) (out: Core.Primitive.t_i64) -> true); + f_from + = + fun (x: Core.Primitive.t_isize) -> + Core.Primitive.C_i64 + (Core.Convert.f_into #Core.Base_interface.Int.t_I64 + #Core.Base_interface.Int.t_I64 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_i64 + } + +let from_le715594649 (x: Core.Primitive.t_u128) : Core.Primitive.t_u128 = x + +let to_le902648378 (self: Core.Primitive.t_u128) : Core.Primitive.t_u128 = self + +let from_le793045973 (x: Core.Primitive.t_u16) : Core.Primitive.t_u16 = x + +let to_le1012469456 (self: Core.Primitive.t_u16) : Core.Primitive.t_u16 = self + +let from_le706338679 (x: Core.Primitive.t_u32) : Core.Primitive.t_u32 = x + +let to_le724624277 (self: Core.Primitive.t_u32) : Core.Primitive.t_u32 = self + +let from_le435089922 (x: Core.Primitive.t_u64) : Core.Primitive.t_u64 = x + +let to_le2703875 (self: Core.Primitive.t_u64) : Core.Primitive.t_u64 = self + +let from_le529489651 (x: Core.Primitive.t_u8) : Core.Primitive.t_u8 = x + +let to_le523556665 (self: Core.Primitive.t_u8) : Core.Primitive.t_u8 = self + +let from_le418743864 (x: Core.Primitive.t_usize) : Core.Primitive.t_usize = x + +let to_le946822077 (self: Core.Primitive.t_usize) : Core.Primitive.t_usize = self + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_31: Core.Convert.t_From Core.Primitive.t_usize Core.Primitive.t_u64 = + { + f_from_pre = (fun (x: Core.Primitive.t_u64) -> true); + f_from_post = (fun (x: Core.Primitive.t_u64) (out: Core.Primitive.t_usize) -> true); + f_from + = + fun (x: Core.Primitive.t_u64) -> + Core.Primitive.C_usize + (Core.Convert.f_into #Core.Base_interface.Int.t_U64 + #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_usize + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_40: Core.Convert.t_From Core.Primitive.t_u64 Core.Primitive.t_usize = + { + f_from_pre = (fun (x: Core.Primitive.t_usize) -> true); + f_from_post = (fun (x: Core.Primitive.t_usize) (out: Core.Primitive.t_u64) -> true); + f_from + = + fun (x: Core.Primitive.t_usize) -> + Core.Primitive.C_u64 + (Core.Convert.f_into #Core.Base_interface.Int.t_U64 + #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_u64 + } + +let v_BITS80497669: Core.Primitive.t_u32 = + Core.Primitive.C_u32 Core.Base_interface.Int.impl_149__BITS <: Core.Primitive.t_u32 + +let v_MAX626626007: Core.Primitive.t_i8 = + Core.Primitive.C_i8 (Core.Base_interface.Int.f_MAX #FStar.Tactics.Typeclasses.solve) + <: + Core.Primitive.t_i8 + +let v_MIN19747349: Core.Primitive.t_i8 = + Core.Primitive.C_i8 (Core.Base_interface.Int.f_MIN #FStar.Tactics.Typeclasses.solve) + <: + Core.Primitive.t_i8 + +let v_BITS421056295: Core.Primitive.t_u32 = + Core.Primitive.C_u32 Core.Base_interface.Int.impl_122__BITS <: Core.Primitive.t_u32 + +let v_MAX474501300: Core.Primitive.t_i16 = + Core.Primitive.C_i16 (Core.Base_interface.Int.f_MAX #FStar.Tactics.Typeclasses.solve) + <: + Core.Primitive.t_i16 + +let v_MIN776391606: Core.Primitive.t_i16 = + Core.Primitive.C_i16 (Core.Base_interface.Int.f_MIN #FStar.Tactics.Typeclasses.solve) + <: + Core.Primitive.t_i16 + +let v_BITS465526498: Core.Primitive.t_u32 = + Core.Primitive.C_u32 Core.Base_interface.Int.impl_95__BITS <: Core.Primitive.t_u32 + +let v_MAX106630818: Core.Primitive.t_i32 = + Core.Primitive.C_i32 (Core.Base_interface.Int.f_MAX #FStar.Tactics.Typeclasses.solve) + <: + Core.Primitive.t_i32 + +let v_MIN682967538: Core.Primitive.t_i32 = + Core.Primitive.C_i32 (Core.Base_interface.Int.f_MIN #FStar.Tactics.Typeclasses.solve) + <: + Core.Primitive.t_i32 + +let v_BITS419886578: Core.Primitive.t_u32 = + Core.Primitive.C_u32 Core.Base_interface.Int.impl_68__BITS <: Core.Primitive.t_u32 + +let v_MAX527043787: Core.Primitive.t_i64 = + Core.Primitive.C_i64 (Core.Base_interface.Int.f_MAX #FStar.Tactics.Typeclasses.solve) + <: + Core.Primitive.t_i64 + +let v_MIN654206259: Core.Primitive.t_i64 = + Core.Primitive.C_i64 (Core.Base_interface.Int.f_MIN #FStar.Tactics.Typeclasses.solve) + <: + Core.Primitive.t_i64 + +let v_BITS992667165: Core.Primitive.t_u32 = + Core.Primitive.C_u32 Core.Base_interface.Int.impl_41__BITS <: Core.Primitive.t_u32 + +let v_MAX375377319: Core.Primitive.t_i128 = + Core.Primitive.C_i128 (Core.Base_interface.Int.f_MAX #FStar.Tactics.Typeclasses.solve) + <: + Core.Primitive.t_i128 + +let v_MIN79612531: Core.Primitive.t_i128 = + Core.Primitive.C_i128 (Core.Base_interface.Int.f_MIN #FStar.Tactics.Typeclasses.solve) + <: + Core.Primitive.t_i128 + +let v_BITS211584016: Core.Primitive.t_u32 = + Core.Primitive.C_u32 Core.Base_interface.Int.impl_68__BITS <: Core.Primitive.t_u32 + +let v_MAX937003029: Core.Primitive.t_isize = + Core.Primitive.C_isize (Core.Base_interface.Int.f_MAX #FStar.Tactics.Typeclasses.solve) + <: + Core.Primitive.t_isize + +let v_MIN1017039533: Core.Primitive.t_isize = + Core.Primitive.C_isize (Core.Base_interface.Int.f_MIN #FStar.Tactics.Typeclasses.solve) + <: + Core.Primitive.t_isize + +let v_BITS690311813: Core.Primitive.t_u32 = + Core.Primitive.C_u32 Core.Base_interface.Int.impl_284__BITS <: Core.Primitive.t_u32 + +let v_MAX310118176: Core.Primitive.t_u8 = + Core.Primitive.C_u8 (Core.Base_interface.Int.f_MAX #FStar.Tactics.Typeclasses.solve) + <: + Core.Primitive.t_u8 + +let v_MIN41851434: Core.Primitive.t_u8 = + Core.Primitive.C_u8 (Core.Base_interface.Int.f_MIN #FStar.Tactics.Typeclasses.solve) + <: + Core.Primitive.t_u8 + +let v_BITS277333551: Core.Primitive.t_u32 = + Core.Primitive.C_u32 Core.Base_interface.Int.impl_257__BITS <: Core.Primitive.t_u32 + +let v_MAX487295910: Core.Primitive.t_u16 = + Core.Primitive.C_u16 (Core.Base_interface.Int.f_MAX #FStar.Tactics.Typeclasses.solve) + <: + Core.Primitive.t_u16 + +let v_MIN592300287: Core.Primitive.t_u16 = + Core.Primitive.C_u16 (Core.Base_interface.Int.f_MIN #FStar.Tactics.Typeclasses.solve) + <: + Core.Primitive.t_u16 + +let v_BITS473478051: Core.Primitive.t_u32 = + Core.Primitive.C_u32 Core.Base_interface.Int.impl_230__BITS <: Core.Primitive.t_u32 + +let v_MAX826434525: Core.Primitive.t_u32 = + Core.Primitive.C_u32 (Core.Base_interface.Int.f_MAX #FStar.Tactics.Typeclasses.solve) + <: + Core.Primitive.t_u32 + +let v_MIN932777089: Core.Primitive.t_u32 = + Core.Primitive.C_u32 (Core.Base_interface.Int.f_MIN #FStar.Tactics.Typeclasses.solve) + <: + Core.Primitive.t_u32 + +let v_BITS177666292: Core.Primitive.t_u32 = + Core.Primitive.C_u32 Core.Base_interface.Int.impl_203__BITS <: Core.Primitive.t_u32 + +let v_MAX815180633: Core.Primitive.t_u64 = + Core.Primitive.C_u64 (Core.Base_interface.Int.f_MAX #FStar.Tactics.Typeclasses.solve) + <: + Core.Primitive.t_u64 + +let v_MIN631333594: Core.Primitive.t_u64 = + Core.Primitive.C_u64 (Core.Base_interface.Int.f_MIN #FStar.Tactics.Typeclasses.solve) + <: + Core.Primitive.t_u64 + +let v_BITS136999051: Core.Primitive.t_u32 = + Core.Primitive.C_u32 Core.Base_interface.Int.impl_176__BITS <: Core.Primitive.t_u32 + +let v_MAX404543799: Core.Primitive.t_u128 = + Core.Primitive.C_u128 (Core.Base_interface.Int.f_MAX #FStar.Tactics.Typeclasses.solve) + <: + Core.Primitive.t_u128 + +let v_MIN668621698: Core.Primitive.t_u128 = + Core.Primitive.C_u128 (Core.Base_interface.Int.f_MIN #FStar.Tactics.Typeclasses.solve) + <: + Core.Primitive.t_u128 + +let v_BITS229952196: Core.Primitive.t_u32 = + Core.Primitive.C_u32 Core.Base_interface.Int.impl_203__BITS <: Core.Primitive.t_u32 + +let v_MAX750570916: Core.Primitive.t_usize = + Core.Primitive.C_usize (Core.Base_interface.Int.f_MAX #FStar.Tactics.Typeclasses.solve) + <: + Core.Primitive.t_usize + +let v_MIN861571008: Core.Primitive.t_usize = + Core.Primitive.C_usize (Core.Base_interface.Int.f_MIN #FStar.Tactics.Typeclasses.solve) + <: + Core.Primitive.t_usize + +let rec from_u128_binary (x: u128) + : Prims.Pure Core.Base.Spec.Binary.Positive.t_Positive + (requires Rust_primitives.U128.ne x (pub_u128 0)) + (fun _ -> Prims.l_True) = + if Rust_primitives.U128.eq x (pub_u128 1) + then Core.Base.Spec.Binary.Positive.xH + else + if Rust_primitives.U128.eq (Rust_primitives.U128.rem x (pub_u128 2) <: u128) (pub_u128 0) + then + Core.Base.Spec.Binary.Positive.xO (from_u128_binary (Rust_primitives.U128.div x (pub_u128 2) + <: + u128) + <: + Core.Base.Spec.Binary.Positive.t_Positive) + else + Core.Base.Spec.Binary.Positive.xI (from_u128_binary (Rust_primitives.U128.div x (pub_u128 2) + <: + u128) + <: + Core.Base.Spec.Binary.Positive.t_Positive) + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_8: Core.Convert.t_From Core.Base.Spec.Haxint.t_HaxInt u128 = + { + f_from_pre = (fun (x: u128) -> true); + f_from_post = (fun (x: u128) (out: Core.Base.Spec.Haxint.t_HaxInt) -> true); + f_from + = + fun (x: u128) -> + if Rust_primitives.U128.eq x (pub_u128 0) + then Core.Base.Spec.Haxint.v_HaxInt_ZERO + else + Core.Base.Spec.Binary.Positive.positive_to_int (from_u128_binary x + <: + Core.Base.Spec.Binary.Positive.t_Positive) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_20: Core.Convert.t_From Core.Base.Spec.Z.t_Z i128 = + { + f_from_pre = (fun (x: i128) -> true); + f_from_post = (fun (x: i128) (out: Core.Base.Spec.Z.t_Z) -> true); + f_from + = + fun (x: i128) -> + match Core.Cmp.f_cmp #i128 #FStar.Tactics.Typeclasses.solve x (pub_i128 0) with + | Core.Cmp.Ordering_Equal -> Core.Base.Spec.Z.Z_ZERO <: Core.Base.Spec.Z.t_Z + | Core.Cmp.Ordering_Less -> + Core.Base.Spec.Z.Z_NEG (from_u128_binary (Core.Num.impl__i128__unsigned_abs x <: u128)) + <: + Core.Base.Spec.Z.t_Z + | Core.Cmp.Ordering_Greater -> + Core.Base.Spec.Z.Z_POS (from_u128_binary (Core.Num.impl__i128__unsigned_abs x <: u128)) + <: + Core.Base.Spec.Z.t_Z + } + +let rec from_u16_binary (x: u16) + : Prims.Pure Core.Base.Spec.Binary.Positive.t_Positive + (requires Rust_primitives.U16.ne x 0us) + (fun _ -> Prims.l_True) = + if Rust_primitives.U16.eq x 1us + then Core.Base.Spec.Binary.Positive.xH + else + if Rust_primitives.U16.eq (Rust_primitives.U16.rem x 2us <: u16) 0us + then + Core.Base.Spec.Binary.Positive.xO (from_u16_binary (Rust_primitives.U16.div x 2us <: u16) + <: + Core.Base.Spec.Binary.Positive.t_Positive) + else + Core.Base.Spec.Binary.Positive.xI (from_u16_binary (Rust_primitives.U16.div x 2us <: u16) + <: + Core.Base.Spec.Binary.Positive.t_Positive) + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_2: Core.Convert.t_From Core.Base.Spec.Haxint.t_HaxInt u16 = + { + f_from_pre = (fun (x: u16) -> true); + f_from_post = (fun (x: u16) (out: Core.Base.Spec.Haxint.t_HaxInt) -> true); + f_from + = + fun (x: u16) -> + if Rust_primitives.U16.eq x 0us + then Core.Base.Spec.Haxint.v_HaxInt_ZERO + else + Core.Base.Spec.Binary.Positive.positive_to_int (from_u16_binary x + <: + Core.Base.Spec.Binary.Positive.t_Positive) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_14: Core.Convert.t_From Core.Base.Spec.Z.t_Z i16 = + { + f_from_pre = (fun (x: i16) -> true); + f_from_post = (fun (x: i16) (out: Core.Base.Spec.Z.t_Z) -> true); + f_from + = + fun (x: i16) -> + match Core.Cmp.f_cmp #i16 #FStar.Tactics.Typeclasses.solve x 0s with + | Core.Cmp.Ordering_Equal -> Core.Base.Spec.Z.Z_ZERO <: Core.Base.Spec.Z.t_Z + | Core.Cmp.Ordering_Less -> + Core.Base.Spec.Z.Z_NEG (from_u16_binary (Core.Num.impl_1__unsigned_abs x <: u16)) + <: + Core.Base.Spec.Z.t_Z + | Core.Cmp.Ordering_Greater -> + Core.Base.Spec.Z.Z_POS (from_u16_binary (Core.Num.impl_1__unsigned_abs x <: u16)) + <: + Core.Base.Spec.Z.t_Z + } + +let rec from_u32_binary (x: u32) + : Prims.Pure Core.Base.Spec.Binary.Positive.t_Positive + (requires Rust_primitives.U32.ne x 0ul) + (fun _ -> Prims.l_True) = + if Rust_primitives.U32.eq x 1ul + then Core.Base.Spec.Binary.Positive.xH + else + if Rust_primitives.U32.eq (Rust_primitives.U32.rem x 2ul <: u32) 0ul + then + Core.Base.Spec.Binary.Positive.xO (from_u32_binary (Rust_primitives.U32.div x 2ul <: u32) + <: + Core.Base.Spec.Binary.Positive.t_Positive) + else + Core.Base.Spec.Binary.Positive.xI (from_u32_binary (Rust_primitives.U32.div x 2ul <: u32) + <: + Core.Base.Spec.Binary.Positive.t_Positive) + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_4: Core.Convert.t_From Core.Base.Spec.Haxint.t_HaxInt u32 = + { + f_from_pre = (fun (x: u32) -> true); + f_from_post = (fun (x: u32) (out: Core.Base.Spec.Haxint.t_HaxInt) -> true); + f_from + = + fun (x: u32) -> + if Rust_primitives.U32.eq x 0ul + then Core.Base.Spec.Haxint.v_HaxInt_ZERO + else + Core.Base.Spec.Binary.Positive.positive_to_int (from_u32_binary x + <: + Core.Base.Spec.Binary.Positive.t_Positive) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_16: Core.Convert.t_From Core.Base.Spec.Z.t_Z i32 = + { + f_from_pre = (fun (x: i32) -> true); + f_from_post = (fun (x: i32) (out: Core.Base.Spec.Z.t_Z) -> true); + f_from + = + fun (x: i32) -> + match Core.Cmp.f_cmp #i32 #FStar.Tactics.Typeclasses.solve x 0l with + | Core.Cmp.Ordering_Equal -> Core.Base.Spec.Z.Z_ZERO <: Core.Base.Spec.Z.t_Z + | Core.Cmp.Ordering_Less -> + Core.Base.Spec.Z.Z_NEG (from_u32_binary (Core.Num.impl__i32__unsigned_abs x <: u32)) + <: + Core.Base.Spec.Z.t_Z + | Core.Cmp.Ordering_Greater -> + Core.Base.Spec.Z.Z_POS (from_u32_binary (Core.Num.impl__i32__unsigned_abs x <: u32)) + <: + Core.Base.Spec.Z.t_Z + } + +let rec from_u64_binary (x: u64) + : Prims.Pure Core.Base.Spec.Binary.Positive.t_Positive + (requires Rust_primitives.U64.ne x 0uL) + (fun _ -> Prims.l_True) = + if Rust_primitives.U64.eq x 1uL + then Core.Base.Spec.Binary.Positive.xH + else + if Rust_primitives.U64.eq (Rust_primitives.U64.rem x 2uL <: u64) 0uL + then + Core.Base.Spec.Binary.Positive.xO (from_u64_binary (Rust_primitives.U64.div x 2uL <: u64) + <: + Core.Base.Spec.Binary.Positive.t_Positive) + else + Core.Base.Spec.Binary.Positive.xI (from_u64_binary (Rust_primitives.U64.div x 2uL <: u64) + <: + Core.Base.Spec.Binary.Positive.t_Positive) + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_6: Core.Convert.t_From Core.Base.Spec.Haxint.t_HaxInt u64 = + { + f_from_pre = (fun (x: u64) -> true); + f_from_post = (fun (x: u64) (out: Core.Base.Spec.Haxint.t_HaxInt) -> true); + f_from + = + fun (x: u64) -> + if Rust_primitives.U64.eq x 0uL + then Core.Base.Spec.Haxint.v_HaxInt_ZERO + else + Core.Base.Spec.Binary.Positive.positive_to_int (from_u64_binary x + <: + Core.Base.Spec.Binary.Positive.t_Positive) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_18: Core.Convert.t_From Core.Base.Spec.Z.t_Z i64 = + { + f_from_pre = (fun (x: i64) -> true); + f_from_post = (fun (x: i64) (out: Core.Base.Spec.Z.t_Z) -> true); + f_from + = + fun (x: i64) -> + match Core.Cmp.f_cmp #i64 #FStar.Tactics.Typeclasses.solve x 0L with + | Core.Cmp.Ordering_Equal -> Core.Base.Spec.Z.Z_ZERO <: Core.Base.Spec.Z.t_Z + | Core.Cmp.Ordering_Less -> + Core.Base.Spec.Z.Z_NEG (from_u64_binary (Core.Num.impl__i64__unsigned_abs x <: u64)) + <: + Core.Base.Spec.Z.t_Z + | Core.Cmp.Ordering_Greater -> + Core.Base.Spec.Z.Z_POS (from_u64_binary (Core.Num.impl__i64__unsigned_abs x <: u64)) + <: + Core.Base.Spec.Z.t_Z + } + +let rec from_u8_binary (x: u8) + : Prims.Pure Core.Base.Spec.Binary.Positive.t_Positive + (requires Rust_primitives.U8.ne x 0uy) + (fun _ -> Prims.l_True) = + if Rust_primitives.U8.eq x 1uy + then Core.Base.Spec.Binary.Positive.xH + else + if Rust_primitives.U8.eq (Rust_primitives.U8.rem x 2uy <: u8) 0uy + then + Core.Base.Spec.Binary.Positive.xO (from_u8_binary (Rust_primitives.U8.div x 2uy <: u8) + <: + Core.Base.Spec.Binary.Positive.t_Positive) + else + Core.Base.Spec.Binary.Positive.xI (from_u8_binary (Rust_primitives.U8.div x 2uy <: u8) + <: + Core.Base.Spec.Binary.Positive.t_Positive) + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl: Core.Convert.t_From Core.Base.Spec.Haxint.t_HaxInt u8 = + { + f_from_pre = (fun (x: u8) -> true); + f_from_post = (fun (x: u8) (out: Core.Base.Spec.Haxint.t_HaxInt) -> true); + f_from + = + fun (x: u8) -> + if Rust_primitives.U8.eq x 0uy + then Core.Base.Spec.Haxint.v_HaxInt_ZERO + else + Core.Base.Spec.Binary.Positive.positive_to_int (from_u8_binary x + <: + Core.Base.Spec.Binary.Positive.t_Positive) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_12: Core.Convert.t_From Core.Base.Spec.Z.t_Z i8 = + { + f_from_pre = (fun (x: i8) -> true); + f_from_post = (fun (x: i8) (out: Core.Base.Spec.Z.t_Z) -> true); + f_from + = + fun (x: i8) -> + match Core.Cmp.f_cmp #i8 #FStar.Tactics.Typeclasses.solve x 0y with + | Core.Cmp.Ordering_Equal -> Core.Base.Spec.Z.Z_ZERO <: Core.Base.Spec.Z.t_Z + | Core.Cmp.Ordering_Less -> + Core.Base.Spec.Z.Z_NEG (from_u8_binary (Core.Num.impl__unsigned_abs x <: u8)) + <: + Core.Base.Spec.Z.t_Z + | Core.Cmp.Ordering_Greater -> + Core.Base.Spec.Z.Z_POS (from_u8_binary (Core.Num.impl__unsigned_abs x <: u8)) + <: + Core.Base.Spec.Z.t_Z + } + +let rec from_usize_binary (x: usize) + : Prims.Pure Core.Base.Spec.Binary.Positive.t_Positive + (requires Rust_primitives.Usize.ne x (sz 0)) + (fun _ -> Prims.l_True) = + if Rust_primitives.Usize.eq x (sz 1) + then Core.Base.Spec.Binary.Positive.xH + else + if Rust_primitives.Usize.eq (Rust_primitives.Usize.rem x (sz 2) <: usize) (sz 0) + then + Core.Base.Spec.Binary.Positive.xO (from_usize_binary (Rust_primitives.Usize.div x (sz 2) + <: + usize) + <: + Core.Base.Spec.Binary.Positive.t_Positive) + else + Core.Base.Spec.Binary.Positive.xI (from_usize_binary (Rust_primitives.Usize.div x (sz 2) + <: + usize) + <: + Core.Base.Spec.Binary.Positive.t_Positive) + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_10: Core.Convert.t_From Core.Base.Spec.Haxint.t_HaxInt usize = + { + f_from_pre = (fun (x: usize) -> true); + f_from_post = (fun (x: usize) (out: Core.Base.Spec.Haxint.t_HaxInt) -> true); + f_from + = + fun (x: usize) -> + if Rust_primitives.Usize.eq x (sz 0) + then Core.Base.Spec.Haxint.v_HaxInt_ZERO + else + Core.Base.Spec.Binary.Positive.positive_to_int (from_usize_binary x + <: + Core.Base.Spec.Binary.Positive.t_Positive) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_22: Core.Convert.t_From Core.Base.Spec.Z.t_Z isize = + { + f_from_pre = (fun (x: isize) -> true); + f_from_post = (fun (x: isize) (out: Core.Base.Spec.Z.t_Z) -> true); + f_from + = + fun (x: isize) -> + match Core.Cmp.f_cmp #isize #FStar.Tactics.Typeclasses.solve x (isz 0) with + | Core.Cmp.Ordering_Equal -> Core.Base.Spec.Z.Z_ZERO <: Core.Base.Spec.Z.t_Z + | Core.Cmp.Ordering_Less -> + Core.Base.Spec.Z.Z_NEG (from_usize_binary (Core.Num.impl__isize__unsigned_abs x <: usize)) + <: + Core.Base.Spec.Z.t_Z + | Core.Cmp.Ordering_Greater -> + Core.Base.Spec.Z.Z_POS (from_usize_binary (Core.Num.impl__isize__unsigned_abs x <: usize)) + <: + Core.Base.Spec.Z.t_Z + } + +let rec to_u128_binary (self: Core.Base.Spec.Binary.Positive.t_Positive) : u128 = + match Core.Base.Spec.Binary.Positive.match_positive self with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> pub_u128 1 + | Core.Base.Spec.Binary.Positive.POSITIVE_XO p -> + Rust_primitives.U128.mul (to_u128_binary p <: u128) (pub_u128 2) + | Core.Base.Spec.Binary.Positive.POSITIVE_XI p -> + Rust_primitives.U128.add (Rust_primitives.U128.mul (to_u128_binary p <: u128) (pub_u128 2) + <: + u128) + (pub_u128 1) + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_9: Core.Convert.t_From u128 Core.Base.Spec.Haxint.t_HaxInt = + { + f_from_pre = (fun (x: Core.Base.Spec.Haxint.t_HaxInt) -> true); + f_from_post = (fun (x: Core.Base.Spec.Haxint.t_HaxInt) (out: u128) -> true); + f_from + = + fun (x: Core.Base.Spec.Haxint.t_HaxInt) -> + match Core.Base.Spec.Binary.Pos.match_pos x with + | Core.Base.Spec.Binary.Pos.POS_ZERO -> pub_u128 0 + | Core.Base.Spec.Binary.Pos.POS_POS p -> to_u128_binary p + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_21: Core.Convert.t_From i128 Core.Base.Spec.Z.t_Z = + { + f_from_pre = (fun (x: Core.Base.Spec.Z.t_Z) -> true); + f_from_post = (fun (x: Core.Base.Spec.Z.t_Z) (out: i128) -> true); + f_from + = + fun (x: Core.Base.Spec.Z.t_Z) -> + match x with + | Core.Base.Spec.Z.Z_NEG x -> + Rust_primitives.I128.sub (Core.Ops.Arith.Neg.neg (cast (Rust_primitives.U128.sub (to_u128_binary + x + <: + u128) + (pub_u128 1) + <: + u128) + <: + i128) + <: + i128) + (pub_i128 1) + | Core.Base.Spec.Z.Z_ZERO -> pub_i128 0 + | Core.Base.Spec.Z.Z_POS x -> cast (to_u128_binary x <: u128) <: i128 + } + +let rec to_u16_binary (self: Core.Base.Spec.Binary.Positive.t_Positive) : u16 = + match Core.Base.Spec.Binary.Positive.match_positive self with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> 1us + | Core.Base.Spec.Binary.Positive.POSITIVE_XO p -> + Rust_primitives.U16.mul (to_u16_binary p <: u16) 2us + | Core.Base.Spec.Binary.Positive.POSITIVE_XI p -> + Rust_primitives.U16.add (Rust_primitives.U16.mul (to_u16_binary p <: u16) 2us <: u16) 1us + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_3: Core.Convert.t_From u16 Core.Base.Spec.Haxint.t_HaxInt = + { + f_from_pre = (fun (x: Core.Base.Spec.Haxint.t_HaxInt) -> true); + f_from_post = (fun (x: Core.Base.Spec.Haxint.t_HaxInt) (out: u16) -> true); + f_from + = + fun (x: Core.Base.Spec.Haxint.t_HaxInt) -> + match Core.Base.Spec.Binary.Pos.match_pos x with + | Core.Base.Spec.Binary.Pos.POS_ZERO -> 0us + | Core.Base.Spec.Binary.Pos.POS_POS p -> to_u16_binary p + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_15: Core.Convert.t_From i16 Core.Base.Spec.Z.t_Z = + { + f_from_pre = (fun (x: Core.Base.Spec.Z.t_Z) -> true); + f_from_post = (fun (x: Core.Base.Spec.Z.t_Z) (out: i16) -> true); + f_from + = + fun (x: Core.Base.Spec.Z.t_Z) -> + match x with + | Core.Base.Spec.Z.Z_NEG x -> + Rust_primitives.I16.sub (Core.Ops.Arith.Neg.neg (cast (Rust_primitives.U16.sub (to_u16_binary + x + <: + u16) + 1us + <: + u16) + <: + i16) + <: + i16) + 1s + | Core.Base.Spec.Z.Z_ZERO -> 0s + | Core.Base.Spec.Z.Z_POS x -> cast (to_u16_binary x <: u16) <: i16 + } + +let rec to_u32_binary (self: Core.Base.Spec.Binary.Positive.t_Positive) : u32 = + match Core.Base.Spec.Binary.Positive.match_positive self with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> 1ul + | Core.Base.Spec.Binary.Positive.POSITIVE_XO p -> + Rust_primitives.U32.mul (to_u32_binary p <: u32) 2ul + | Core.Base.Spec.Binary.Positive.POSITIVE_XI p -> + Rust_primitives.U32.add (Rust_primitives.U32.mul (to_u32_binary p <: u32) 2ul <: u32) 1ul + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_5: Core.Convert.t_From u32 Core.Base.Spec.Haxint.t_HaxInt = + { + f_from_pre = (fun (x: Core.Base.Spec.Haxint.t_HaxInt) -> true); + f_from_post = (fun (x: Core.Base.Spec.Haxint.t_HaxInt) (out: u32) -> true); + f_from + = + fun (x: Core.Base.Spec.Haxint.t_HaxInt) -> + match Core.Base.Spec.Binary.Pos.match_pos x with + | Core.Base.Spec.Binary.Pos.POS_ZERO -> 0ul + | Core.Base.Spec.Binary.Pos.POS_POS p -> to_u32_binary p + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_17: Core.Convert.t_From i32 Core.Base.Spec.Z.t_Z = + { + f_from_pre = (fun (x: Core.Base.Spec.Z.t_Z) -> true); + f_from_post = (fun (x: Core.Base.Spec.Z.t_Z) (out: i32) -> true); + f_from + = + fun (x: Core.Base.Spec.Z.t_Z) -> + match x with + | Core.Base.Spec.Z.Z_NEG x -> + Rust_primitives.I32.sub (Core.Ops.Arith.Neg.neg (cast (Rust_primitives.U32.sub (to_u32_binary + x + <: + u32) + 1ul + <: + u32) + <: + i32) + <: + i32) + 1l + | Core.Base.Spec.Z.Z_ZERO -> 0l + | Core.Base.Spec.Z.Z_POS x -> cast (to_u32_binary x <: u32) <: i32 + } + +let rec to_u64_binary (self: Core.Base.Spec.Binary.Positive.t_Positive) : u64 = + match Core.Base.Spec.Binary.Positive.match_positive self with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> 1uL + | Core.Base.Spec.Binary.Positive.POSITIVE_XO p -> + Rust_primitives.U64.mul (to_u64_binary p <: u64) 2uL + | Core.Base.Spec.Binary.Positive.POSITIVE_XI p -> + Rust_primitives.U64.add (Rust_primitives.U64.mul (to_u64_binary p <: u64) 2uL <: u64) 1uL + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_7: Core.Convert.t_From u64 Core.Base.Spec.Haxint.t_HaxInt = + { + f_from_pre = (fun (x: Core.Base.Spec.Haxint.t_HaxInt) -> true); + f_from_post = (fun (x: Core.Base.Spec.Haxint.t_HaxInt) (out: u64) -> true); + f_from + = + fun (x: Core.Base.Spec.Haxint.t_HaxInt) -> + match Core.Base.Spec.Binary.Pos.match_pos x with + | Core.Base.Spec.Binary.Pos.POS_ZERO -> 0uL + | Core.Base.Spec.Binary.Pos.POS_POS p -> to_u64_binary p + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_19: Core.Convert.t_From i64 Core.Base.Spec.Z.t_Z = + { + f_from_pre = (fun (x: Core.Base.Spec.Z.t_Z) -> true); + f_from_post = (fun (x: Core.Base.Spec.Z.t_Z) (out: i64) -> true); + f_from + = + fun (x: Core.Base.Spec.Z.t_Z) -> + match x with + | Core.Base.Spec.Z.Z_NEG x -> + Rust_primitives.I64.sub (Core.Ops.Arith.Neg.neg (cast (Rust_primitives.U64.sub (to_u64_binary + x + <: + u64) + 1uL + <: + u64) + <: + i64) + <: + i64) + 1L + | Core.Base.Spec.Z.Z_ZERO -> 0L + | Core.Base.Spec.Z.Z_POS x -> cast (to_u64_binary x <: u64) <: i64 + } + +let rec to_u8_binary (self: Core.Base.Spec.Binary.Positive.t_Positive) : u8 = + match Core.Base.Spec.Binary.Positive.match_positive self with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> 1uy + | Core.Base.Spec.Binary.Positive.POSITIVE_XO p -> + Rust_primitives.U8.mul (to_u8_binary p <: u8) 2uy + | Core.Base.Spec.Binary.Positive.POSITIVE_XI p -> + Rust_primitives.U8.add (Rust_primitives.U8.mul (to_u8_binary p <: u8) 2uy <: u8) 1uy + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_1: Core.Convert.t_From u8 Core.Base.Spec.Haxint.t_HaxInt = + { + f_from_pre = (fun (x: Core.Base.Spec.Haxint.t_HaxInt) -> true); + f_from_post = (fun (x: Core.Base.Spec.Haxint.t_HaxInt) (out: u8) -> true); + f_from + = + fun (x: Core.Base.Spec.Haxint.t_HaxInt) -> + match Core.Base.Spec.Binary.Pos.match_pos x with + | Core.Base.Spec.Binary.Pos.POS_ZERO -> 0uy + | Core.Base.Spec.Binary.Pos.POS_POS p -> to_u8_binary p + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_13: Core.Convert.t_From i8 Core.Base.Spec.Z.t_Z = + { + f_from_pre = (fun (x: Core.Base.Spec.Z.t_Z) -> true); + f_from_post = (fun (x: Core.Base.Spec.Z.t_Z) (out: i8) -> true); + f_from + = + fun (x: Core.Base.Spec.Z.t_Z) -> + match x with + | Core.Base.Spec.Z.Z_NEG x -> + Rust_primitives.I8.sub (Core.Ops.Arith.Neg.neg (cast (Rust_primitives.U8.sub (to_u8_binary x + <: + u8) + 1uy + <: + u8) + <: + i8) + <: + i8) + 1y + | Core.Base.Spec.Z.Z_ZERO -> 0y + | Core.Base.Spec.Z.Z_POS x -> cast (to_u8_binary x <: u8) <: i8 + } + +let rec to_usize_binary (self: Core.Base.Spec.Binary.Positive.t_Positive) : usize = + match Core.Base.Spec.Binary.Positive.match_positive self with + | Core.Base.Spec.Binary.Positive.POSITIVE_XH -> sz 1 + | Core.Base.Spec.Binary.Positive.POSITIVE_XO p -> + Rust_primitives.Usize.mul (to_usize_binary p <: usize) (sz 2) + | Core.Base.Spec.Binary.Positive.POSITIVE_XI p -> + Rust_primitives.Usize.add (Rust_primitives.Usize.mul (to_usize_binary p <: usize) (sz 2) + <: + usize) + (sz 1) + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_11: Core.Convert.t_From usize Core.Base.Spec.Haxint.t_HaxInt = + { + f_from_pre = (fun (x: Core.Base.Spec.Haxint.t_HaxInt) -> true); + f_from_post = (fun (x: Core.Base.Spec.Haxint.t_HaxInt) (out: usize) -> true); + f_from + = + fun (x: Core.Base.Spec.Haxint.t_HaxInt) -> + match Core.Base.Spec.Binary.Pos.match_pos x with + | Core.Base.Spec.Binary.Pos.POS_ZERO -> sz 0 + | Core.Base.Spec.Binary.Pos.POS_POS p -> to_usize_binary p + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_23: Core.Convert.t_From isize Core.Base.Spec.Z.t_Z = + { + f_from_pre = (fun (x: Core.Base.Spec.Z.t_Z) -> true); + f_from_post = (fun (x: Core.Base.Spec.Z.t_Z) (out: isize) -> true); + f_from + = + fun (x: Core.Base.Spec.Z.t_Z) -> + match x with + | Core.Base.Spec.Z.Z_NEG x -> + Rust_primitives.Isize.sub (Core.Ops.Arith.Neg.neg (cast (Rust_primitives.Usize.sub (to_usize_binary + x + <: + usize) + (sz 1) + <: + usize) + <: + isize) + <: + isize) + (isz 1) + | Core.Base.Spec.Z.Z_ZERO -> isz 0 + | Core.Base.Spec.Z.Z_POS x -> cast (to_usize_binary x <: usize) <: isize + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl: Core.Convert.t_From Core.Primitive.t_u8 u8 = + { + f_from_pre = (fun (x: u8) -> true); + f_from_post = (fun (x: u8) (out: Core.Primitive.t_u8) -> true); + f_from + = + fun (x: u8) -> + Core.Primitive.C_u8 + ({ + Core.Base_interface.Int.f_v + = + Core.Convert.f_into #u8 #Core.Base.Spec.Haxint.t_HaxInt #FStar.Tactics.Typeclasses.solve x + } + <: + Core.Base_interface.Int.t_U8) + <: + Core.Primitive.t_u8 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_1: Core.Convert.t_From u8 Core.Primitive.t_u8 = + { + f_from_pre = (fun (x: Core.Primitive.t_u8) -> true); + f_from_post = (fun (x: Core.Primitive.t_u8) (out: u8) -> true); + f_from + = + fun (x: Core.Primitive.t_u8) -> + Core.Convert.f_into #Core.Base.Spec.Haxint.t_HaxInt + #u8 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0.Core.Base_interface.Int.f_v + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_2: Core.Convert.t_From Core.Primitive.t_u16 u16 = + { + f_from_pre = (fun (x: u16) -> true); + f_from_post = (fun (x: u16) (out: Core.Primitive.t_u16) -> true); + f_from + = + fun (x: u16) -> + Core.Primitive.C_u16 + ({ + Core.Base_interface.Int.f_v + = + Core.Convert.f_into #u16 + #Core.Base.Spec.Haxint.t_HaxInt + #FStar.Tactics.Typeclasses.solve + x + } + <: + Core.Base_interface.Int.t_U16) + <: + Core.Primitive.t_u16 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_3: Core.Convert.t_From u16 Core.Primitive.t_u16 = + { + f_from_pre = (fun (x: Core.Primitive.t_u16) -> true); + f_from_post = (fun (x: Core.Primitive.t_u16) (out: u16) -> true); + f_from + = + fun (x: Core.Primitive.t_u16) -> + Core.Convert.f_into #Core.Base.Spec.Haxint.t_HaxInt + #u16 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0.Core.Base_interface.Int.f_v + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_4: Core.Convert.t_From Core.Primitive.t_u32 u32 = + { + f_from_pre = (fun (x: u32) -> true); + f_from_post = (fun (x: u32) (out: Core.Primitive.t_u32) -> true); + f_from + = + fun (x: u32) -> + Core.Primitive.C_u32 + ({ + Core.Base_interface.Int.f_v + = + Core.Convert.f_into #u32 + #Core.Base.Spec.Haxint.t_HaxInt + #FStar.Tactics.Typeclasses.solve + x + } + <: + Core.Base_interface.Int.t_U32) + <: + Core.Primitive.t_u32 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_5: Core.Convert.t_From u32 Core.Primitive.t_u32 = + { + f_from_pre = (fun (x: Core.Primitive.t_u32) -> true); + f_from_post = (fun (x: Core.Primitive.t_u32) (out: u32) -> true); + f_from + = + fun (x: Core.Primitive.t_u32) -> + Core.Convert.f_into #Core.Base.Spec.Haxint.t_HaxInt + #u32 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0.Core.Base_interface.Int.f_v + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_6: Core.Convert.t_From Core.Primitive.t_u64 u64 = + { + f_from_pre = (fun (x: u64) -> true); + f_from_post = (fun (x: u64) (out: Core.Primitive.t_u64) -> true); + f_from + = + fun (x: u64) -> + Core.Primitive.C_u64 + ({ + Core.Base_interface.Int.f_v + = + Core.Convert.f_into #u64 + #Core.Base.Spec.Haxint.t_HaxInt + #FStar.Tactics.Typeclasses.solve + x + } + <: + Core.Base_interface.Int.t_U64) + <: + Core.Primitive.t_u64 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_7: Core.Convert.t_From u64 Core.Primitive.t_u64 = + { + f_from_pre = (fun (x: Core.Primitive.t_u64) -> true); + f_from_post = (fun (x: Core.Primitive.t_u64) (out: u64) -> true); + f_from + = + fun (x: Core.Primitive.t_u64) -> + Core.Convert.f_into #Core.Base.Spec.Haxint.t_HaxInt + #u64 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0.Core.Base_interface.Int.f_v + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_8: Core.Convert.t_From Core.Primitive.t_u128 u128 = + { + f_from_pre = (fun (x: u128) -> true); + f_from_post = (fun (x: u128) (out: Core.Primitive.t_u128) -> true); + f_from + = + fun (x: u128) -> + Core.Primitive.C_u128 + ({ + Core.Base_interface.Int.f_v + = + Core.Convert.f_into #u128 + #Core.Base.Spec.Haxint.t_HaxInt + #FStar.Tactics.Typeclasses.solve + x + } + <: + Core.Base_interface.Int.t_U128) + <: + Core.Primitive.t_u128 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_9: Core.Convert.t_From u128 Core.Primitive.t_u128 = + { + f_from_pre = (fun (x: Core.Primitive.t_u128) -> true); + f_from_post = (fun (x: Core.Primitive.t_u128) (out: u128) -> true); + f_from + = + fun (x: Core.Primitive.t_u128) -> + Core.Convert.f_into #Core.Base.Spec.Haxint.t_HaxInt + #u128 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0.Core.Base_interface.Int.f_v + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_10: Core.Convert.t_From Core.Primitive.t_usize usize = + { + f_from_pre = (fun (x: usize) -> true); + f_from_post = (fun (x: usize) (out: Core.Primitive.t_usize) -> true); + f_from + = + fun (x: usize) -> + Core.Primitive.C_usize + ({ + Core.Base_interface.Int.f_v + = + Core.Convert.f_into #usize + #Core.Base.Spec.Haxint.t_HaxInt + #FStar.Tactics.Typeclasses.solve + x + } + <: + Core.Base_interface.Int.t_U64) + <: + Core.Primitive.t_usize + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_11: Core.Convert.t_From usize Core.Primitive.t_usize = + { + f_from_pre = (fun (x: Core.Primitive.t_usize) -> true); + f_from_post = (fun (x: Core.Primitive.t_usize) (out: usize) -> true); + f_from + = + fun (x: Core.Primitive.t_usize) -> + Core.Convert.f_into #Core.Base.Spec.Haxint.t_HaxInt + #usize + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0.Core.Base_interface.Int.f_v + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl: Core.Convert.t_From Core.Primitive.t_i8 i8 = + { + f_from_pre = (fun (x: i8) -> true); + f_from_post = (fun (x: i8) (out: Core.Primitive.t_i8) -> true); + f_from + = + fun (x: i8) -> + Core.Primitive.C_i8 + ({ + Core.Base_interface.Int.f_v + = + Core.Convert.f_into #i8 #Core.Base.Spec.Z.t_Z #FStar.Tactics.Typeclasses.solve x + } + <: + Core.Base_interface.Int.t_I8) + <: + Core.Primitive.t_i8 + } + +let is_negative350273175 (self: Core.Primitive.t_i8) : bool = + self <. + (Core.Convert.f_into #i8 #Core.Primitive.t_i8 #FStar.Tactics.Typeclasses.solve 0y + <: + Core.Primitive.t_i8) + +let is_positive286955196 (self: Core.Primitive.t_i8) : bool = + self >. + (Core.Convert.f_into #i8 #Core.Primitive.t_i8 #FStar.Tactics.Typeclasses.solve 0y + <: + Core.Primitive.t_i8) + +let signum721334203 (self: Core.Primitive.t_i8) : Core.Primitive.t_i8 = + if + (Core.Clone.f_clone #Core.Primitive.t_i8 #FStar.Tactics.Typeclasses.solve self + <: + Core.Primitive.t_i8) <. + (Core.Convert.f_into #i8 #Core.Primitive.t_i8 #FStar.Tactics.Typeclasses.solve 0y + <: + Core.Primitive.t_i8) + then Core.Convert.f_into #i8 #Core.Primitive.t_i8 #FStar.Tactics.Typeclasses.solve (-1y) + else + if + self =. + (Core.Convert.f_into #i8 #Core.Primitive.t_i8 #FStar.Tactics.Typeclasses.solve 0y + <: + Core.Primitive.t_i8) + then Core.Convert.f_into #i8 #Core.Primitive.t_i8 #FStar.Tactics.Typeclasses.solve 0y + else Core.Convert.f_into #i8 #Core.Primitive.t_i8 #FStar.Tactics.Typeclasses.solve 1y + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_1: Core.Convert.t_From i8 Core.Primitive.t_i8 = + { + f_from_pre = (fun (x: Core.Primitive.t_i8) -> true); + f_from_post = (fun (x: Core.Primitive.t_i8) (out: i8) -> true); + f_from + = + fun (x: Core.Primitive.t_i8) -> + Core.Convert.f_into #Core.Base.Spec.Z.t_Z + #i8 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0.Core.Base_interface.Int.f_v + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_2: Core.Convert.t_From Core.Primitive.t_i16 i16 = + { + f_from_pre = (fun (x: i16) -> true); + f_from_post = (fun (x: i16) (out: Core.Primitive.t_i16) -> true); + f_from + = + fun (x: i16) -> + Core.Primitive.C_i16 + ({ + Core.Base_interface.Int.f_v + = + Core.Convert.f_into #i16 #Core.Base.Spec.Z.t_Z #FStar.Tactics.Typeclasses.solve x + } + <: + Core.Base_interface.Int.t_I16) + <: + Core.Primitive.t_i16 + } + +let is_negative477067241 (self: Core.Primitive.t_i16) : bool = + self <. + (Core.Convert.f_into #i16 #Core.Primitive.t_i16 #FStar.Tactics.Typeclasses.solve 0s + <: + Core.Primitive.t_i16) + +let is_positive821581438 (self: Core.Primitive.t_i16) : bool = + self >. + (Core.Convert.f_into #i16 #Core.Primitive.t_i16 #FStar.Tactics.Typeclasses.solve 0s + <: + Core.Primitive.t_i16) + +let signum243706004 (self: Core.Primitive.t_i16) : Core.Primitive.t_i16 = + if + (Core.Clone.f_clone #Core.Primitive.t_i16 #FStar.Tactics.Typeclasses.solve self + <: + Core.Primitive.t_i16) <. + (Core.Convert.f_into #i16 #Core.Primitive.t_i16 #FStar.Tactics.Typeclasses.solve 0s + <: + Core.Primitive.t_i16) + then Core.Convert.f_into #i16 #Core.Primitive.t_i16 #FStar.Tactics.Typeclasses.solve (-1s) + else + if + self =. + (Core.Convert.f_into #i16 #Core.Primitive.t_i16 #FStar.Tactics.Typeclasses.solve 0s + <: + Core.Primitive.t_i16) + then Core.Convert.f_into #i16 #Core.Primitive.t_i16 #FStar.Tactics.Typeclasses.solve 0s + else Core.Convert.f_into #i16 #Core.Primitive.t_i16 #FStar.Tactics.Typeclasses.solve 1s + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_3: Core.Convert.t_From i16 Core.Primitive.t_i16 = + { + f_from_pre = (fun (x: Core.Primitive.t_i16) -> true); + f_from_post = (fun (x: Core.Primitive.t_i16) (out: i16) -> true); + f_from + = + fun (x: Core.Primitive.t_i16) -> + Core.Convert.f_into #Core.Base.Spec.Z.t_Z + #i16 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0.Core.Base_interface.Int.f_v + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_4: Core.Convert.t_From Core.Primitive.t_i32 i32 = + { + f_from_pre = (fun (x: i32) -> true); + f_from_post = (fun (x: i32) (out: Core.Primitive.t_i32) -> true); + f_from + = + fun (x: i32) -> + Core.Primitive.C_i32 + ({ + Core.Base_interface.Int.f_v + = + Core.Convert.f_into #i32 #Core.Base.Spec.Z.t_Z #FStar.Tactics.Typeclasses.solve x + } + <: + Core.Base_interface.Int.t_I32) + <: + Core.Primitive.t_i32 + } + +let is_negative1035644813 (self: Core.Primitive.t_i32) : bool = + self <. + (Core.Convert.f_into #i32 #Core.Primitive.t_i32 #FStar.Tactics.Typeclasses.solve 0l + <: + Core.Primitive.t_i32) + +let is_positive401652342 (self: Core.Primitive.t_i32) : bool = + self >. + (Core.Convert.f_into #i32 #Core.Primitive.t_i32 #FStar.Tactics.Typeclasses.solve 0l + <: + Core.Primitive.t_i32) + +let signum323641039 (self: Core.Primitive.t_i32) : Core.Primitive.t_i32 = + if + (Core.Clone.f_clone #Core.Primitive.t_i32 #FStar.Tactics.Typeclasses.solve self + <: + Core.Primitive.t_i32) <. + (Core.Convert.f_into #i32 #Core.Primitive.t_i32 #FStar.Tactics.Typeclasses.solve 0l + <: + Core.Primitive.t_i32) + then Core.Convert.f_into #i32 #Core.Primitive.t_i32 #FStar.Tactics.Typeclasses.solve (-1l) + else + if + self =. + (Core.Convert.f_into #i32 #Core.Primitive.t_i32 #FStar.Tactics.Typeclasses.solve 0l + <: + Core.Primitive.t_i32) + then Core.Convert.f_into #i32 #Core.Primitive.t_i32 #FStar.Tactics.Typeclasses.solve 0l + else Core.Convert.f_into #i32 #Core.Primitive.t_i32 #FStar.Tactics.Typeclasses.solve 1l + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_5: Core.Convert.t_From i32 Core.Primitive.t_i32 = + { + f_from_pre = (fun (x: Core.Primitive.t_i32) -> true); + f_from_post = (fun (x: Core.Primitive.t_i32) (out: i32) -> true); + f_from + = + fun (x: Core.Primitive.t_i32) -> + Core.Convert.f_into #Core.Base.Spec.Z.t_Z + #i32 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0.Core.Base_interface.Int.f_v + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_6: Core.Convert.t_From Core.Primitive.t_i64 i64 = + { + f_from_pre = (fun (x: i64) -> true); + f_from_post = (fun (x: i64) (out: Core.Primitive.t_i64) -> true); + f_from + = + fun (x: i64) -> + Core.Primitive.C_i64 + ({ + Core.Base_interface.Int.f_v + = + Core.Convert.f_into #i64 #Core.Base.Spec.Z.t_Z #FStar.Tactics.Typeclasses.solve x + } + <: + Core.Base_interface.Int.t_I64) + <: + Core.Primitive.t_i64 + } + +let is_negative1066124578 (self: Core.Primitive.t_i64) : bool = + self <. + (Core.Convert.f_into #i64 #Core.Primitive.t_i64 #FStar.Tactics.Typeclasses.solve 0L + <: + Core.Primitive.t_i64) + +let is_positive16569358 (self: Core.Primitive.t_i64) : bool = + self >. + (Core.Convert.f_into #i64 #Core.Primitive.t_i64 #FStar.Tactics.Typeclasses.solve 0L + <: + Core.Primitive.t_i64) + +let signum582963664 (self: Core.Primitive.t_i64) : Core.Primitive.t_i64 = + if + (Core.Clone.f_clone #Core.Primitive.t_i64 #FStar.Tactics.Typeclasses.solve self + <: + Core.Primitive.t_i64) <. + (Core.Convert.f_into #i64 #Core.Primitive.t_i64 #FStar.Tactics.Typeclasses.solve 0L + <: + Core.Primitive.t_i64) + then Core.Convert.f_into #i64 #Core.Primitive.t_i64 #FStar.Tactics.Typeclasses.solve (-1L) + else + if + self =. + (Core.Convert.f_into #i64 #Core.Primitive.t_i64 #FStar.Tactics.Typeclasses.solve 0L + <: + Core.Primitive.t_i64) + then Core.Convert.f_into #i64 #Core.Primitive.t_i64 #FStar.Tactics.Typeclasses.solve 0L + else Core.Convert.f_into #i64 #Core.Primitive.t_i64 #FStar.Tactics.Typeclasses.solve 1L + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_7: Core.Convert.t_From i64 Core.Primitive.t_i64 = + { + f_from_pre = (fun (x: Core.Primitive.t_i64) -> true); + f_from_post = (fun (x: Core.Primitive.t_i64) (out: i64) -> true); + f_from + = + fun (x: Core.Primitive.t_i64) -> + Core.Convert.f_into #Core.Base.Spec.Z.t_Z + #i64 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0.Core.Base_interface.Int.f_v + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_8: Core.Convert.t_From Core.Primitive.t_i128 i128 = + { + f_from_pre = (fun (x: i128) -> true); + f_from_post = (fun (x: i128) (out: Core.Primitive.t_i128) -> true); + f_from + = + fun (x: i128) -> + Core.Primitive.C_i128 + ({ + Core.Base_interface.Int.f_v + = + Core.Convert.f_into #i128 #Core.Base.Spec.Z.t_Z #FStar.Tactics.Typeclasses.solve x + } + <: + Core.Base_interface.Int.t_I128) + <: + Core.Primitive.t_i128 + } + +let is_negative221698470 (self: Core.Primitive.t_i128) : bool = + self <. + (Core.Convert.f_into #i128 #Core.Primitive.t_i128 #FStar.Tactics.Typeclasses.solve (pub_i128 0) + <: + Core.Primitive.t_i128) + +let is_positive883218309 (self: Core.Primitive.t_i128) : bool = + self >. + (Core.Convert.f_into #i128 #Core.Primitive.t_i128 #FStar.Tactics.Typeclasses.solve (pub_i128 0) + <: + Core.Primitive.t_i128) + +let signum408800799 (self: Core.Primitive.t_i128) : Core.Primitive.t_i128 = + if + (Core.Clone.f_clone #Core.Primitive.t_i128 #FStar.Tactics.Typeclasses.solve self + <: + Core.Primitive.t_i128) <. + (Core.Convert.f_into #i128 #Core.Primitive.t_i128 #FStar.Tactics.Typeclasses.solve (pub_i128 0) + <: + Core.Primitive.t_i128) + then + Core.Convert.f_into #i128 + #Core.Primitive.t_i128 + #FStar.Tactics.Typeclasses.solve + (pub_i128 (-1)) + else + if + self =. + (Core.Convert.f_into #i128 + #Core.Primitive.t_i128 + #FStar.Tactics.Typeclasses.solve + (pub_i128 0) + <: + Core.Primitive.t_i128) + then + Core.Convert.f_into #i128 #Core.Primitive.t_i128 #FStar.Tactics.Typeclasses.solve (pub_i128 0) + else + Core.Convert.f_into #i128 #Core.Primitive.t_i128 #FStar.Tactics.Typeclasses.solve (pub_i128 1) + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_9: Core.Convert.t_From i128 Core.Primitive.t_i128 = + { + f_from_pre = (fun (x: Core.Primitive.t_i128) -> true); + f_from_post = (fun (x: Core.Primitive.t_i128) (out: i128) -> true); + f_from + = + fun (x: Core.Primitive.t_i128) -> + Core.Convert.f_into #Core.Base.Spec.Z.t_Z + #i128 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0.Core.Base_interface.Int.f_v + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_10: Core.Convert.t_From Core.Primitive.t_isize isize = + { + f_from_pre = (fun (x: isize) -> true); + f_from_post = (fun (x: isize) (out: Core.Primitive.t_isize) -> true); + f_from + = + fun (x: isize) -> + Core.Primitive.C_isize + ({ + Core.Base_interface.Int.f_v + = + Core.Convert.f_into #isize #Core.Base.Spec.Z.t_Z #FStar.Tactics.Typeclasses.solve x + } + <: + Core.Base_interface.Int.t_I64) + <: + Core.Primitive.t_isize + } + +let is_negative693446369 (self: Core.Primitive.t_isize) : bool = + self <. + (Core.Convert.f_into #isize #Core.Primitive.t_isize #FStar.Tactics.Typeclasses.solve (isz 0) + <: + Core.Primitive.t_isize) + +let is_positive169998680 (self: Core.Primitive.t_isize) : bool = + self >. + (Core.Convert.f_into #isize #Core.Primitive.t_isize #FStar.Tactics.Typeclasses.solve (isz 0) + <: + Core.Primitive.t_isize) + +let signum91486536 (self: Core.Primitive.t_isize) : Core.Primitive.t_isize = + if + (Core.Clone.f_clone #Core.Primitive.t_isize #FStar.Tactics.Typeclasses.solve self + <: + Core.Primitive.t_isize) <. + (Core.Convert.f_into #isize #Core.Primitive.t_isize #FStar.Tactics.Typeclasses.solve (isz 0) + <: + Core.Primitive.t_isize) + then + Core.Convert.f_into #isize #Core.Primitive.t_isize #FStar.Tactics.Typeclasses.solve (isz (-1)) + else + if + self =. + (Core.Convert.f_into #isize #Core.Primitive.t_isize #FStar.Tactics.Typeclasses.solve (isz 0) + <: + Core.Primitive.t_isize) + then Core.Convert.f_into #isize #Core.Primitive.t_isize #FStar.Tactics.Typeclasses.solve (isz 0) + else Core.Convert.f_into #isize #Core.Primitive.t_isize #FStar.Tactics.Typeclasses.solve (isz 1) + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_11: Core.Convert.t_From isize Core.Primitive.t_isize = + { + f_from_pre = (fun (x: Core.Primitive.t_isize) -> true); + f_from_post = (fun (x: Core.Primitive.t_isize) (out: isize) -> true); + f_from + = + fun (x: Core.Primitive.t_isize) -> + Core.Convert.f_into #Core.Base.Spec.Z.t_Z + #isize + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0.Core.Base_interface.Int.f_v + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_12: Core.Convert.t_From Core.Primitive.t_i16 Core.Primitive.t_i8 = + { + f_from_pre = (fun (x: Core.Primitive.t_i8) -> true); + f_from_post = (fun (x: Core.Primitive.t_i8) (out: Core.Primitive.t_i16) -> true); + f_from + = + fun (x: Core.Primitive.t_i8) -> + Core.Primitive.C_i16 + (Core.Convert.f_into #Core.Base_interface.Int.t_I8 + #Core.Base_interface.Int.t_I16 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_i16 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_13: Core.Convert.t_From Core.Primitive.t_i32 Core.Primitive.t_i8 = + { + f_from_pre = (fun (x: Core.Primitive.t_i8) -> true); + f_from_post = (fun (x: Core.Primitive.t_i8) (out: Core.Primitive.t_i32) -> true); + f_from + = + fun (x: Core.Primitive.t_i8) -> + Core.Primitive.C_i32 + (Core.Convert.f_into #Core.Base_interface.Int.t_I8 + #Core.Base_interface.Int.t_I32 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_i32 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_14: Core.Convert.t_From Core.Primitive.t_i64 Core.Primitive.t_i8 = + { + f_from_pre = (fun (x: Core.Primitive.t_i8) -> true); + f_from_post = (fun (x: Core.Primitive.t_i8) (out: Core.Primitive.t_i64) -> true); + f_from + = + fun (x: Core.Primitive.t_i8) -> + Core.Primitive.C_i64 + (Core.Convert.f_into #Core.Base_interface.Int.t_I8 + #Core.Base_interface.Int.t_I64 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_i64 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_15: Core.Convert.t_From Core.Primitive.t_i128 Core.Primitive.t_i8 = + { + f_from_pre = (fun (x: Core.Primitive.t_i8) -> true); + f_from_post = (fun (x: Core.Primitive.t_i8) (out: Core.Primitive.t_i128) -> true); + f_from + = + fun (x: Core.Primitive.t_i8) -> + Core.Primitive.C_i128 + (Core.Convert.f_into #Core.Base_interface.Int.t_I8 + #Core.Base_interface.Int.t_I128 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_i128 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_16: Core.Convert.t_From Core.Primitive.t_isize Core.Primitive.t_i8 = + { + f_from_pre = (fun (x: Core.Primitive.t_i8) -> true); + f_from_post = (fun (x: Core.Primitive.t_i8) (out: Core.Primitive.t_isize) -> true); + f_from + = + fun (x: Core.Primitive.t_i8) -> + Core.Primitive.C_isize + (Core.Convert.f_into #Core.Base_interface.Int.t_I8 + #Core.Base_interface.Int.t_I64 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_isize + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_17: Core.Convert.t_From Core.Primitive.t_i8 Core.Primitive.t_i16 = + { + f_from_pre = (fun (x: Core.Primitive.t_i16) -> true); + f_from_post = (fun (x: Core.Primitive.t_i16) (out: Core.Primitive.t_i8) -> true); + f_from + = + fun (x: Core.Primitive.t_i16) -> + Core.Primitive.C_i8 + (Core.Convert.f_into #Core.Base_interface.Int.t_I16 + #Core.Base_interface.Int.t_I8 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_i8 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_18: Core.Convert.t_From Core.Primitive.t_i32 Core.Primitive.t_i16 = + { + f_from_pre = (fun (x: Core.Primitive.t_i16) -> true); + f_from_post = (fun (x: Core.Primitive.t_i16) (out: Core.Primitive.t_i32) -> true); + f_from + = + fun (x: Core.Primitive.t_i16) -> + Core.Primitive.C_i32 + (Core.Convert.f_into #Core.Base_interface.Int.t_I16 + #Core.Base_interface.Int.t_I32 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_i32 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_19: Core.Convert.t_From Core.Primitive.t_i64 Core.Primitive.t_i16 = + { + f_from_pre = (fun (x: Core.Primitive.t_i16) -> true); + f_from_post = (fun (x: Core.Primitive.t_i16) (out: Core.Primitive.t_i64) -> true); + f_from + = + fun (x: Core.Primitive.t_i16) -> + Core.Primitive.C_i64 + (Core.Convert.f_into #Core.Base_interface.Int.t_I16 + #Core.Base_interface.Int.t_I64 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_i64 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_20: Core.Convert.t_From Core.Primitive.t_i128 Core.Primitive.t_i16 = + { + f_from_pre = (fun (x: Core.Primitive.t_i16) -> true); + f_from_post = (fun (x: Core.Primitive.t_i16) (out: Core.Primitive.t_i128) -> true); + f_from + = + fun (x: Core.Primitive.t_i16) -> + Core.Primitive.C_i128 + (Core.Convert.f_into #Core.Base_interface.Int.t_I16 + #Core.Base_interface.Int.t_I128 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_i128 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_21: Core.Convert.t_From Core.Primitive.t_isize Core.Primitive.t_i16 = + { + f_from_pre = (fun (x: Core.Primitive.t_i16) -> true); + f_from_post = (fun (x: Core.Primitive.t_i16) (out: Core.Primitive.t_isize) -> true); + f_from + = + fun (x: Core.Primitive.t_i16) -> + Core.Primitive.C_isize + (Core.Convert.f_into #Core.Base_interface.Int.t_I16 + #Core.Base_interface.Int.t_I64 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_isize + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_22: Core.Convert.t_From Core.Primitive.t_i8 Core.Primitive.t_i32 = + { + f_from_pre = (fun (x: Core.Primitive.t_i32) -> true); + f_from_post = (fun (x: Core.Primitive.t_i32) (out: Core.Primitive.t_i8) -> true); + f_from + = + fun (x: Core.Primitive.t_i32) -> + Core.Primitive.C_i8 + (Core.Convert.f_into #Core.Base_interface.Int.t_I32 + #Core.Base_interface.Int.t_I8 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_i8 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_23: Core.Convert.t_From Core.Primitive.t_i16 Core.Primitive.t_i32 = + { + f_from_pre = (fun (x: Core.Primitive.t_i32) -> true); + f_from_post = (fun (x: Core.Primitive.t_i32) (out: Core.Primitive.t_i16) -> true); + f_from + = + fun (x: Core.Primitive.t_i32) -> + Core.Primitive.C_i16 + (Core.Convert.f_into #Core.Base_interface.Int.t_I32 + #Core.Base_interface.Int.t_I16 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_i16 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_24: Core.Convert.t_From Core.Primitive.t_i64 Core.Primitive.t_i32 = + { + f_from_pre = (fun (x: Core.Primitive.t_i32) -> true); + f_from_post = (fun (x: Core.Primitive.t_i32) (out: Core.Primitive.t_i64) -> true); + f_from + = + fun (x: Core.Primitive.t_i32) -> + Core.Primitive.C_i64 + (Core.Convert.f_into #Core.Base_interface.Int.t_I32 + #Core.Base_interface.Int.t_I64 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_i64 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_25: Core.Convert.t_From Core.Primitive.t_i128 Core.Primitive.t_i32 = + { + f_from_pre = (fun (x: Core.Primitive.t_i32) -> true); + f_from_post = (fun (x: Core.Primitive.t_i32) (out: Core.Primitive.t_i128) -> true); + f_from + = + fun (x: Core.Primitive.t_i32) -> + Core.Primitive.C_i128 + (Core.Convert.f_into #Core.Base_interface.Int.t_I32 + #Core.Base_interface.Int.t_I128 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_i128 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_26: Core.Convert.t_From Core.Primitive.t_isize Core.Primitive.t_i32 = + { + f_from_pre = (fun (x: Core.Primitive.t_i32) -> true); + f_from_post = (fun (x: Core.Primitive.t_i32) (out: Core.Primitive.t_isize) -> true); + f_from + = + fun (x: Core.Primitive.t_i32) -> + Core.Primitive.C_isize + (Core.Convert.f_into #Core.Base_interface.Int.t_I32 + #Core.Base_interface.Int.t_I64 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_isize + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_27: Core.Convert.t_From Core.Primitive.t_i8 Core.Primitive.t_i64 = + { + f_from_pre = (fun (x: Core.Primitive.t_i64) -> true); + f_from_post = (fun (x: Core.Primitive.t_i64) (out: Core.Primitive.t_i8) -> true); + f_from + = + fun (x: Core.Primitive.t_i64) -> + Core.Primitive.C_i8 + (Core.Convert.f_into #Core.Base_interface.Int.t_I64 + #Core.Base_interface.Int.t_I8 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_i8 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_28: Core.Convert.t_From Core.Primitive.t_i16 Core.Primitive.t_i64 = + { + f_from_pre = (fun (x: Core.Primitive.t_i64) -> true); + f_from_post = (fun (x: Core.Primitive.t_i64) (out: Core.Primitive.t_i16) -> true); + f_from + = + fun (x: Core.Primitive.t_i64) -> + Core.Primitive.C_i16 + (Core.Convert.f_into #Core.Base_interface.Int.t_I64 + #Core.Base_interface.Int.t_I16 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_i16 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_29: Core.Convert.t_From Core.Primitive.t_i32 Core.Primitive.t_i64 = + { + f_from_pre = (fun (x: Core.Primitive.t_i64) -> true); + f_from_post = (fun (x: Core.Primitive.t_i64) (out: Core.Primitive.t_i32) -> true); + f_from + = + fun (x: Core.Primitive.t_i64) -> + Core.Primitive.C_i32 + (Core.Convert.f_into #Core.Base_interface.Int.t_I64 + #Core.Base_interface.Int.t_I32 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_i32 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_30: Core.Convert.t_From Core.Primitive.t_i128 Core.Primitive.t_i64 = + { + f_from_pre = (fun (x: Core.Primitive.t_i64) -> true); + f_from_post = (fun (x: Core.Primitive.t_i64) (out: Core.Primitive.t_i128) -> true); + f_from + = + fun (x: Core.Primitive.t_i64) -> + Core.Primitive.C_i128 + (Core.Convert.f_into #Core.Base_interface.Int.t_I64 + #Core.Base_interface.Int.t_I128 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_i128 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_32: Core.Convert.t_From Core.Primitive.t_i8 Core.Primitive.t_i128 = + { + f_from_pre = (fun (x: Core.Primitive.t_i128) -> true); + f_from_post = (fun (x: Core.Primitive.t_i128) (out: Core.Primitive.t_i8) -> true); + f_from + = + fun (x: Core.Primitive.t_i128) -> + Core.Primitive.C_i8 + (Core.Convert.f_into #Core.Base_interface.Int.t_I128 + #Core.Base_interface.Int.t_I8 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_i8 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_33: Core.Convert.t_From Core.Primitive.t_i16 Core.Primitive.t_i128 = + { + f_from_pre = (fun (x: Core.Primitive.t_i128) -> true); + f_from_post = (fun (x: Core.Primitive.t_i128) (out: Core.Primitive.t_i16) -> true); + f_from + = + fun (x: Core.Primitive.t_i128) -> + Core.Primitive.C_i16 + (Core.Convert.f_into #Core.Base_interface.Int.t_I128 + #Core.Base_interface.Int.t_I16 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_i16 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_34: Core.Convert.t_From Core.Primitive.t_i32 Core.Primitive.t_i128 = + { + f_from_pre = (fun (x: Core.Primitive.t_i128) -> true); + f_from_post = (fun (x: Core.Primitive.t_i128) (out: Core.Primitive.t_i32) -> true); + f_from + = + fun (x: Core.Primitive.t_i128) -> + Core.Primitive.C_i32 + (Core.Convert.f_into #Core.Base_interface.Int.t_I128 + #Core.Base_interface.Int.t_I32 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_i32 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_35: Core.Convert.t_From Core.Primitive.t_i64 Core.Primitive.t_i128 = + { + f_from_pre = (fun (x: Core.Primitive.t_i128) -> true); + f_from_post = (fun (x: Core.Primitive.t_i128) (out: Core.Primitive.t_i64) -> true); + f_from + = + fun (x: Core.Primitive.t_i128) -> + Core.Primitive.C_i64 + (Core.Convert.f_into #Core.Base_interface.Int.t_I128 + #Core.Base_interface.Int.t_I64 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_i64 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_36: Core.Convert.t_From Core.Primitive.t_isize Core.Primitive.t_i128 = + { + f_from_pre = (fun (x: Core.Primitive.t_i128) -> true); + f_from_post = (fun (x: Core.Primitive.t_i128) (out: Core.Primitive.t_isize) -> true); + f_from + = + fun (x: Core.Primitive.t_i128) -> + Core.Primitive.C_isize + (Core.Convert.f_into #Core.Base_interface.Int.t_I128 + #Core.Base_interface.Int.t_I64 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_isize + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_37: Core.Convert.t_From Core.Primitive.t_i8 Core.Primitive.t_isize = + { + f_from_pre = (fun (x: Core.Primitive.t_isize) -> true); + f_from_post = (fun (x: Core.Primitive.t_isize) (out: Core.Primitive.t_i8) -> true); + f_from + = + fun (x: Core.Primitive.t_isize) -> + Core.Primitive.C_i8 + (Core.Convert.f_into #Core.Base_interface.Int.t_I64 + #Core.Base_interface.Int.t_I8 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_i8 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_38: Core.Convert.t_From Core.Primitive.t_i16 Core.Primitive.t_isize = + { + f_from_pre = (fun (x: Core.Primitive.t_isize) -> true); + f_from_post = (fun (x: Core.Primitive.t_isize) (out: Core.Primitive.t_i16) -> true); + f_from + = + fun (x: Core.Primitive.t_isize) -> + Core.Primitive.C_i16 + (Core.Convert.f_into #Core.Base_interface.Int.t_I64 + #Core.Base_interface.Int.t_I16 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_i16 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_39: Core.Convert.t_From Core.Primitive.t_i32 Core.Primitive.t_isize = + { + f_from_pre = (fun (x: Core.Primitive.t_isize) -> true); + f_from_post = (fun (x: Core.Primitive.t_isize) (out: Core.Primitive.t_i32) -> true); + f_from + = + fun (x: Core.Primitive.t_isize) -> + Core.Primitive.C_i32 + (Core.Convert.f_into #Core.Base_interface.Int.t_I64 + #Core.Base_interface.Int.t_I32 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_i32 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_41: Core.Convert.t_From Core.Primitive.t_i128 Core.Primitive.t_isize = + { + f_from_pre = (fun (x: Core.Primitive.t_isize) -> true); + f_from_post = (fun (x: Core.Primitive.t_isize) (out: Core.Primitive.t_i128) -> true); + f_from + = + fun (x: Core.Primitive.t_isize) -> + Core.Primitive.C_i128 + (Core.Convert.f_into #Core.Base_interface.Int.t_I64 + #Core.Base_interface.Int.t_I128 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_i128 + } + +let add_with_overflow_i128 (x y: Core.Primitive.t_i128) : (Core.Primitive.t_i128 & bool) = + let overflow:Core.Base.Spec.Z.t_Z = + Core.Base.Z.z_add (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I128 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0 + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I128 + #FStar.Tactics.Typeclasses.solve + y.Core.Primitive._0 + <: + Core.Base.Spec.Z.t_Z) + in + let (res: Core.Base_interface.Int.t_I128):Core.Base_interface.Int.t_I128 = + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #Core.Base_interface.Int.t_I128 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base.Spec.Z.t_Z #FStar.Tactics.Typeclasses.solve overflow + <: + Core.Base.Spec.Z.t_Z) + in + (Core.Primitive.C_i128 + (Core.Clone.f_clone #Core.Base_interface.Int.t_I128 #FStar.Tactics.Typeclasses.solve res) + <: + Core.Primitive.t_i128), + Core.Base.Z.z_lt (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I128 + #FStar.Tactics.Typeclasses.solve + res + <: + Core.Base.Spec.Z.t_Z) + overflow + <: + (Core.Primitive.t_i128 & bool) + +let add_with_overflow_i16 (x y: Core.Primitive.t_i16) : (Core.Primitive.t_i16 & bool) = + let overflow:Core.Base.Spec.Z.t_Z = + Core.Base.Z.z_add (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I16 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0 + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I16 + #FStar.Tactics.Typeclasses.solve + y.Core.Primitive._0 + <: + Core.Base.Spec.Z.t_Z) + in + let (res: Core.Base_interface.Int.t_I16):Core.Base_interface.Int.t_I16 = + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #Core.Base_interface.Int.t_I16 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base.Spec.Z.t_Z #FStar.Tactics.Typeclasses.solve overflow + <: + Core.Base.Spec.Z.t_Z) + in + (Core.Primitive.C_i16 + (Core.Clone.f_clone #Core.Base_interface.Int.t_I16 #FStar.Tactics.Typeclasses.solve res) + <: + Core.Primitive.t_i16), + Core.Base.Z.z_lt (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I16 + #FStar.Tactics.Typeclasses.solve + res + <: + Core.Base.Spec.Z.t_Z) + overflow + <: + (Core.Primitive.t_i16 & bool) + +let add_with_overflow_i32 (x y: Core.Primitive.t_i32) : (Core.Primitive.t_i32 & bool) = + let overflow:Core.Base.Spec.Z.t_Z = + Core.Base.Z.z_add (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I32 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0 + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I32 + #FStar.Tactics.Typeclasses.solve + y.Core.Primitive._0 + <: + Core.Base.Spec.Z.t_Z) + in + let (res: Core.Base_interface.Int.t_I32):Core.Base_interface.Int.t_I32 = + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #Core.Base_interface.Int.t_I32 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base.Spec.Z.t_Z #FStar.Tactics.Typeclasses.solve overflow + <: + Core.Base.Spec.Z.t_Z) + in + (Core.Primitive.C_i32 + (Core.Clone.f_clone #Core.Base_interface.Int.t_I32 #FStar.Tactics.Typeclasses.solve res) + <: + Core.Primitive.t_i32), + Core.Base.Z.z_lt (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I32 + #FStar.Tactics.Typeclasses.solve + res + <: + Core.Base.Spec.Z.t_Z) + overflow + <: + (Core.Primitive.t_i32 & bool) + +let add_with_overflow_i64 (x y: Core.Primitive.t_i64) : (Core.Primitive.t_i64 & bool) = + let overflow:Core.Base.Spec.Z.t_Z = + Core.Base.Z.z_add (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I64 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0 + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I64 + #FStar.Tactics.Typeclasses.solve + y.Core.Primitive._0 + <: + Core.Base.Spec.Z.t_Z) + in + let (res: Core.Base_interface.Int.t_I64):Core.Base_interface.Int.t_I64 = + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #Core.Base_interface.Int.t_I64 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base.Spec.Z.t_Z #FStar.Tactics.Typeclasses.solve overflow + <: + Core.Base.Spec.Z.t_Z) + in + (Core.Primitive.C_i64 + (Core.Clone.f_clone #Core.Base_interface.Int.t_I64 #FStar.Tactics.Typeclasses.solve res) + <: + Core.Primitive.t_i64), + Core.Base.Z.z_lt (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I64 + #FStar.Tactics.Typeclasses.solve + res + <: + Core.Base.Spec.Z.t_Z) + overflow + <: + (Core.Primitive.t_i64 & bool) + +let add_with_overflow_i8 (x y: Core.Primitive.t_i8) : (Core.Primitive.t_i8 & bool) = + let overflow:Core.Base.Spec.Z.t_Z = + Core.Base.Z.z_add (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I8 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0 + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I8 + #FStar.Tactics.Typeclasses.solve + y.Core.Primitive._0 + <: + Core.Base.Spec.Z.t_Z) + in + let (res: Core.Base_interface.Int.t_I8):Core.Base_interface.Int.t_I8 = + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #Core.Base_interface.Int.t_I8 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base.Spec.Z.t_Z #FStar.Tactics.Typeclasses.solve overflow + <: + Core.Base.Spec.Z.t_Z) + in + (Core.Primitive.C_i8 + (Core.Clone.f_clone #Core.Base_interface.Int.t_I8 #FStar.Tactics.Typeclasses.solve res) + <: + Core.Primitive.t_i8), + Core.Base.Z.z_lt (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I8 + #FStar.Tactics.Typeclasses.solve + res + <: + Core.Base.Spec.Z.t_Z) + overflow + <: + (Core.Primitive.t_i8 & bool) + +let add_with_overflow_isize (x y: Core.Primitive.t_isize) : (Core.Primitive.t_isize & bool) = + let overflow:Core.Base.Spec.Z.t_Z = + Core.Base.Z.z_add (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I64 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0 + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I64 + #FStar.Tactics.Typeclasses.solve + y.Core.Primitive._0 + <: + Core.Base.Spec.Z.t_Z) + in + let (res: Core.Base_interface.Int.t_I64):Core.Base_interface.Int.t_I64 = + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Z.t_Z + #Core.Base_interface.Int.t_I64 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base.Spec.Z.t_Z #FStar.Tactics.Typeclasses.solve overflow + <: + Core.Base.Spec.Z.t_Z) + in + (Core.Primitive.C_isize + (Core.Clone.f_clone #Core.Base_interface.Int.t_I64 #FStar.Tactics.Typeclasses.solve res) + <: + Core.Primitive.t_isize), + Core.Base.Z.z_lt (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I64 + #FStar.Tactics.Typeclasses.solve + res + <: + Core.Base.Spec.Z.t_Z) + overflow + <: + (Core.Primitive.t_isize & bool) + +let unchecked_add_i128 (x y: Core.Primitive.t_i128) : Core.Primitive.t_i128 = + Core.Primitive.C_i128 + ({ + Core.Base_interface.Int.f_v + = + Core.Base.Z.z_add (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I128 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0 + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I128 + #FStar.Tactics.Typeclasses.solve + y.Core.Primitive._0 + <: + Core.Base.Spec.Z.t_Z) + } + <: + Core.Base_interface.Int.t_I128) + <: + Core.Primitive.t_i128 + +let unchecked_add_i16 (x y: Core.Primitive.t_i16) : Core.Primitive.t_i16 = + Core.Primitive.C_i16 + ({ + Core.Base_interface.Int.f_v + = + Core.Base.Z.z_add (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I16 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0 + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I16 + #FStar.Tactics.Typeclasses.solve + y.Core.Primitive._0 + <: + Core.Base.Spec.Z.t_Z) + } + <: + Core.Base_interface.Int.t_I16) + <: + Core.Primitive.t_i16 + +let unchecked_add_i32 (x y: Core.Primitive.t_i32) : Core.Primitive.t_i32 = + Core.Primitive.C_i32 + ({ + Core.Base_interface.Int.f_v + = + Core.Base.Z.z_add (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I32 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0 + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I32 + #FStar.Tactics.Typeclasses.solve + y.Core.Primitive._0 + <: + Core.Base.Spec.Z.t_Z) + } + <: + Core.Base_interface.Int.t_I32) + <: + Core.Primitive.t_i32 + +let unchecked_add_i64 (x y: Core.Primitive.t_i64) : Core.Primitive.t_i64 = + Core.Primitive.C_i64 + ({ + Core.Base_interface.Int.f_v + = + Core.Base.Z.z_add (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I64 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0 + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I64 + #FStar.Tactics.Typeclasses.solve + y.Core.Primitive._0 + <: + Core.Base.Spec.Z.t_Z) + } + <: + Core.Base_interface.Int.t_I64) + <: + Core.Primitive.t_i64 + +let unchecked_add_i8 (x y: Core.Primitive.t_i8) : Core.Primitive.t_i8 = + Core.Primitive.C_i8 + ({ + Core.Base_interface.Int.f_v + = + Core.Base.Z.z_add (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I8 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0 + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I8 + #FStar.Tactics.Typeclasses.solve + y.Core.Primitive._0 + <: + Core.Base.Spec.Z.t_Z) + } + <: + Core.Base_interface.Int.t_I8) + <: + Core.Primitive.t_i8 + +let unchecked_add_isize (x y: Core.Primitive.t_isize) : Core.Primitive.t_isize = + Core.Primitive.C_isize + ({ + Core.Base_interface.Int.f_v + = + Core.Base.Z.z_add (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I64 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0 + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I64 + #FStar.Tactics.Typeclasses.solve + y.Core.Primitive._0 + <: + Core.Base.Spec.Z.t_Z) + } + <: + Core.Base_interface.Int.t_I64) + <: + Core.Primitive.t_isize + +let unchecked_add_u128 (x y: Core.Primitive.t_u128) : Core.Primitive.t_u128 = + Core.Primitive.C_u128 + ({ + Core.Base_interface.Int.f_v + = + Core.Base.Pos.haxint_add (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U128 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0 + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U128 + #FStar.Tactics.Typeclasses.solve + y.Core.Primitive._0 + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + <: + Core.Base_interface.Int.t_U128) + <: + Core.Primitive.t_u128 + +let unchecked_add_u16 (x y: Core.Primitive.t_u16) : Core.Primitive.t_u16 = + Core.Primitive.C_u16 + ({ + Core.Base_interface.Int.f_v + = + Core.Base.Pos.haxint_add (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U16 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0 + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U16 + #FStar.Tactics.Typeclasses.solve + y.Core.Primitive._0 + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + <: + Core.Base_interface.Int.t_U16) + <: + Core.Primitive.t_u16 + +let unchecked_add_u32 (x y: Core.Primitive.t_u32) : Core.Primitive.t_u32 = + Core.Primitive.C_u32 + ({ + Core.Base_interface.Int.f_v + = + Core.Base.Pos.haxint_add (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U32 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0 + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U32 + #FStar.Tactics.Typeclasses.solve + y.Core.Primitive._0 + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + <: + Core.Base_interface.Int.t_U32) + <: + Core.Primitive.t_u32 + +let unchecked_add_u64 (x y: Core.Primitive.t_u64) : Core.Primitive.t_u64 = + Core.Primitive.C_u64 + ({ + Core.Base_interface.Int.f_v + = + Core.Base.Pos.haxint_add (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0 + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + y.Core.Primitive._0 + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + <: + Core.Base_interface.Int.t_U64) + <: + Core.Primitive.t_u64 + +let unchecked_add_u8 (x y: Core.Primitive.t_u8) : Core.Primitive.t_u8 = + Core.Primitive.C_u8 + ({ + Core.Base_interface.Int.f_v + = + Core.Base.Pos.haxint_add (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U8 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0 + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U8 + #FStar.Tactics.Typeclasses.solve + y.Core.Primitive._0 + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + <: + Core.Base_interface.Int.t_U8) + <: + Core.Primitive.t_u8 + +let unchecked_add_usize (x y: Core.Primitive.t_usize) : Core.Primitive.t_usize = + Core.Primitive.C_usize + ({ + Core.Base_interface.Int.f_v + = + Core.Base.Pos.haxint_add (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0 + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + y.Core.Primitive._0 + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + <: + Core.Base_interface.Int.t_U64) + <: + Core.Primitive.t_usize + +let checked_add268751055 (self rhs: Core.Primitive.t_u8) : Core.Option.t_Option Core.Primitive.t_u8 = + Core.Option.Option_Some (unchecked_add_u8 self rhs) <: Core.Option.t_Option Core.Primitive.t_u8 + +let checked_add132377399 (self rhs: Core.Primitive.t_u16) + : Core.Option.t_Option Core.Primitive.t_u16 = + Core.Option.Option_Some (unchecked_add_u16 self rhs) <: Core.Option.t_Option Core.Primitive.t_u16 + +let checked_add985437730 (self rhs: Core.Primitive.t_u32) + : Core.Option.t_Option Core.Primitive.t_u32 = + Core.Option.Option_Some (unchecked_add_u32 self rhs) <: Core.Option.t_Option Core.Primitive.t_u32 + +let checked_add586246465 (self rhs: Core.Primitive.t_u64) + : Core.Option.t_Option Core.Primitive.t_u64 = + Core.Option.Option_Some (unchecked_add_u64 self rhs) <: Core.Option.t_Option Core.Primitive.t_u64 + +let checked_add218978451 (self rhs: Core.Primitive.t_u128) + : Core.Option.t_Option Core.Primitive.t_u128 = + Core.Option.Option_Some (unchecked_add_u128 self rhs) + <: + Core.Option.t_Option Core.Primitive.t_u128 + +let checked_add984013567 (self rhs: Core.Primitive.t_usize) + : Core.Option.t_Option Core.Primitive.t_usize = + Core.Option.Option_Some (unchecked_add_usize self rhs) + <: + Core.Option.t_Option Core.Primitive.t_usize + +let add_with_overflow_u128 (x y: Core.Primitive.t_u128) : (Core.Primitive.t_u128 & bool) = + let overflow:Core.Base.Spec.Haxint.t_HaxInt = + Core.Base.Pos.haxint_add (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U128 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0 + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U128 + #FStar.Tactics.Typeclasses.solve + y.Core.Primitive._0 + <: + Core.Base.Spec.Haxint.t_HaxInt) + in + let (res: Core.Base_interface.Int.t_U128):Core.Base_interface.Int.t_U128 = + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #Core.Base_interface.Int.t_U128 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base.Spec.Haxint.t_HaxInt #FStar.Tactics.Typeclasses.solve overflow + <: + Core.Base.Spec.Haxint.t_HaxInt) + in + (Core.Primitive.C_u128 + (Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve res) + <: + Core.Primitive.t_u128), + Core.Base.Pos.haxint_lt (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U128 + #FStar.Tactics.Typeclasses.solve + res + <: + Core.Base.Spec.Haxint.t_HaxInt) + overflow + <: + (Core.Primitive.t_u128 & bool) + +let add_with_overflow_u16 (x y: Core.Primitive.t_u16) : (Core.Primitive.t_u16 & bool) = + let overflow:Core.Base.Spec.Haxint.t_HaxInt = + Core.Base.Pos.haxint_add (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U16 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0 + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U16 + #FStar.Tactics.Typeclasses.solve + y.Core.Primitive._0 + <: + Core.Base.Spec.Haxint.t_HaxInt) + in + let (res: Core.Base_interface.Int.t_U16):Core.Base_interface.Int.t_U16 = + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #Core.Base_interface.Int.t_U16 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base.Spec.Haxint.t_HaxInt #FStar.Tactics.Typeclasses.solve overflow + <: + Core.Base.Spec.Haxint.t_HaxInt) + in + (Core.Primitive.C_u16 + (Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve res) + <: + Core.Primitive.t_u16), + Core.Base.Pos.haxint_lt (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U16 + #FStar.Tactics.Typeclasses.solve + res + <: + Core.Base.Spec.Haxint.t_HaxInt) + overflow + <: + (Core.Primitive.t_u16 & bool) + +let add_with_overflow_u32 (x y: Core.Primitive.t_u32) : (Core.Primitive.t_u32 & bool) = + let overflow:Core.Base.Spec.Haxint.t_HaxInt = + Core.Base.Pos.haxint_add (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U32 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0 + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U32 + #FStar.Tactics.Typeclasses.solve + y.Core.Primitive._0 + <: + Core.Base.Spec.Haxint.t_HaxInt) + in + let (res: Core.Base_interface.Int.t_U32):Core.Base_interface.Int.t_U32 = + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #Core.Base_interface.Int.t_U32 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base.Spec.Haxint.t_HaxInt #FStar.Tactics.Typeclasses.solve overflow + <: + Core.Base.Spec.Haxint.t_HaxInt) + in + (Core.Primitive.C_u32 + (Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve res) + <: + Core.Primitive.t_u32), + Core.Base.Pos.haxint_lt (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U32 + #FStar.Tactics.Typeclasses.solve + res + <: + Core.Base.Spec.Haxint.t_HaxInt) + overflow + <: + (Core.Primitive.t_u32 & bool) + +let add_with_overflow_u64 (x y: Core.Primitive.t_u64) : (Core.Primitive.t_u64 & bool) = + let overflow:Core.Base.Spec.Haxint.t_HaxInt = + Core.Base.Pos.haxint_add (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0 + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + y.Core.Primitive._0 + <: + Core.Base.Spec.Haxint.t_HaxInt) + in + let (res: Core.Base_interface.Int.t_U64):Core.Base_interface.Int.t_U64 = + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base.Spec.Haxint.t_HaxInt #FStar.Tactics.Typeclasses.solve overflow + <: + Core.Base.Spec.Haxint.t_HaxInt) + in + (Core.Primitive.C_u64 + (Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve res) + <: + Core.Primitive.t_u64), + Core.Base.Pos.haxint_lt (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + res + <: + Core.Base.Spec.Haxint.t_HaxInt) + overflow + <: + (Core.Primitive.t_u64 & bool) + +let add_with_overflow_u8 (x y: Core.Primitive.t_u8) : (Core.Primitive.t_u8 & bool) = + let overflow:Core.Base.Spec.Haxint.t_HaxInt = + Core.Base.Pos.haxint_add (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U8 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0 + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U8 + #FStar.Tactics.Typeclasses.solve + y.Core.Primitive._0 + <: + Core.Base.Spec.Haxint.t_HaxInt) + in + let (res: Core.Base_interface.Int.t_U8):Core.Base_interface.Int.t_U8 = + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #Core.Base_interface.Int.t_U8 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base.Spec.Haxint.t_HaxInt #FStar.Tactics.Typeclasses.solve overflow + <: + Core.Base.Spec.Haxint.t_HaxInt) + in + (Core.Primitive.C_u8 + (Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve res) + <: + Core.Primitive.t_u8), + Core.Base.Pos.haxint_lt (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U8 + #FStar.Tactics.Typeclasses.solve + res + <: + Core.Base.Spec.Haxint.t_HaxInt) + overflow + <: + (Core.Primitive.t_u8 & bool) + +let add_with_overflow_usize (x y: Core.Primitive.t_usize) : (Core.Primitive.t_usize & bool) = + let overflow:Core.Base.Spec.Haxint.t_HaxInt = + Core.Base.Pos.haxint_add (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0 + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + y.Core.Primitive._0 + <: + Core.Base.Spec.Haxint.t_HaxInt) + in + let (res: Core.Base_interface.Int.t_U64):Core.Base_interface.Int.t_U64 = + Core.Base_interface.Coerce.f_concretize #Core.Base.Spec.Haxint.t_HaxInt + #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + (Core.Clone.f_clone #Core.Base.Spec.Haxint.t_HaxInt #FStar.Tactics.Typeclasses.solve overflow + <: + Core.Base.Spec.Haxint.t_HaxInt) + in + (Core.Primitive.C_usize + (Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve res) + <: + Core.Primitive.t_usize), + Core.Base.Pos.haxint_lt (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + res + <: + Core.Base.Spec.Haxint.t_HaxInt) + overflow + <: + (Core.Primitive.t_usize & bool) + +let unchecked_div_u128 (x y: Core.Primitive.t_u128) : Core.Primitive.t_u128 = + Core.Primitive.C_u128 + ({ + Core.Base_interface.Int.f_v + = + Core.Base.Pos.haxint_div (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U128 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0 + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U128 + #FStar.Tactics.Typeclasses.solve + y.Core.Primitive._0 + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + <: + Core.Base_interface.Int.t_U128) + <: + Core.Primitive.t_u128 + +let unchecked_div_u16 (x y: Core.Primitive.t_u16) : Core.Primitive.t_u16 = + Core.Primitive.C_u16 + ({ + Core.Base_interface.Int.f_v + = + Core.Base.Pos.haxint_div (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U16 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0 + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U16 + #FStar.Tactics.Typeclasses.solve + y.Core.Primitive._0 + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + <: + Core.Base_interface.Int.t_U16) + <: + Core.Primitive.t_u16 + +let unchecked_div_u32 (x y: Core.Primitive.t_u32) : Core.Primitive.t_u32 = + Core.Primitive.C_u32 + ({ + Core.Base_interface.Int.f_v + = + Core.Base.Pos.haxint_div (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U32 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0 + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U32 + #FStar.Tactics.Typeclasses.solve + y.Core.Primitive._0 + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + <: + Core.Base_interface.Int.t_U32) + <: + Core.Primitive.t_u32 + +let unchecked_div_u64 (x y: Core.Primitive.t_u64) : Core.Primitive.t_u64 = + Core.Primitive.C_u64 + ({ + Core.Base_interface.Int.f_v + = + Core.Base.Pos.haxint_div (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0 + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + y.Core.Primitive._0 + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + <: + Core.Base_interface.Int.t_U64) + <: + Core.Primitive.t_u64 + +let unchecked_div_u8 (x y: Core.Primitive.t_u8) : Core.Primitive.t_u8 = + Core.Primitive.C_u8 + ({ + Core.Base_interface.Int.f_v + = + Core.Base.Pos.haxint_div (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U8 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0 + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U8 + #FStar.Tactics.Typeclasses.solve + y.Core.Primitive._0 + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + <: + Core.Base_interface.Int.t_U8) + <: + Core.Primitive.t_u8 + +let unchecked_div_usize (x y: Core.Primitive.t_usize) : Core.Primitive.t_usize = + Core.Primitive.C_usize + ({ + Core.Base_interface.Int.f_v + = + Core.Base.Pos.haxint_div (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0 + <: + Core.Base.Spec.Haxint.t_HaxInt) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + y.Core.Primitive._0 + <: + Core.Base.Spec.Haxint.t_HaxInt) + } + <: + Core.Base_interface.Int.t_U64) + <: + Core.Primitive.t_usize + +let wrapping_add_i128 (a b: Core.Primitive.t_i128) : Core.Primitive.t_i128 = + Core.Primitive.C_i128 (a.Core.Primitive._0 +! b.Core.Primitive._0) <: Core.Primitive.t_i128 + +let wrapping_add_i16 (a b: Core.Primitive.t_i16) : Core.Primitive.t_i16 = + Core.Primitive.C_i16 (a.Core.Primitive._0 +! b.Core.Primitive._0) <: Core.Primitive.t_i16 + +let wrapping_add_i32 (a b: Core.Primitive.t_i32) : Core.Primitive.t_i32 = + Core.Primitive.C_i32 (a.Core.Primitive._0 +! b.Core.Primitive._0) <: Core.Primitive.t_i32 + +let wrapping_add_i64 (a b: Core.Primitive.t_i64) : Core.Primitive.t_i64 = + Core.Primitive.C_i64 (a.Core.Primitive._0 +! b.Core.Primitive._0) <: Core.Primitive.t_i64 + +let wrapping_add_i8 (a b: Core.Primitive.t_i8) : Core.Primitive.t_i8 = + Core.Primitive.C_i8 (a.Core.Primitive._0 +! b.Core.Primitive._0) <: Core.Primitive.t_i8 + +let wrapping_add_isize (a b: Core.Primitive.t_isize) : Core.Primitive.t_isize = + Core.Primitive.C_isize (a.Core.Primitive._0 +! b.Core.Primitive._0) <: Core.Primitive.t_isize + +let wrapping_sub_i128 (a b: Core.Primitive.t_i128) : Core.Primitive.t_i128 = + Core.Primitive.C_i128 (a.Core.Primitive._0 -! b.Core.Primitive._0) <: Core.Primitive.t_i128 + +let wrapping_sub_i16 (a b: Core.Primitive.t_i16) : Core.Primitive.t_i16 = + Core.Primitive.C_i16 (a.Core.Primitive._0 -! b.Core.Primitive._0) <: Core.Primitive.t_i16 + +let wrapping_sub_i32 (a b: Core.Primitive.t_i32) : Core.Primitive.t_i32 = + Core.Primitive.C_i32 (a.Core.Primitive._0 -! b.Core.Primitive._0) <: Core.Primitive.t_i32 + +let wrapping_sub_i64 (a b: Core.Primitive.t_i64) : Core.Primitive.t_i64 = + Core.Primitive.C_i64 (a.Core.Primitive._0 -! b.Core.Primitive._0) <: Core.Primitive.t_i64 + +let wrapping_sub_i8 (a b: Core.Primitive.t_i8) : Core.Primitive.t_i8 = + Core.Primitive.C_i8 (a.Core.Primitive._0 -! b.Core.Primitive._0) <: Core.Primitive.t_i8 + +let wrapping_sub_isize (a b: Core.Primitive.t_isize) : Core.Primitive.t_isize = + Core.Primitive.C_isize (a.Core.Primitive._0 -! b.Core.Primitive._0) <: Core.Primitive.t_isize + +let wrapping_add634491935 (self rhs: Core.Primitive.t_i8) : Core.Primitive.t_i8 = + wrapping_add_i8 self rhs + +let wrapping_sub973428293 (self rhs: Core.Primitive.t_i8) : Core.Primitive.t_i8 = + wrapping_sub_i8 self rhs + +let wrapping_neg400701205 (self: Core.Primitive.t_i8) : Core.Primitive.t_i8 = + wrapping_sub973428293 (Core.Convert.f_into #i8 + #Core.Primitive.t_i8 + #FStar.Tactics.Typeclasses.solve + 0y + <: + Core.Primitive.t_i8) + self + +let wrapping_abs400396545 (self: Core.Primitive.t_i8) : Core.Primitive.t_i8 = + if + is_negative350273175 (Core.Clone.f_clone #Core.Primitive.t_i8 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Primitive.t_i8) + then wrapping_neg400701205 self + else self + +let wrapping_add868559108 (self rhs: Core.Primitive.t_i16) : Core.Primitive.t_i16 = + wrapping_add_i16 self rhs + +let wrapping_sub189469152 (self rhs: Core.Primitive.t_i16) : Core.Primitive.t_i16 = + wrapping_sub_i16 self rhs + +let wrapping_neg860505723 (self: Core.Primitive.t_i16) : Core.Primitive.t_i16 = + wrapping_sub189469152 (Core.Convert.f_into #i16 + #Core.Primitive.t_i16 + #FStar.Tactics.Typeclasses.solve + 0s + <: + Core.Primitive.t_i16) + self + +let wrapping_abs229076826 (self: Core.Primitive.t_i16) : Core.Primitive.t_i16 = + if + is_negative477067241 (Core.Clone.f_clone #Core.Primitive.t_i16 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Primitive.t_i16) + then wrapping_neg860505723 self + else self + +let wrapping_add475006616 (self rhs: Core.Primitive.t_i32) : Core.Primitive.t_i32 = + wrapping_add_i32 self rhs + +let wrapping_sub298337071 (self rhs: Core.Primitive.t_i32) : Core.Primitive.t_i32 = + wrapping_sub_i32 self rhs + +let wrapping_neg636433078 (self: Core.Primitive.t_i32) : Core.Primitive.t_i32 = + wrapping_sub298337071 (Core.Convert.f_into #i32 + #Core.Primitive.t_i32 + #FStar.Tactics.Typeclasses.solve + 0l + <: + Core.Primitive.t_i32) + self + +let wrapping_abs729536875 (self: Core.Primitive.t_i32) : Core.Primitive.t_i32 = + if + is_negative1035644813 (Core.Clone.f_clone #Core.Primitive.t_i32 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Primitive.t_i32) + then wrapping_neg636433078 self + else self + +let wrapping_add590074241 (self rhs: Core.Primitive.t_i64) : Core.Primitive.t_i64 = + wrapping_add_i64 self rhs + +let wrapping_sub334584751 (self rhs: Core.Primitive.t_i64) : Core.Primitive.t_i64 = + wrapping_sub_i64 self rhs + +let wrapping_neg868282938 (self: Core.Primitive.t_i64) : Core.Primitive.t_i64 = + wrapping_sub334584751 (Core.Convert.f_into #i64 + #Core.Primitive.t_i64 + #FStar.Tactics.Typeclasses.solve + 0L + <: + Core.Primitive.t_i64) + self + +let wrapping_abs285829312 (self: Core.Primitive.t_i64) : Core.Primitive.t_i64 = + if + is_negative1066124578 (Core.Clone.f_clone #Core.Primitive.t_i64 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Primitive.t_i64) + then wrapping_neg868282938 self + else self + +let wrapping_add251385439 (self rhs: Core.Primitive.t_i128) : Core.Primitive.t_i128 = + wrapping_add_i128 self rhs + +let wrapping_sub681598071 (self rhs: Core.Primitive.t_i128) : Core.Primitive.t_i128 = + wrapping_sub_i128 self rhs + +let wrapping_neg446546984 (self: Core.Primitive.t_i128) : Core.Primitive.t_i128 = + wrapping_sub681598071 (Core.Convert.f_into #i128 + #Core.Primitive.t_i128 + #FStar.Tactics.Typeclasses.solve + (pub_i128 0) + <: + Core.Primitive.t_i128) + self + +let wrapping_abs281925696 (self: Core.Primitive.t_i128) : Core.Primitive.t_i128 = + if + is_negative221698470 (Core.Clone.f_clone #Core.Primitive.t_i128 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Primitive.t_i128) + then wrapping_neg446546984 self + else self + +let wrapping_add226040243 (self rhs: Core.Primitive.t_isize) : Core.Primitive.t_isize = + wrapping_add_isize self rhs + +let wrapping_sub698035192 (self rhs: Core.Primitive.t_isize) : Core.Primitive.t_isize = + wrapping_sub_isize self rhs + +let wrapping_neg912291768 (self: Core.Primitive.t_isize) : Core.Primitive.t_isize = + wrapping_sub698035192 (Core.Convert.f_into #isize + #Core.Primitive.t_isize + #FStar.Tactics.Typeclasses.solve + (isz 0) + <: + Core.Primitive.t_isize) + self + +let wrapping_abs347300819 (self: Core.Primitive.t_isize) : Core.Primitive.t_isize = + if + is_negative693446369 (Core.Clone.f_clone #Core.Primitive.t_isize + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Primitive.t_isize) + then wrapping_neg912291768 self + else self + +let checked_div508301931 (self rhs: Core.Primitive.t_u8) : Core.Option.t_Option Core.Primitive.t_u8 = + if + rhs =. + (Core.Convert.f_into #u8 #Core.Primitive.t_u8 #FStar.Tactics.Typeclasses.solve 0uy + <: + Core.Primitive.t_u8) + then Core.Option.Option_None <: Core.Option.t_Option Core.Primitive.t_u8 + else + Core.Option.Option_Some (unchecked_div_u8 self rhs) <: Core.Option.t_Option Core.Primitive.t_u8 + +let overflowing_add708890057 (self rhs: Core.Primitive.t_u8) : (Core.Primitive.t_u8 & bool) = + add_with_overflow_u8 self rhs + +let checked_div614920780 (self rhs: Core.Primitive.t_u16) + : Core.Option.t_Option Core.Primitive.t_u16 = + if + rhs =. + (Core.Convert.f_into #u16 #Core.Primitive.t_u16 #FStar.Tactics.Typeclasses.solve 0us + <: + Core.Primitive.t_u16) + then Core.Option.Option_None <: Core.Option.t_Option Core.Primitive.t_u16 + else + Core.Option.Option_Some (unchecked_div_u16 self rhs) + <: + Core.Option.t_Option Core.Primitive.t_u16 + +let overflowing_add1023344178 (self rhs: Core.Primitive.t_u16) : (Core.Primitive.t_u16 & bool) = + add_with_overflow_u16 self rhs + +let checked_div979383477 (self rhs: Core.Primitive.t_u32) + : Core.Option.t_Option Core.Primitive.t_u32 = + if + rhs =. + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve 0ul + <: + Core.Primitive.t_u32) + then Core.Option.Option_None <: Core.Option.t_Option Core.Primitive.t_u32 + else + Core.Option.Option_Some (unchecked_div_u32 self rhs) + <: + Core.Option.t_Option Core.Primitive.t_u32 + +let overflowing_add905744292 (self rhs: Core.Primitive.t_u32) : (Core.Primitive.t_u32 & bool) = + add_with_overflow_u32 self rhs + +let checked_div988689127 (self rhs: Core.Primitive.t_u64) + : Core.Option.t_Option Core.Primitive.t_u64 = + if + rhs =. + (Core.Convert.f_into #u64 #Core.Primitive.t_u64 #FStar.Tactics.Typeclasses.solve 0uL + <: + Core.Primitive.t_u64) + then Core.Option.Option_None <: Core.Option.t_Option Core.Primitive.t_u64 + else + Core.Option.Option_Some (unchecked_div_u64 self rhs) + <: + Core.Option.t_Option Core.Primitive.t_u64 + +let overflowing_add581983607 (self rhs: Core.Primitive.t_u64) : (Core.Primitive.t_u64 & bool) = + add_with_overflow_u64 self rhs + +let checked_div344106746 (self rhs: Core.Primitive.t_u128) + : Core.Option.t_Option Core.Primitive.t_u128 = + if + rhs =. + (Core.Convert.f_into #u128 #Core.Primitive.t_u128 #FStar.Tactics.Typeclasses.solve (pub_u128 0) + <: + Core.Primitive.t_u128) + then Core.Option.Option_None <: Core.Option.t_Option Core.Primitive.t_u128 + else + Core.Option.Option_Some (unchecked_div_u128 self rhs) + <: + Core.Option.t_Option Core.Primitive.t_u128 + +let overflowing_add458293681 (self rhs: Core.Primitive.t_u128) : (Core.Primitive.t_u128 & bool) = + add_with_overflow_u128 self rhs + +let checked_div80223906 (self rhs: Core.Primitive.t_usize) + : Core.Option.t_Option Core.Primitive.t_usize = + if + rhs =. + (Core.Convert.f_into #usize #Core.Primitive.t_usize #FStar.Tactics.Typeclasses.solve (sz 0) + <: + Core.Primitive.t_usize) + then Core.Option.Option_None <: Core.Option.t_Option Core.Primitive.t_usize + else + Core.Option.Option_Some (unchecked_div_usize self rhs) + <: + Core.Option.t_Option Core.Primitive.t_usize + +let overflowing_add682280407 (self rhs: Core.Primitive.t_usize) : (Core.Primitive.t_usize & bool) = + add_with_overflow_usize self rhs + +let abs945505614 (self: Core.Primitive.t_i8) : Core.Primitive.t_i8 = + if + is_negative350273175 (Core.Clone.f_clone #Core.Primitive.t_i8 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Primitive.t_i8) + then Core.Ops.Arith.f_neg #Core.Primitive.t_i8 #FStar.Tactics.Typeclasses.solve self + else self + +let abs581170970 (self: Core.Primitive.t_i16) : Core.Primitive.t_i16 = + if + is_negative477067241 (Core.Clone.f_clone #Core.Primitive.t_i16 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Primitive.t_i16) + then Core.Ops.Arith.f_neg #Core.Primitive.t_i16 #FStar.Tactics.Typeclasses.solve self + else self + +let abs590464694 (self: Core.Primitive.t_i32) : Core.Primitive.t_i32 = + if + is_negative1035644813 (Core.Clone.f_clone #Core.Primitive.t_i32 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Primitive.t_i32) + then Core.Ops.Arith.f_neg #Core.Primitive.t_i32 #FStar.Tactics.Typeclasses.solve self + else self + +let abs654781043 (self: Core.Primitive.t_i64) : Core.Primitive.t_i64 = + if + is_negative1066124578 (Core.Clone.f_clone #Core.Primitive.t_i64 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Primitive.t_i64) + then Core.Ops.Arith.f_neg #Core.Primitive.t_i64 #FStar.Tactics.Typeclasses.solve self + else self + +let abs204417539 (self: Core.Primitive.t_i128) : Core.Primitive.t_i128 = + if + is_negative221698470 (Core.Clone.f_clone #Core.Primitive.t_i128 + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Primitive.t_i128) + then Core.Ops.Arith.f_neg #Core.Primitive.t_i128 #FStar.Tactics.Typeclasses.solve self + else self + +let abs220926056 (self: Core.Primitive.t_isize) : Core.Primitive.t_isize = + if + is_negative693446369 (Core.Clone.f_clone #Core.Primitive.t_isize + #FStar.Tactics.Typeclasses.solve + self + <: + Core.Primitive.t_isize) + then Core.Ops.Arith.f_neg #Core.Primitive.t_isize #FStar.Tactics.Typeclasses.solve self + else self + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_12: Core.Convert.t_From Core.Primitive.t_u16 Core.Primitive.t_u8 = + { + f_from_pre = (fun (x: Core.Primitive.t_u8) -> true); + f_from_post = (fun (x: Core.Primitive.t_u8) (out: Core.Primitive.t_u16) -> true); + f_from + = + fun (x: Core.Primitive.t_u8) -> + Core.Primitive.C_u16 + (Core.Convert.f_into #Core.Base_interface.Int.t_U8 + #Core.Base_interface.Int.t_U16 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_u16 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_13: Core.Convert.t_From Core.Primitive.t_u32 Core.Primitive.t_u8 = + { + f_from_pre = (fun (x: Core.Primitive.t_u8) -> true); + f_from_post = (fun (x: Core.Primitive.t_u8) (out: Core.Primitive.t_u32) -> true); + f_from + = + fun (x: Core.Primitive.t_u8) -> + Core.Primitive.C_u32 + (Core.Convert.f_into #Core.Base_interface.Int.t_U8 + #Core.Base_interface.Int.t_U32 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_u32 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_14: Core.Convert.t_From Core.Primitive.t_u64 Core.Primitive.t_u8 = + { + f_from_pre = (fun (x: Core.Primitive.t_u8) -> true); + f_from_post = (fun (x: Core.Primitive.t_u8) (out: Core.Primitive.t_u64) -> true); + f_from + = + fun (x: Core.Primitive.t_u8) -> + Core.Primitive.C_u64 + (Core.Convert.f_into #Core.Base_interface.Int.t_U8 + #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_u64 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_15: Core.Convert.t_From Core.Primitive.t_u128 Core.Primitive.t_u8 = + { + f_from_pre = (fun (x: Core.Primitive.t_u8) -> true); + f_from_post = (fun (x: Core.Primitive.t_u8) (out: Core.Primitive.t_u128) -> true); + f_from + = + fun (x: Core.Primitive.t_u8) -> + Core.Primitive.C_u128 + (Core.Convert.f_into #Core.Base_interface.Int.t_U8 + #Core.Base_interface.Int.t_U128 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_u128 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_16: Core.Convert.t_From Core.Primitive.t_usize Core.Primitive.t_u8 = + { + f_from_pre = (fun (x: Core.Primitive.t_u8) -> true); + f_from_post = (fun (x: Core.Primitive.t_u8) (out: Core.Primitive.t_usize) -> true); + f_from + = + fun (x: Core.Primitive.t_u8) -> + Core.Primitive.C_usize + (Core.Convert.f_into #Core.Base_interface.Int.t_U8 + #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_usize + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_17: Core.Convert.t_From Core.Primitive.t_u8 Core.Primitive.t_u16 = + { + f_from_pre = (fun (x: Core.Primitive.t_u16) -> true); + f_from_post = (fun (x: Core.Primitive.t_u16) (out: Core.Primitive.t_u8) -> true); + f_from + = + fun (x: Core.Primitive.t_u16) -> + Core.Primitive.C_u8 + (Core.Convert.f_into #Core.Base_interface.Int.t_U16 + #Core.Base_interface.Int.t_U8 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_u8 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_18: Core.Convert.t_From Core.Primitive.t_u32 Core.Primitive.t_u16 = + { + f_from_pre = (fun (x: Core.Primitive.t_u16) -> true); + f_from_post = (fun (x: Core.Primitive.t_u16) (out: Core.Primitive.t_u32) -> true); + f_from + = + fun (x: Core.Primitive.t_u16) -> + Core.Primitive.C_u32 + (Core.Convert.f_into #Core.Base_interface.Int.t_U16 + #Core.Base_interface.Int.t_U32 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_u32 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_19: Core.Convert.t_From Core.Primitive.t_u64 Core.Primitive.t_u16 = + { + f_from_pre = (fun (x: Core.Primitive.t_u16) -> true); + f_from_post = (fun (x: Core.Primitive.t_u16) (out: Core.Primitive.t_u64) -> true); + f_from + = + fun (x: Core.Primitive.t_u16) -> + Core.Primitive.C_u64 + (Core.Convert.f_into #Core.Base_interface.Int.t_U16 + #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_u64 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_20: Core.Convert.t_From Core.Primitive.t_u128 Core.Primitive.t_u16 = + { + f_from_pre = (fun (x: Core.Primitive.t_u16) -> true); + f_from_post = (fun (x: Core.Primitive.t_u16) (out: Core.Primitive.t_u128) -> true); + f_from + = + fun (x: Core.Primitive.t_u16) -> + Core.Primitive.C_u128 + (Core.Convert.f_into #Core.Base_interface.Int.t_U16 + #Core.Base_interface.Int.t_U128 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_u128 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_21: Core.Convert.t_From Core.Primitive.t_usize Core.Primitive.t_u16 = + { + f_from_pre = (fun (x: Core.Primitive.t_u16) -> true); + f_from_post = (fun (x: Core.Primitive.t_u16) (out: Core.Primitive.t_usize) -> true); + f_from + = + fun (x: Core.Primitive.t_u16) -> + Core.Primitive.C_usize + (Core.Convert.f_into #Core.Base_interface.Int.t_U16 + #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_usize + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_22: Core.Convert.t_From Core.Primitive.t_u8 Core.Primitive.t_u32 = + { + f_from_pre = (fun (x: Core.Primitive.t_u32) -> true); + f_from_post = (fun (x: Core.Primitive.t_u32) (out: Core.Primitive.t_u8) -> true); + f_from + = + fun (x: Core.Primitive.t_u32) -> + Core.Primitive.C_u8 + (Core.Convert.f_into #Core.Base_interface.Int.t_U32 + #Core.Base_interface.Int.t_U8 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_u8 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_23: Core.Convert.t_From Core.Primitive.t_u16 Core.Primitive.t_u32 = + { + f_from_pre = (fun (x: Core.Primitive.t_u32) -> true); + f_from_post = (fun (x: Core.Primitive.t_u32) (out: Core.Primitive.t_u16) -> true); + f_from + = + fun (x: Core.Primitive.t_u32) -> + Core.Primitive.C_u16 + (Core.Convert.f_into #Core.Base_interface.Int.t_U32 + #Core.Base_interface.Int.t_U16 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_u16 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_24: Core.Convert.t_From Core.Primitive.t_u64 Core.Primitive.t_u32 = + { + f_from_pre = (fun (x: Core.Primitive.t_u32) -> true); + f_from_post = (fun (x: Core.Primitive.t_u32) (out: Core.Primitive.t_u64) -> true); + f_from + = + fun (x: Core.Primitive.t_u32) -> + Core.Primitive.C_u64 + (Core.Convert.f_into #Core.Base_interface.Int.t_U32 + #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_u64 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_25: Core.Convert.t_From Core.Primitive.t_u128 Core.Primitive.t_u32 = + { + f_from_pre = (fun (x: Core.Primitive.t_u32) -> true); + f_from_post = (fun (x: Core.Primitive.t_u32) (out: Core.Primitive.t_u128) -> true); + f_from + = + fun (x: Core.Primitive.t_u32) -> + Core.Primitive.C_u128 + (Core.Convert.f_into #Core.Base_interface.Int.t_U32 + #Core.Base_interface.Int.t_U128 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_u128 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_26: Core.Convert.t_From Core.Primitive.t_usize Core.Primitive.t_u32 = + { + f_from_pre = (fun (x: Core.Primitive.t_u32) -> true); + f_from_post = (fun (x: Core.Primitive.t_u32) (out: Core.Primitive.t_usize) -> true); + f_from + = + fun (x: Core.Primitive.t_u32) -> + Core.Primitive.C_usize + (Core.Convert.f_into #Core.Base_interface.Int.t_U32 + #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_usize + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_27: Core.Convert.t_From Core.Primitive.t_u8 Core.Primitive.t_u64 = + { + f_from_pre = (fun (x: Core.Primitive.t_u64) -> true); + f_from_post = (fun (x: Core.Primitive.t_u64) (out: Core.Primitive.t_u8) -> true); + f_from + = + fun (x: Core.Primitive.t_u64) -> + Core.Primitive.C_u8 + (Core.Convert.f_into #Core.Base_interface.Int.t_U64 + #Core.Base_interface.Int.t_U8 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_u8 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_28: Core.Convert.t_From Core.Primitive.t_u16 Core.Primitive.t_u64 = + { + f_from_pre = (fun (x: Core.Primitive.t_u64) -> true); + f_from_post = (fun (x: Core.Primitive.t_u64) (out: Core.Primitive.t_u16) -> true); + f_from + = + fun (x: Core.Primitive.t_u64) -> + Core.Primitive.C_u16 + (Core.Convert.f_into #Core.Base_interface.Int.t_U64 + #Core.Base_interface.Int.t_U16 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_u16 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_29: Core.Convert.t_From Core.Primitive.t_u32 Core.Primitive.t_u64 = + { + f_from_pre = (fun (x: Core.Primitive.t_u64) -> true); + f_from_post = (fun (x: Core.Primitive.t_u64) (out: Core.Primitive.t_u32) -> true); + f_from + = + fun (x: Core.Primitive.t_u64) -> + Core.Primitive.C_u32 + (Core.Convert.f_into #Core.Base_interface.Int.t_U64 + #Core.Base_interface.Int.t_U32 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_u32 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_30: Core.Convert.t_From Core.Primitive.t_u128 Core.Primitive.t_u64 = + { + f_from_pre = (fun (x: Core.Primitive.t_u64) -> true); + f_from_post = (fun (x: Core.Primitive.t_u64) (out: Core.Primitive.t_u128) -> true); + f_from + = + fun (x: Core.Primitive.t_u64) -> + Core.Primitive.C_u128 + (Core.Convert.f_into #Core.Base_interface.Int.t_U64 + #Core.Base_interface.Int.t_U128 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_u128 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_32: Core.Convert.t_From Core.Primitive.t_u8 Core.Primitive.t_u128 = + { + f_from_pre = (fun (x: Core.Primitive.t_u128) -> true); + f_from_post = (fun (x: Core.Primitive.t_u128) (out: Core.Primitive.t_u8) -> true); + f_from + = + fun (x: Core.Primitive.t_u128) -> + Core.Primitive.C_u8 + (Core.Convert.f_into #Core.Base_interface.Int.t_U128 + #Core.Base_interface.Int.t_U8 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_u8 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_33: Core.Convert.t_From Core.Primitive.t_u16 Core.Primitive.t_u128 = + { + f_from_pre = (fun (x: Core.Primitive.t_u128) -> true); + f_from_post = (fun (x: Core.Primitive.t_u128) (out: Core.Primitive.t_u16) -> true); + f_from + = + fun (x: Core.Primitive.t_u128) -> + Core.Primitive.C_u16 + (Core.Convert.f_into #Core.Base_interface.Int.t_U128 + #Core.Base_interface.Int.t_U16 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_u16 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_34: Core.Convert.t_From Core.Primitive.t_u32 Core.Primitive.t_u128 = + { + f_from_pre = (fun (x: Core.Primitive.t_u128) -> true); + f_from_post = (fun (x: Core.Primitive.t_u128) (out: Core.Primitive.t_u32) -> true); + f_from + = + fun (x: Core.Primitive.t_u128) -> + Core.Primitive.C_u32 + (Core.Convert.f_into #Core.Base_interface.Int.t_U128 + #Core.Base_interface.Int.t_U32 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_u32 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_35: Core.Convert.t_From Core.Primitive.t_u64 Core.Primitive.t_u128 = + { + f_from_pre = (fun (x: Core.Primitive.t_u128) -> true); + f_from_post = (fun (x: Core.Primitive.t_u128) (out: Core.Primitive.t_u64) -> true); + f_from + = + fun (x: Core.Primitive.t_u128) -> + Core.Primitive.C_u64 + (Core.Convert.f_into #Core.Base_interface.Int.t_U128 + #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_u64 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_36: Core.Convert.t_From Core.Primitive.t_usize Core.Primitive.t_u128 = + { + f_from_pre = (fun (x: Core.Primitive.t_u128) -> true); + f_from_post = (fun (x: Core.Primitive.t_u128) (out: Core.Primitive.t_usize) -> true); + f_from + = + fun (x: Core.Primitive.t_u128) -> + Core.Primitive.C_usize + (Core.Convert.f_into #Core.Base_interface.Int.t_U128 + #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_usize + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_37: Core.Convert.t_From Core.Primitive.t_u8 Core.Primitive.t_usize = + { + f_from_pre = (fun (x: Core.Primitive.t_usize) -> true); + f_from_post = (fun (x: Core.Primitive.t_usize) (out: Core.Primitive.t_u8) -> true); + f_from + = + fun (x: Core.Primitive.t_usize) -> + Core.Primitive.C_u8 + (Core.Convert.f_into #Core.Base_interface.Int.t_U64 + #Core.Base_interface.Int.t_U8 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_u8 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_38: Core.Convert.t_From Core.Primitive.t_u16 Core.Primitive.t_usize = + { + f_from_pre = (fun (x: Core.Primitive.t_usize) -> true); + f_from_post = (fun (x: Core.Primitive.t_usize) (out: Core.Primitive.t_u16) -> true); + f_from + = + fun (x: Core.Primitive.t_usize) -> + Core.Primitive.C_u16 + (Core.Convert.f_into #Core.Base_interface.Int.t_U64 + #Core.Base_interface.Int.t_U16 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_u16 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_39: Core.Convert.t_From Core.Primitive.t_u32 Core.Primitive.t_usize = + { + f_from_pre = (fun (x: Core.Primitive.t_usize) -> true); + f_from_post = (fun (x: Core.Primitive.t_usize) (out: Core.Primitive.t_u32) -> true); + f_from + = + fun (x: Core.Primitive.t_usize) -> + Core.Primitive.C_u32 + (Core.Convert.f_into #Core.Base_interface.Int.t_U64 + #Core.Base_interface.Int.t_U32 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_u32 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_41: Core.Convert.t_From Core.Primitive.t_u128 Core.Primitive.t_usize = + { + f_from_pre = (fun (x: Core.Primitive.t_usize) -> true); + f_from_post = (fun (x: Core.Primitive.t_usize) (out: Core.Primitive.t_u128) -> true); + f_from + = + fun (x: Core.Primitive.t_usize) -> + Core.Primitive.C_u128 + (Core.Convert.f_into #Core.Base_interface.Int.t_U64 + #Core.Base_interface.Int.t_U128 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0) + <: + Core.Primitive.t_u128 + } + +let unchecked_div_i128 (x y: Core.Primitive.t_i128) : Core.Primitive.t_i128 = + Core.Primitive.C_i128 + ({ + Core.Base_interface.Int.f_v + = + Core.Base.Z.z_div (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I128 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0 + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I128 + #FStar.Tactics.Typeclasses.solve + y.Core.Primitive._0 + <: + Core.Base.Spec.Z.t_Z) + } + <: + Core.Base_interface.Int.t_I128) + <: + Core.Primitive.t_i128 + +let unchecked_div_i16 (x y: Core.Primitive.t_i16) : Core.Primitive.t_i16 = + Core.Primitive.C_i16 + ({ + Core.Base_interface.Int.f_v + = + Core.Base.Z.z_div (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I16 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0 + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I16 + #FStar.Tactics.Typeclasses.solve + y.Core.Primitive._0 + <: + Core.Base.Spec.Z.t_Z) + } + <: + Core.Base_interface.Int.t_I16) + <: + Core.Primitive.t_i16 + +let unchecked_div_i32 (x y: Core.Primitive.t_i32) : Core.Primitive.t_i32 = + Core.Primitive.C_i32 + ({ + Core.Base_interface.Int.f_v + = + Core.Base.Z.z_div (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I32 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0 + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I32 + #FStar.Tactics.Typeclasses.solve + y.Core.Primitive._0 + <: + Core.Base.Spec.Z.t_Z) + } + <: + Core.Base_interface.Int.t_I32) + <: + Core.Primitive.t_i32 + +let unchecked_div_i64 (x y: Core.Primitive.t_i64) : Core.Primitive.t_i64 = + Core.Primitive.C_i64 + ({ + Core.Base_interface.Int.f_v + = + Core.Base.Z.z_div (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I64 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0 + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I64 + #FStar.Tactics.Typeclasses.solve + y.Core.Primitive._0 + <: + Core.Base.Spec.Z.t_Z) + } + <: + Core.Base_interface.Int.t_I64) + <: + Core.Primitive.t_i64 + +let unchecked_div_i8 (x y: Core.Primitive.t_i8) : Core.Primitive.t_i8 = + Core.Primitive.C_i8 + ({ + Core.Base_interface.Int.f_v + = + Core.Base.Z.z_div (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I8 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0 + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I8 + #FStar.Tactics.Typeclasses.solve + y.Core.Primitive._0 + <: + Core.Base.Spec.Z.t_Z) + } + <: + Core.Base_interface.Int.t_I8) + <: + Core.Primitive.t_i8 + +let unchecked_div_isize (x y: Core.Primitive.t_isize) : Core.Primitive.t_isize = + Core.Primitive.C_isize + ({ + Core.Base_interface.Int.f_v + = + Core.Base.Z.z_div (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I64 + #FStar.Tactics.Typeclasses.solve + x.Core.Primitive._0 + <: + Core.Base.Spec.Z.t_Z) + (Core.Base_interface.Coerce.f_lift #Core.Base_interface.Int.t_I64 + #FStar.Tactics.Typeclasses.solve + y.Core.Primitive._0 + <: + Core.Base.Spec.Z.t_Z) + } + <: + Core.Base_interface.Int.t_I64) + <: + Core.Primitive.t_isize + +let wrapping_add_u128 (a b: Core.Primitive.t_u128) : Core.Primitive.t_u128 = + Core.Primitive.C_u128 (a.Core.Primitive._0 +! b.Core.Primitive._0) <: Core.Primitive.t_u128 + +let wrapping_add_u16 (a b: Core.Primitive.t_u16) : Core.Primitive.t_u16 = + Core.Primitive.C_u16 (a.Core.Primitive._0 +! b.Core.Primitive._0) <: Core.Primitive.t_u16 + +let wrapping_add_u32 (a b: Core.Primitive.t_u32) : Core.Primitive.t_u32 = + Core.Primitive.C_u32 (a.Core.Primitive._0 +! b.Core.Primitive._0) <: Core.Primitive.t_u32 + +let wrapping_add_u64 (a b: Core.Primitive.t_u64) : Core.Primitive.t_u64 = + Core.Primitive.C_u64 (a.Core.Primitive._0 +! b.Core.Primitive._0) <: Core.Primitive.t_u64 + +let wrapping_add_u8 (a b: Core.Primitive.t_u8) : Core.Primitive.t_u8 = + Core.Primitive.C_u8 (a.Core.Primitive._0 +! b.Core.Primitive._0) <: Core.Primitive.t_u8 + +let wrapping_add_usize (a b: Core.Primitive.t_usize) : Core.Primitive.t_usize = + Core.Primitive.C_usize (a.Core.Primitive._0 +! b.Core.Primitive._0) <: Core.Primitive.t_usize + +let wrapping_mul_i128 (a b: Core.Primitive.t_i128) : Core.Primitive.t_i128 = + Core.Primitive.C_i128 (a.Core.Primitive._0 *! b.Core.Primitive._0) <: Core.Primitive.t_i128 + +let wrapping_mul_i16 (a b: Core.Primitive.t_i16) : Core.Primitive.t_i16 = + Core.Primitive.C_i16 (a.Core.Primitive._0 *! b.Core.Primitive._0) <: Core.Primitive.t_i16 + +let wrapping_mul_i32 (a b: Core.Primitive.t_i32) : Core.Primitive.t_i32 = + Core.Primitive.C_i32 (a.Core.Primitive._0 *! b.Core.Primitive._0) <: Core.Primitive.t_i32 + +let wrapping_mul_i64 (a b: Core.Primitive.t_i64) : Core.Primitive.t_i64 = + Core.Primitive.C_i64 (a.Core.Primitive._0 *! b.Core.Primitive._0) <: Core.Primitive.t_i64 + +let wrapping_mul_i8 (a b: Core.Primitive.t_i8) : Core.Primitive.t_i8 = + Core.Primitive.C_i8 (a.Core.Primitive._0 *! b.Core.Primitive._0) <: Core.Primitive.t_i8 + +let wrapping_mul_isize (a b: Core.Primitive.t_isize) : Core.Primitive.t_isize = + Core.Primitive.C_isize (a.Core.Primitive._0 *! b.Core.Primitive._0) <: Core.Primitive.t_isize + +let wrapping_mul_u128 (a b: Core.Primitive.t_u128) : Core.Primitive.t_u128 = + Core.Primitive.C_u128 (a.Core.Primitive._0 *! b.Core.Primitive._0) <: Core.Primitive.t_u128 + +let wrapping_mul_u16 (a b: Core.Primitive.t_u16) : Core.Primitive.t_u16 = + Core.Primitive.C_u16 (a.Core.Primitive._0 *! b.Core.Primitive._0) <: Core.Primitive.t_u16 + +let wrapping_mul_u32 (a b: Core.Primitive.t_u32) : Core.Primitive.t_u32 = + Core.Primitive.C_u32 (a.Core.Primitive._0 *! b.Core.Primitive._0) <: Core.Primitive.t_u32 + +let wrapping_mul_u64 (a b: Core.Primitive.t_u64) : Core.Primitive.t_u64 = + Core.Primitive.C_u64 (a.Core.Primitive._0 *! b.Core.Primitive._0) <: Core.Primitive.t_u64 + +let wrapping_mul_u8 (a b: Core.Primitive.t_u8) : Core.Primitive.t_u8 = + Core.Primitive.C_u8 (a.Core.Primitive._0 *! b.Core.Primitive._0) <: Core.Primitive.t_u8 + +let wrapping_mul_usize (a b: Core.Primitive.t_usize) : Core.Primitive.t_usize = + Core.Primitive.C_usize (a.Core.Primitive._0 *! b.Core.Primitive._0) <: Core.Primitive.t_usize + +let wrapping_add480603777 (self rhs: Core.Primitive.t_u8) : Core.Primitive.t_u8 = + wrapping_add_u8 self rhs + +let wrapping_mul885216284 (self rhs: Core.Primitive.t_u8) : Core.Primitive.t_u8 = + wrapping_mul_u8 self rhs + +let wrapping_add124432709 (self rhs: Core.Primitive.t_u16) : Core.Primitive.t_u16 = + wrapping_add_u16 self rhs + +let wrapping_mul14465189 (self rhs: Core.Primitive.t_u16) : Core.Primitive.t_u16 = + wrapping_mul_u16 self rhs + +let wrapping_add1049665857 (self rhs: Core.Primitive.t_u32) : Core.Primitive.t_u32 = + wrapping_add_u32 self rhs + +let wrapping_mul203346768 (self rhs: Core.Primitive.t_u32) : Core.Primitive.t_u32 = + wrapping_mul_u32 self rhs + +let wrapping_add865565639 (self rhs: Core.Primitive.t_u64) : Core.Primitive.t_u64 = + wrapping_add_u64 self rhs + +let wrapping_mul742978873 (self rhs: Core.Primitive.t_u64) : Core.Primitive.t_u64 = + wrapping_mul_u64 self rhs + +let wrapping_add40844100 (self rhs: Core.Primitive.t_u128) : Core.Primitive.t_u128 = + wrapping_add_u128 self rhs + +let wrapping_mul294115024 (self rhs: Core.Primitive.t_u128) : Core.Primitive.t_u128 = + wrapping_mul_u128 self rhs + +let wrapping_add427637036 (self rhs: Core.Primitive.t_usize) : Core.Primitive.t_usize = + wrapping_add_usize self rhs + +let wrapping_mul680896953 (self rhs: Core.Primitive.t_usize) : Core.Primitive.t_usize = + wrapping_mul_usize self rhs + +let wrapping_sub_u128 (a b: Core.Primitive.t_u128) : Core.Primitive.t_u128 = + Core.Primitive.C_u128 (a.Core.Primitive._0 -! b.Core.Primitive._0) <: Core.Primitive.t_u128 + +let wrapping_sub_u16 (a b: Core.Primitive.t_u16) : Core.Primitive.t_u16 = + Core.Primitive.C_u16 (a.Core.Primitive._0 -! b.Core.Primitive._0) <: Core.Primitive.t_u16 + +let wrapping_sub_u32 (a b: Core.Primitive.t_u32) : Core.Primitive.t_u32 = + Core.Primitive.C_u32 (a.Core.Primitive._0 -! b.Core.Primitive._0) <: Core.Primitive.t_u32 + +let wrapping_sub_u64 (a b: Core.Primitive.t_u64) : Core.Primitive.t_u64 = + Core.Primitive.C_u64 (a.Core.Primitive._0 -! b.Core.Primitive._0) <: Core.Primitive.t_u64 + +let wrapping_sub_u8 (a b: Core.Primitive.t_u8) : Core.Primitive.t_u8 = + Core.Primitive.C_u8 (a.Core.Primitive._0 -! b.Core.Primitive._0) <: Core.Primitive.t_u8 + +let wrapping_sub_usize (a b: Core.Primitive.t_usize) : Core.Primitive.t_usize = + Core.Primitive.C_usize (a.Core.Primitive._0 -! b.Core.Primitive._0) <: Core.Primitive.t_usize + +let wrapping_sub403906422 (self rhs: Core.Primitive.t_u8) : Core.Primitive.t_u8 = + wrapping_sub_u8 self rhs + +let wrapping_neg123212788 (self: Core.Primitive.t_u8) : Core.Primitive.t_u8 = + wrapping_sub403906422 (Core.Primitive.C_u8 + (Core.Base_interface.Int.f_ZERO #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U8) + <: + Core.Primitive.t_u8) + self + +let wrapping_sub811251034 (self rhs: Core.Primitive.t_u16) : Core.Primitive.t_u16 = + wrapping_sub_u16 self rhs + +let wrapping_neg128555595 (self: Core.Primitive.t_u16) : Core.Primitive.t_u16 = + wrapping_sub811251034 (Core.Primitive.C_u16 + (Core.Base_interface.Int.f_ZERO #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U16) + <: + Core.Primitive.t_u16) + self + +let wrapping_sub708953500 (self rhs: Core.Primitive.t_u32) : Core.Primitive.t_u32 = + wrapping_sub_u32 self rhs + +let wrapping_neg328220773 (self: Core.Primitive.t_u32) : Core.Primitive.t_u32 = + wrapping_sub708953500 (Core.Primitive.C_u32 + (Core.Base_interface.Int.f_ZERO #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U32) + <: + Core.Primitive.t_u32) + self + +let wrapping_sub762520851 (self rhs: Core.Primitive.t_u64) : Core.Primitive.t_u64 = + wrapping_sub_u64 self rhs + +let wrapping_neg617136337 (self: Core.Primitive.t_u64) : Core.Primitive.t_u64 = + wrapping_sub762520851 (Core.Primitive.C_u64 + (Core.Base_interface.Int.f_ZERO #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U64) + <: + Core.Primitive.t_u64) + self + +let wrapping_sub409310259 (self rhs: Core.Primitive.t_u128) : Core.Primitive.t_u128 = + wrapping_sub_u128 self rhs + +let wrapping_neg729451428 (self: Core.Primitive.t_u128) : Core.Primitive.t_u128 = + wrapping_sub409310259 (Core.Primitive.C_u128 + (Core.Base_interface.Int.f_ZERO #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U128) + <: + Core.Primitive.t_u128) + self + +let wrapping_sub813101882 (self rhs: Core.Primitive.t_usize) : Core.Primitive.t_usize = + wrapping_sub_usize self rhs + +let wrapping_neg342773446 (self: Core.Primitive.t_usize) : Core.Primitive.t_usize = + wrapping_sub813101882 (Core.Primitive.C_usize + (Core.Base_interface.Int.f_ZERO #FStar.Tactics.Typeclasses.solve + <: + Core.Base_interface.Int.t_U64) + <: + Core.Primitive.t_usize) + self + +let wrapping_div660080892 (self rhs: Core.Primitive.t_u8) : Core.Primitive.t_u8 = self /! rhs + +let wrapping_div_euclid481233436 (self rhs: Core.Primitive.t_u8) : Core.Primitive.t_u8 = self /! rhs + +let wrapping_div366977334 (self rhs: Core.Primitive.t_u16) : Core.Primitive.t_u16 = self /! rhs + +let wrapping_div_euclid22267888 (self rhs: Core.Primitive.t_u16) : Core.Primitive.t_u16 = + self /! rhs + +let wrapping_div931150450 (self rhs: Core.Primitive.t_u32) : Core.Primitive.t_u32 = self /! rhs + +let wrapping_div_euclid606291997 (self rhs: Core.Primitive.t_u32) : Core.Primitive.t_u32 = + self /! rhs + +let wrapping_div168427046 (self rhs: Core.Primitive.t_u64) : Core.Primitive.t_u64 = self /! rhs + +let wrapping_div_euclid321252086 (self rhs: Core.Primitive.t_u64) : Core.Primitive.t_u64 = + self /! rhs + +let wrapping_div692427683 (self rhs: Core.Primitive.t_u128) : Core.Primitive.t_u128 = self /! rhs + +let wrapping_div_euclid926334515 (self rhs: Core.Primitive.t_u128) : Core.Primitive.t_u128 = + self /! rhs + +let wrapping_div905768546 (self rhs: Core.Primitive.t_usize) : Core.Primitive.t_usize = self /! rhs + +let wrapping_div_euclid90317722 (self rhs: Core.Primitive.t_usize) : Core.Primitive.t_usize = + self /! rhs + +let wrapping_rem984569721 (self rhs: Core.Primitive.t_u8) : Core.Primitive.t_u8 = self %! rhs + +let wrapping_rem_euclid946579345 (self rhs: Core.Primitive.t_u8) : Core.Primitive.t_u8 = self %! rhs + +let wrapping_rem378598035 (self rhs: Core.Primitive.t_u16) : Core.Primitive.t_u16 = self %! rhs + +let wrapping_rem_euclid602402638 (self rhs: Core.Primitive.t_u16) : Core.Primitive.t_u16 = + self %! rhs + +let wrapping_rem292009099 (self rhs: Core.Primitive.t_u32) : Core.Primitive.t_u32 = self %! rhs + +let wrapping_rem_euclid1020271291 (self rhs: Core.Primitive.t_u32) : Core.Primitive.t_u32 = + self %! rhs + +let wrapping_rem390602260 (self rhs: Core.Primitive.t_u64) : Core.Primitive.t_u64 = self %! rhs + +let wrapping_rem_euclid839264546 (self rhs: Core.Primitive.t_u64) : Core.Primitive.t_u64 = + self %! rhs + +let wrapping_rem332379920 (self rhs: Core.Primitive.t_u128) : Core.Primitive.t_u128 = self %! rhs + +let wrapping_rem_euclid646122423 (self rhs: Core.Primitive.t_u128) : Core.Primitive.t_u128 = + self %! rhs + +let wrapping_rem333089373 (self rhs: Core.Primitive.t_usize) : Core.Primitive.t_usize = self %! rhs + +let wrapping_rem_euclid769656504 (self rhs: Core.Primitive.t_usize) : Core.Primitive.t_usize = + self %! rhs + +let bswap_u8 (x: Core.Primitive.t_u8) : Core.Primitive.t_u8 = + let (count: Core.Primitive.t_u8):Core.Primitive.t_u8 = + Core.Convert.f_into #u8 #Core.Primitive.t_u8 #FStar.Tactics.Typeclasses.solve 0uy + in + let count:Core.Primitive.t_u8 = + Rust_primitives.Hax.Folds.fold_range 0ul + (Core.Convert.f_into #Core.Primitive.t_u32 + #u32 + #FStar.Tactics.Typeclasses.solve + v_BITS690311813 + <: + u32) + (fun count temp_1_ -> + let count:Core.Primitive.t_u8 = count in + let _:u32 = temp_1_ in + true) + count + (fun count i -> + let count:Core.Primitive.t_u8 = count in + let i:u32 = i in + let (low_bit: Core.Primitive.t_u8):Core.Primitive.t_u8 = + Core.Convert.f_into #Core.Primitive.t_u8 + #Core.Primitive.t_u8 + #FStar.Tactics.Typeclasses.solve + (((Core.Clone.f_clone #Core.Primitive.t_u8 #FStar.Tactics.Typeclasses.solve x + <: + Core.Primitive.t_u8) >>! + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve i + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u8) &. + (Core.Convert.f_into #u8 #Core.Primitive.t_u8 #FStar.Tactics.Typeclasses.solve 1uy + <: + Core.Primitive.t_u8) + <: + Core.Primitive.t_u8) + in + let count:Core.Primitive.t_u8 = + (count < + let count:Core.Primitive.t_u32 = count in + let _:u32 = temp_1_ in + true) + count + (fun count i -> + let count:Core.Primitive.t_u32 = count in + let i:u32 = i in + count +! + (Core.Convert.f_into #Core.Primitive.t_u8 + #Core.Primitive.t_u32 + #FStar.Tactics.Typeclasses.solve + (((Core.Clone.f_clone #Core.Primitive.t_u8 #FStar.Tactics.Typeclasses.solve x + <: + Core.Primitive.t_u8) >>! + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve i + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u8) &. + (Core.Convert.f_into #u8 #Core.Primitive.t_u8 #FStar.Tactics.Typeclasses.solve 1uy + <: + Core.Primitive.t_u8) + <: + Core.Primitive.t_u8) + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u32) + in + count + +let cttz_u8 (x: Core.Primitive.t_u8) : Core.Primitive.t_u32 = + let (count: Core.Primitive.t_u32):Core.Primitive.t_u32 = + Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve 0ul + in + let done:bool = false in + let count, done:(Core.Primitive.t_u32 & bool) = + Rust_primitives.Hax.Folds.fold_range 0ul + (Core.Convert.f_into #Core.Primitive.t_u32 + #u32 + #FStar.Tactics.Typeclasses.solve + v_BITS690311813 + <: + u32) + (fun temp_0_ temp_1_ -> + let count, done:(Core.Primitive.t_u32 & bool) = temp_0_ in + let _:u32 = temp_1_ in + true) + (count, done <: (Core.Primitive.t_u32 & bool)) + (fun temp_0_ i -> + let count, done:(Core.Primitive.t_u32 & bool) = temp_0_ in + let i:u32 = i in + let (low_bit: Core.Primitive.t_u32):Core.Primitive.t_u32 = + Core.Convert.f_into #Core.Primitive.t_u8 + #Core.Primitive.t_u32 + #FStar.Tactics.Typeclasses.solve + (((Core.Clone.f_clone #Core.Primitive.t_u8 #FStar.Tactics.Typeclasses.solve x + <: + Core.Primitive.t_u8) >>! + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve i + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u8) &. + (Core.Convert.f_into #u8 #Core.Primitive.t_u8 #FStar.Tactics.Typeclasses.solve 1uy + <: + Core.Primitive.t_u8) + <: + Core.Primitive.t_u8) + in + if + low_bit =. + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve 1ul + <: + Core.Primitive.t_u32) || + done + then + let done:bool = true in + count, done <: (Core.Primitive.t_u32 & bool) + else + let count:Core.Primitive.t_u32 = + count +! + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve 1ul + <: + Core.Primitive.t_u32) + in + count, done <: (Core.Primitive.t_u32 & bool)) + in + count + +let count_ones202509899 (self: Core.Primitive.t_u8) : Core.Primitive.t_u32 = ctpop_u8 self + +let swap_bytes657156997 (self: Core.Primitive.t_u8) : Core.Primitive.t_u8 = + Core.Convert.f_into #Core.Primitive.t_u8 + #Core.Primitive.t_u8 + #FStar.Tactics.Typeclasses.solve + (bswap_u8 self <: Core.Primitive.t_u8) + +let from_be746282521 (x: Core.Primitive.t_u8) : Core.Primitive.t_u8 = swap_bytes657156997 x + +let to_be972448780 (self: Core.Primitive.t_u8) : Core.Primitive.t_u8 = swap_bytes657156997 self + +let trailing_zeros572929871 (self: Core.Primitive.t_u8) : Core.Primitive.t_u32 = cttz_u8 self + +let bswap_u16 (x: Core.Primitive.t_u16) : Core.Primitive.t_u16 = + let (count: Core.Primitive.t_u16):Core.Primitive.t_u16 = + Core.Convert.f_into #u16 #Core.Primitive.t_u16 #FStar.Tactics.Typeclasses.solve 0us + in + let count:Core.Primitive.t_u16 = + Rust_primitives.Hax.Folds.fold_range 0ul + (Core.Convert.f_into #Core.Primitive.t_u32 + #u32 + #FStar.Tactics.Typeclasses.solve + v_BITS277333551 + <: + u32) + (fun count temp_1_ -> + let count:Core.Primitive.t_u16 = count in + let _:u32 = temp_1_ in + true) + count + (fun count i -> + let count:Core.Primitive.t_u16 = count in + let i:u32 = i in + let (low_bit: Core.Primitive.t_u16):Core.Primitive.t_u16 = + Core.Convert.f_into #Core.Primitive.t_u16 + #Core.Primitive.t_u16 + #FStar.Tactics.Typeclasses.solve + (((Core.Clone.f_clone #Core.Primitive.t_u16 #FStar.Tactics.Typeclasses.solve x + <: + Core.Primitive.t_u16) >>! + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve i + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u16) &. + (Core.Convert.f_into #u16 #Core.Primitive.t_u16 #FStar.Tactics.Typeclasses.solve 1us + <: + Core.Primitive.t_u16) + <: + Core.Primitive.t_u16) + in + let count:Core.Primitive.t_u16 = + (count < + let count:Core.Primitive.t_u32 = count in + let _:u32 = temp_1_ in + true) + count + (fun count i -> + let count:Core.Primitive.t_u32 = count in + let i:u32 = i in + count +! + (Core.Convert.f_into #Core.Primitive.t_u16 + #Core.Primitive.t_u32 + #FStar.Tactics.Typeclasses.solve + (((Core.Clone.f_clone #Core.Primitive.t_u16 #FStar.Tactics.Typeclasses.solve x + <: + Core.Primitive.t_u16) >>! + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve i + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u16) &. + (Core.Convert.f_into #u16 #Core.Primitive.t_u16 #FStar.Tactics.Typeclasses.solve 1us + <: + Core.Primitive.t_u16) + <: + Core.Primitive.t_u16) + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u32) + in + count + +let cttz_u16 (x: Core.Primitive.t_u16) : Core.Primitive.t_u32 = + let (count: Core.Primitive.t_u32):Core.Primitive.t_u32 = + Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve 0ul + in + let done:bool = false in + let count, done:(Core.Primitive.t_u32 & bool) = + Rust_primitives.Hax.Folds.fold_range 0ul + (Core.Convert.f_into #Core.Primitive.t_u32 + #u32 + #FStar.Tactics.Typeclasses.solve + v_BITS277333551 + <: + u32) + (fun temp_0_ temp_1_ -> + let count, done:(Core.Primitive.t_u32 & bool) = temp_0_ in + let _:u32 = temp_1_ in + true) + (count, done <: (Core.Primitive.t_u32 & bool)) + (fun temp_0_ i -> + let count, done:(Core.Primitive.t_u32 & bool) = temp_0_ in + let i:u32 = i in + let (low_bit: Core.Primitive.t_u32):Core.Primitive.t_u32 = + Core.Convert.f_into #Core.Primitive.t_u16 + #Core.Primitive.t_u32 + #FStar.Tactics.Typeclasses.solve + (((Core.Clone.f_clone #Core.Primitive.t_u16 #FStar.Tactics.Typeclasses.solve x + <: + Core.Primitive.t_u16) >>! + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve i + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u16) &. + (Core.Convert.f_into #u16 #Core.Primitive.t_u16 #FStar.Tactics.Typeclasses.solve 1us + <: + Core.Primitive.t_u16) + <: + Core.Primitive.t_u16) + in + if + low_bit =. + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve 1ul + <: + Core.Primitive.t_u32) || + done + then + let done:bool = true in + count, done <: (Core.Primitive.t_u32 & bool) + else + let count:Core.Primitive.t_u32 = + count +! + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve 1ul + <: + Core.Primitive.t_u32) + in + count, done <: (Core.Primitive.t_u32 & bool)) + in + count + +let count_ones91875752 (self: Core.Primitive.t_u16) : Core.Primitive.t_u32 = ctpop_u16 self + +let swap_bytes926722059 (self: Core.Primitive.t_u16) : Core.Primitive.t_u16 = + Core.Convert.f_into #Core.Primitive.t_u16 + #Core.Primitive.t_u16 + #FStar.Tactics.Typeclasses.solve + (bswap_u16 self <: Core.Primitive.t_u16) + +let from_be510959665 (x: Core.Primitive.t_u16) : Core.Primitive.t_u16 = swap_bytes926722059 x + +let to_be551590602 (self: Core.Primitive.t_u16) : Core.Primitive.t_u16 = swap_bytes926722059 self + +let trailing_zeros421474733 (self: Core.Primitive.t_u16) : Core.Primitive.t_u32 = cttz_u16 self + +let bswap_u32 (x: Core.Primitive.t_u32) : Core.Primitive.t_u32 = + let (count: Core.Primitive.t_u32):Core.Primitive.t_u32 = + Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve 0ul + in + let count:Core.Primitive.t_u32 = + Rust_primitives.Hax.Folds.fold_range 0ul + (Core.Convert.f_into #Core.Primitive.t_u32 + #u32 + #FStar.Tactics.Typeclasses.solve + v_BITS473478051 + <: + u32) + (fun count temp_1_ -> + let count:Core.Primitive.t_u32 = count in + let _:u32 = temp_1_ in + true) + count + (fun count i -> + let count:Core.Primitive.t_u32 = count in + let i:u32 = i in + let (low_bit: Core.Primitive.t_u32):Core.Primitive.t_u32 = + Core.Convert.f_into #Core.Primitive.t_u32 + #Core.Primitive.t_u32 + #FStar.Tactics.Typeclasses.solve + (((Core.Clone.f_clone #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve x + <: + Core.Primitive.t_u32) >>! + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve i + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u32) &. + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve 1ul + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u32) + in + let count:Core.Primitive.t_u32 = + (count < + let count:Core.Primitive.t_u32 = count in + let _:u32 = temp_1_ in + true) + count + (fun count i -> + let count:Core.Primitive.t_u32 = count in + let i:u32 = i in + count +! + (Core.Convert.f_into #Core.Primitive.t_u32 + #Core.Primitive.t_u32 + #FStar.Tactics.Typeclasses.solve + (((Core.Clone.f_clone #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve x + <: + Core.Primitive.t_u32) >>! + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve i + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u32) &. + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve 1ul + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u32) + in + count + +let cttz_u32 (x: Core.Primitive.t_u32) : Core.Primitive.t_u32 = + let (count: Core.Primitive.t_u32):Core.Primitive.t_u32 = + Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve 0ul + in + let done:bool = false in + let count, done:(Core.Primitive.t_u32 & bool) = + Rust_primitives.Hax.Folds.fold_range 0ul + (Core.Convert.f_into #Core.Primitive.t_u32 + #u32 + #FStar.Tactics.Typeclasses.solve + v_BITS473478051 + <: + u32) + (fun temp_0_ temp_1_ -> + let count, done:(Core.Primitive.t_u32 & bool) = temp_0_ in + let _:u32 = temp_1_ in + true) + (count, done <: (Core.Primitive.t_u32 & bool)) + (fun temp_0_ i -> + let count, done:(Core.Primitive.t_u32 & bool) = temp_0_ in + let i:u32 = i in + let (low_bit: Core.Primitive.t_u32):Core.Primitive.t_u32 = + Core.Convert.f_into #Core.Primitive.t_u32 + #Core.Primitive.t_u32 + #FStar.Tactics.Typeclasses.solve + (((Core.Clone.f_clone #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve x + <: + Core.Primitive.t_u32) >>! + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve i + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u32) &. + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve 1ul + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u32) + in + if + low_bit =. + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve 1ul + <: + Core.Primitive.t_u32) || + done + then + let done:bool = true in + count, done <: (Core.Primitive.t_u32 & bool) + else + let count:Core.Primitive.t_u32 = + count +! + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve 1ul + <: + Core.Primitive.t_u32) + in + count, done <: (Core.Primitive.t_u32 & bool)) + in + count + +let count_ones776185738 (self: Core.Primitive.t_u32) : Core.Primitive.t_u32 = ctpop_u32 self + +let swap_bytes320480126 (self: Core.Primitive.t_u32) : Core.Primitive.t_u32 = + Core.Convert.f_into #Core.Primitive.t_u32 + #Core.Primitive.t_u32 + #FStar.Tactics.Typeclasses.solve + (bswap_u32 self <: Core.Primitive.t_u32) + +let from_be664756649 (x: Core.Primitive.t_u32) : Core.Primitive.t_u32 = swap_bytes320480126 x + +let to_be82825962 (self: Core.Primitive.t_u32) : Core.Primitive.t_u32 = swap_bytes320480126 self + +let trailing_zeros1061560720 (self: Core.Primitive.t_u32) : Core.Primitive.t_u32 = cttz_u32 self + +let bswap_u64 (x: Core.Primitive.t_u64) : Core.Primitive.t_u64 = + let (count: Core.Primitive.t_u64):Core.Primitive.t_u64 = + Core.Convert.f_into #u64 #Core.Primitive.t_u64 #FStar.Tactics.Typeclasses.solve 0uL + in + let count:Core.Primitive.t_u64 = + Rust_primitives.Hax.Folds.fold_range 0ul + (Core.Convert.f_into #Core.Primitive.t_u32 + #u32 + #FStar.Tactics.Typeclasses.solve + v_BITS177666292 + <: + u32) + (fun count temp_1_ -> + let count:Core.Primitive.t_u64 = count in + let _:u32 = temp_1_ in + true) + count + (fun count i -> + let count:Core.Primitive.t_u64 = count in + let i:u32 = i in + let (low_bit: Core.Primitive.t_u64):Core.Primitive.t_u64 = + Core.Convert.f_into #Core.Primitive.t_u64 + #Core.Primitive.t_u64 + #FStar.Tactics.Typeclasses.solve + (((Core.Clone.f_clone #Core.Primitive.t_u64 #FStar.Tactics.Typeclasses.solve x + <: + Core.Primitive.t_u64) >>! + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve i + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u64) &. + (Core.Convert.f_into #u64 #Core.Primitive.t_u64 #FStar.Tactics.Typeclasses.solve 1uL + <: + Core.Primitive.t_u64) + <: + Core.Primitive.t_u64) + in + let count:Core.Primitive.t_u64 = + (count < + let count:Core.Primitive.t_u32 = count in + let _:u32 = temp_1_ in + true) + count + (fun count i -> + let count:Core.Primitive.t_u32 = count in + let i:u32 = i in + count +! + (Core.Convert.f_into #Core.Primitive.t_u64 + #Core.Primitive.t_u32 + #FStar.Tactics.Typeclasses.solve + (((Core.Clone.f_clone #Core.Primitive.t_u64 #FStar.Tactics.Typeclasses.solve x + <: + Core.Primitive.t_u64) >>! + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve i + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u64) &. + (Core.Convert.f_into #u64 #Core.Primitive.t_u64 #FStar.Tactics.Typeclasses.solve 1uL + <: + Core.Primitive.t_u64) + <: + Core.Primitive.t_u64) + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u32) + in + count + +let cttz_u64 (x: Core.Primitive.t_u64) : Core.Primitive.t_u32 = + let (count: Core.Primitive.t_u32):Core.Primitive.t_u32 = + Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve 0ul + in + let done:bool = false in + let count, done:(Core.Primitive.t_u32 & bool) = + Rust_primitives.Hax.Folds.fold_range 0ul + (Core.Convert.f_into #Core.Primitive.t_u32 + #u32 + #FStar.Tactics.Typeclasses.solve + v_BITS177666292 + <: + u32) + (fun temp_0_ temp_1_ -> + let count, done:(Core.Primitive.t_u32 & bool) = temp_0_ in + let _:u32 = temp_1_ in + true) + (count, done <: (Core.Primitive.t_u32 & bool)) + (fun temp_0_ i -> + let count, done:(Core.Primitive.t_u32 & bool) = temp_0_ in + let i:u32 = i in + let (low_bit: Core.Primitive.t_u32):Core.Primitive.t_u32 = + Core.Convert.f_into #Core.Primitive.t_u64 + #Core.Primitive.t_u32 + #FStar.Tactics.Typeclasses.solve + (((Core.Clone.f_clone #Core.Primitive.t_u64 #FStar.Tactics.Typeclasses.solve x + <: + Core.Primitive.t_u64) >>! + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve i + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u64) &. + (Core.Convert.f_into #u64 #Core.Primitive.t_u64 #FStar.Tactics.Typeclasses.solve 1uL + <: + Core.Primitive.t_u64) + <: + Core.Primitive.t_u64) + in + if + low_bit =. + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve 1ul + <: + Core.Primitive.t_u32) || + done + then + let done:bool = true in + count, done <: (Core.Primitive.t_u32 & bool) + else + let count:Core.Primitive.t_u32 = + count +! + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve 1ul + <: + Core.Primitive.t_u32) + in + count, done <: (Core.Primitive.t_u32 & bool)) + in + count + +let count_ones235885653 (self: Core.Primitive.t_u64) : Core.Primitive.t_u32 = ctpop_u64 self + +let swap_bytes722254271 (self: Core.Primitive.t_u64) : Core.Primitive.t_u64 = + Core.Convert.f_into #Core.Primitive.t_u64 + #Core.Primitive.t_u64 + #FStar.Tactics.Typeclasses.solve + (bswap_u64 self <: Core.Primitive.t_u64) + +let from_be16013635 (x: Core.Primitive.t_u64) : Core.Primitive.t_u64 = swap_bytes722254271 x + +let to_be376714729 (self: Core.Primitive.t_u64) : Core.Primitive.t_u64 = swap_bytes722254271 self + +let trailing_zeros188346231 (self: Core.Primitive.t_u64) : Core.Primitive.t_u32 = cttz_u64 self + +let bswap_u128 (x: Core.Primitive.t_u128) : Core.Primitive.t_u128 = + let (count: Core.Primitive.t_u128):Core.Primitive.t_u128 = + Core.Convert.f_into #u128 #Core.Primitive.t_u128 #FStar.Tactics.Typeclasses.solve (pub_u128 0) + in + let count:Core.Primitive.t_u128 = + Rust_primitives.Hax.Folds.fold_range 0ul + (Core.Convert.f_into #Core.Primitive.t_u32 + #u32 + #FStar.Tactics.Typeclasses.solve + v_BITS136999051 + <: + u32) + (fun count temp_1_ -> + let count:Core.Primitive.t_u128 = count in + let _:u32 = temp_1_ in + true) + count + (fun count i -> + let count:Core.Primitive.t_u128 = count in + let i:u32 = i in + let (low_bit: Core.Primitive.t_u128):Core.Primitive.t_u128 = + Core.Convert.f_into #Core.Primitive.t_u128 + #Core.Primitive.t_u128 + #FStar.Tactics.Typeclasses.solve + (((Core.Clone.f_clone #Core.Primitive.t_u128 #FStar.Tactics.Typeclasses.solve x + <: + Core.Primitive.t_u128) >>! + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve i + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u128) &. + (Core.Convert.f_into #u128 + #Core.Primitive.t_u128 + #FStar.Tactics.Typeclasses.solve + (pub_u128 1) + <: + Core.Primitive.t_u128) + <: + Core.Primitive.t_u128) + in + let count:Core.Primitive.t_u128 = + (count < + let count:Core.Primitive.t_u32 = count in + let _:u32 = temp_1_ in + true) + count + (fun count i -> + let count:Core.Primitive.t_u32 = count in + let i:u32 = i in + count +! + (Core.Convert.f_into #Core.Primitive.t_u128 + #Core.Primitive.t_u32 + #FStar.Tactics.Typeclasses.solve + (((Core.Clone.f_clone #Core.Primitive.t_u128 #FStar.Tactics.Typeclasses.solve x + <: + Core.Primitive.t_u128) >>! + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve i + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u128) &. + (Core.Convert.f_into #u128 + #Core.Primitive.t_u128 + #FStar.Tactics.Typeclasses.solve + (pub_u128 1) + <: + Core.Primitive.t_u128) + <: + Core.Primitive.t_u128) + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u32) + in + count + +let cttz_u128 (x: Core.Primitive.t_u128) : Core.Primitive.t_u32 = + let (count: Core.Primitive.t_u32):Core.Primitive.t_u32 = + Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve 0ul + in + let done:bool = false in + let count, done:(Core.Primitive.t_u32 & bool) = + Rust_primitives.Hax.Folds.fold_range 0ul + (Core.Convert.f_into #Core.Primitive.t_u32 + #u32 + #FStar.Tactics.Typeclasses.solve + v_BITS136999051 + <: + u32) + (fun temp_0_ temp_1_ -> + let count, done:(Core.Primitive.t_u32 & bool) = temp_0_ in + let _:u32 = temp_1_ in + true) + (count, done <: (Core.Primitive.t_u32 & bool)) + (fun temp_0_ i -> + let count, done:(Core.Primitive.t_u32 & bool) = temp_0_ in + let i:u32 = i in + let (low_bit: Core.Primitive.t_u32):Core.Primitive.t_u32 = + Core.Convert.f_into #Core.Primitive.t_u128 + #Core.Primitive.t_u32 + #FStar.Tactics.Typeclasses.solve + (((Core.Clone.f_clone #Core.Primitive.t_u128 #FStar.Tactics.Typeclasses.solve x + <: + Core.Primitive.t_u128) >>! + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve i + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u128) &. + (Core.Convert.f_into #u128 + #Core.Primitive.t_u128 + #FStar.Tactics.Typeclasses.solve + (pub_u128 1) + <: + Core.Primitive.t_u128) + <: + Core.Primitive.t_u128) + in + if + low_bit =. + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve 1ul + <: + Core.Primitive.t_u32) || + done + then + let done:bool = true in + count, done <: (Core.Primitive.t_u32 & bool) + else + let count:Core.Primitive.t_u32 = + count +! + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve 1ul + <: + Core.Primitive.t_u32) + in + count, done <: (Core.Primitive.t_u32 & bool)) + in + count + +let count_ones926736261 (self: Core.Primitive.t_u128) : Core.Primitive.t_u32 = ctpop_u128 self + +let swap_bytes420879368 (self: Core.Primitive.t_u128) : Core.Primitive.t_u128 = + Core.Convert.f_into #Core.Primitive.t_u128 + #Core.Primitive.t_u128 + #FStar.Tactics.Typeclasses.solve + (bswap_u128 self <: Core.Primitive.t_u128) + +let from_be191085771 (x: Core.Primitive.t_u128) : Core.Primitive.t_u128 = swap_bytes420879368 x + +let to_be555075987 (self: Core.Primitive.t_u128) : Core.Primitive.t_u128 = swap_bytes420879368 self + +let trailing_zeros821715250 (self: Core.Primitive.t_u128) : Core.Primitive.t_u32 = cttz_u128 self + +let bswap_usize (x: Core.Primitive.t_usize) : Core.Primitive.t_usize = + let (count: Core.Primitive.t_usize):Core.Primitive.t_usize = + Core.Convert.f_into #usize #Core.Primitive.t_usize #FStar.Tactics.Typeclasses.solve (sz 0) + in + let count:Core.Primitive.t_usize = + Rust_primitives.Hax.Folds.fold_range 0ul + (Core.Convert.f_into #Core.Primitive.t_u32 + #u32 + #FStar.Tactics.Typeclasses.solve + v_BITS229952196 + <: + u32) + (fun count temp_1_ -> + let count:Core.Primitive.t_usize = count in + let _:u32 = temp_1_ in + true) + count + (fun count i -> + let count:Core.Primitive.t_usize = count in + let i:u32 = i in + let (low_bit: Core.Primitive.t_usize):Core.Primitive.t_usize = + Core.Convert.f_into #Core.Primitive.t_usize + #Core.Primitive.t_usize + #FStar.Tactics.Typeclasses.solve + (((Core.Clone.f_clone #Core.Primitive.t_usize #FStar.Tactics.Typeclasses.solve x + <: + Core.Primitive.t_usize) >>! + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve i + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_usize) &. + (Core.Convert.f_into #usize + #Core.Primitive.t_usize + #FStar.Tactics.Typeclasses.solve + (sz 1) + <: + Core.Primitive.t_usize) + <: + Core.Primitive.t_usize) + in + let count:Core.Primitive.t_usize = + (count < + let count:Core.Primitive.t_u32 = count in + let _:u32 = temp_1_ in + true) + count + (fun count i -> + let count:Core.Primitive.t_u32 = count in + let i:u32 = i in + count +! + (Core.Convert.f_into #Core.Primitive.t_usize + #Core.Primitive.t_u32 + #FStar.Tactics.Typeclasses.solve + (((Core.Clone.f_clone #Core.Primitive.t_usize #FStar.Tactics.Typeclasses.solve x + <: + Core.Primitive.t_usize) >>! + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve i + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_usize) &. + (Core.Convert.f_into #usize + #Core.Primitive.t_usize + #FStar.Tactics.Typeclasses.solve + (sz 1) + <: + Core.Primitive.t_usize) + <: + Core.Primitive.t_usize) + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u32) + in + count + +let cttz_usize (x: Core.Primitive.t_usize) : Core.Primitive.t_u32 = + let (count: Core.Primitive.t_u32):Core.Primitive.t_u32 = + Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve 0ul + in + let done:bool = false in + let count, done:(Core.Primitive.t_u32 & bool) = + Rust_primitives.Hax.Folds.fold_range 0ul + (Core.Convert.f_into #Core.Primitive.t_u32 + #u32 + #FStar.Tactics.Typeclasses.solve + v_BITS229952196 + <: + u32) + (fun temp_0_ temp_1_ -> + let count, done:(Core.Primitive.t_u32 & bool) = temp_0_ in + let _:u32 = temp_1_ in + true) + (count, done <: (Core.Primitive.t_u32 & bool)) + (fun temp_0_ i -> + let count, done:(Core.Primitive.t_u32 & bool) = temp_0_ in + let i:u32 = i in + let (low_bit: Core.Primitive.t_u32):Core.Primitive.t_u32 = + Core.Convert.f_into #Core.Primitive.t_usize + #Core.Primitive.t_u32 + #FStar.Tactics.Typeclasses.solve + (((Core.Clone.f_clone #Core.Primitive.t_usize #FStar.Tactics.Typeclasses.solve x + <: + Core.Primitive.t_usize) >>! + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve i + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_usize) &. + (Core.Convert.f_into #usize + #Core.Primitive.t_usize + #FStar.Tactics.Typeclasses.solve + (sz 1) + <: + Core.Primitive.t_usize) + <: + Core.Primitive.t_usize) + in + if + low_bit =. + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve 1ul + <: + Core.Primitive.t_u32) || + done + then + let done:bool = true in + count, done <: (Core.Primitive.t_u32 & bool) + else + let count:Core.Primitive.t_u32 = + count +! + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve 1ul + <: + Core.Primitive.t_u32) + in + count, done <: (Core.Primitive.t_u32 & bool)) + in + count + +let count_ones441645762 (self: Core.Primitive.t_usize) : Core.Primitive.t_u32 = ctpop_usize self + +let swap_bytes268673424 (self: Core.Primitive.t_usize) : Core.Primitive.t_usize = + Core.Convert.f_into #Core.Primitive.t_usize + #Core.Primitive.t_usize + #FStar.Tactics.Typeclasses.solve + (bswap_usize self <: Core.Primitive.t_usize) + +let from_be607978059 (x: Core.Primitive.t_usize) : Core.Primitive.t_usize = swap_bytes268673424 x + +let to_be561847134 (self: Core.Primitive.t_usize) : Core.Primitive.t_usize = + swap_bytes268673424 self + +let trailing_zeros42066260 (self: Core.Primitive.t_usize) : Core.Primitive.t_u32 = cttz_usize self + +let ctlz_u128 (x: Core.Primitive.t_u128) : Core.Primitive.t_u32 = + let (count: Core.Primitive.t_u32):Core.Primitive.t_u32 = + Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve 0ul + in + let done:bool = false in + let count, done:(Core.Primitive.t_u32 & bool) = + Rust_primitives.Hax.Folds.fold_range 0ul + (Core.Convert.f_into #Core.Primitive.t_u32 + #u32 + #FStar.Tactics.Typeclasses.solve + v_BITS136999051 + <: + u32) + (fun temp_0_ temp_1_ -> + let count, done:(Core.Primitive.t_u32 & bool) = temp_0_ in + let _:u32 = temp_1_ in + true) + (count, done <: (Core.Primitive.t_u32 & bool)) + (fun temp_0_ i -> + let count, done:(Core.Primitive.t_u32 & bool) = temp_0_ in + let i:u32 = i in + let (high_bit: Core.Primitive.t_u32):Core.Primitive.t_u32 = + Core.Convert.f_into #Core.Primitive.t_u128 + #Core.Primitive.t_u32 + #FStar.Tactics.Typeclasses.solve + (((Core.Clone.f_clone #Core.Primitive.t_u128 #FStar.Tactics.Typeclasses.solve x + <: + Core.Primitive.t_u128) <>! + (Core.Convert.f_into #Core.Primitive.t_u32 + #Core.Primitive.t_u32 + #FStar.Tactics.Typeclasses.solve + (v_BITS136999051 -! + (Core.Convert.f_into #u32 + #Core.Primitive.t_u32 + #FStar.Tactics.Typeclasses.solve + 1ul + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u128) + in + if + high_bit =. + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve 1ul + <: + Core.Primitive.t_u32) || + done + then + let done:bool = true in + count, done <: (Core.Primitive.t_u32 & bool) + else + let count:Core.Primitive.t_u32 = + count +! + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve 1ul + <: + Core.Primitive.t_u32) + in + count, done <: (Core.Primitive.t_u32 & bool)) + in + count + +let ctlz_u16 (x: Core.Primitive.t_u16) : Core.Primitive.t_u32 = + let (count: Core.Primitive.t_u32):Core.Primitive.t_u32 = + Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve 0ul + in + let done:bool = false in + let count, done:(Core.Primitive.t_u32 & bool) = + Rust_primitives.Hax.Folds.fold_range 0ul + (Core.Convert.f_into #Core.Primitive.t_u32 + #u32 + #FStar.Tactics.Typeclasses.solve + v_BITS277333551 + <: + u32) + (fun temp_0_ temp_1_ -> + let count, done:(Core.Primitive.t_u32 & bool) = temp_0_ in + let _:u32 = temp_1_ in + true) + (count, done <: (Core.Primitive.t_u32 & bool)) + (fun temp_0_ i -> + let count, done:(Core.Primitive.t_u32 & bool) = temp_0_ in + let i:u32 = i in + let (high_bit: Core.Primitive.t_u32):Core.Primitive.t_u32 = + Core.Convert.f_into #Core.Primitive.t_u16 + #Core.Primitive.t_u32 + #FStar.Tactics.Typeclasses.solve + (((Core.Clone.f_clone #Core.Primitive.t_u16 #FStar.Tactics.Typeclasses.solve x + <: + Core.Primitive.t_u16) <>! + (Core.Convert.f_into #Core.Primitive.t_u32 + #Core.Primitive.t_u32 + #FStar.Tactics.Typeclasses.solve + (v_BITS277333551 -! + (Core.Convert.f_into #u32 + #Core.Primitive.t_u32 + #FStar.Tactics.Typeclasses.solve + 1ul + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u16) + in + if + high_bit =. + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve 1ul + <: + Core.Primitive.t_u32) || + done + then + let done:bool = true in + count, done <: (Core.Primitive.t_u32 & bool) + else + let count:Core.Primitive.t_u32 = + count +! + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve 1ul + <: + Core.Primitive.t_u32) + in + count, done <: (Core.Primitive.t_u32 & bool)) + in + count + +let ctlz_u32 (x: Core.Primitive.t_u32) : Core.Primitive.t_u32 = + let (count: Core.Primitive.t_u32):Core.Primitive.t_u32 = + Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve 0ul + in + let done:bool = false in + let count, done:(Core.Primitive.t_u32 & bool) = + Rust_primitives.Hax.Folds.fold_range 0ul + (Core.Convert.f_into #Core.Primitive.t_u32 + #u32 + #FStar.Tactics.Typeclasses.solve + v_BITS473478051 + <: + u32) + (fun temp_0_ temp_1_ -> + let count, done:(Core.Primitive.t_u32 & bool) = temp_0_ in + let _:u32 = temp_1_ in + true) + (count, done <: (Core.Primitive.t_u32 & bool)) + (fun temp_0_ i -> + let count, done:(Core.Primitive.t_u32 & bool) = temp_0_ in + let i:u32 = i in + let (high_bit: Core.Primitive.t_u32):Core.Primitive.t_u32 = + Core.Convert.f_into #Core.Primitive.t_u32 + #Core.Primitive.t_u32 + #FStar.Tactics.Typeclasses.solve + (((Core.Clone.f_clone #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve x + <: + Core.Primitive.t_u32) <>! + (Core.Convert.f_into #Core.Primitive.t_u32 + #Core.Primitive.t_u32 + #FStar.Tactics.Typeclasses.solve + (v_BITS473478051 -! + (Core.Convert.f_into #u32 + #Core.Primitive.t_u32 + #FStar.Tactics.Typeclasses.solve + 1ul + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u32) + in + if + high_bit =. + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve 1ul + <: + Core.Primitive.t_u32) || + done + then + let done:bool = true in + count, done <: (Core.Primitive.t_u32 & bool) + else + let count:Core.Primitive.t_u32 = + count +! + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve 1ul + <: + Core.Primitive.t_u32) + in + count, done <: (Core.Primitive.t_u32 & bool)) + in + count + +let ctlz_u64 (x: Core.Primitive.t_u64) : Core.Primitive.t_u32 = + let (count: Core.Primitive.t_u32):Core.Primitive.t_u32 = + Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve 0ul + in + let done:bool = false in + let count, done:(Core.Primitive.t_u32 & bool) = + Rust_primitives.Hax.Folds.fold_range 0ul + (Core.Convert.f_into #Core.Primitive.t_u32 + #u32 + #FStar.Tactics.Typeclasses.solve + v_BITS177666292 + <: + u32) + (fun temp_0_ temp_1_ -> + let count, done:(Core.Primitive.t_u32 & bool) = temp_0_ in + let _:u32 = temp_1_ in + true) + (count, done <: (Core.Primitive.t_u32 & bool)) + (fun temp_0_ i -> + let count, done:(Core.Primitive.t_u32 & bool) = temp_0_ in + let i:u32 = i in + let (high_bit: Core.Primitive.t_u32):Core.Primitive.t_u32 = + Core.Convert.f_into #Core.Primitive.t_u64 + #Core.Primitive.t_u32 + #FStar.Tactics.Typeclasses.solve + (((Core.Clone.f_clone #Core.Primitive.t_u64 #FStar.Tactics.Typeclasses.solve x + <: + Core.Primitive.t_u64) <>! + (Core.Convert.f_into #Core.Primitive.t_u32 + #Core.Primitive.t_u32 + #FStar.Tactics.Typeclasses.solve + (v_BITS177666292 -! + (Core.Convert.f_into #u32 + #Core.Primitive.t_u32 + #FStar.Tactics.Typeclasses.solve + 1ul + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u64) + in + if + high_bit =. + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve 1ul + <: + Core.Primitive.t_u32) || + done + then + let done:bool = true in + count, done <: (Core.Primitive.t_u32 & bool) + else + let count:Core.Primitive.t_u32 = + count +! + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve 1ul + <: + Core.Primitive.t_u32) + in + count, done <: (Core.Primitive.t_u32 & bool)) + in + count + +let ctlz_u8 (x: Core.Primitive.t_u8) : Core.Primitive.t_u32 = + let (count: Core.Primitive.t_u32):Core.Primitive.t_u32 = + Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve 0ul + in + let done:bool = false in + let count, done:(Core.Primitive.t_u32 & bool) = + Rust_primitives.Hax.Folds.fold_range 0ul + (Core.Convert.f_into #Core.Primitive.t_u32 + #u32 + #FStar.Tactics.Typeclasses.solve + v_BITS690311813 + <: + u32) + (fun temp_0_ temp_1_ -> + let count, done:(Core.Primitive.t_u32 & bool) = temp_0_ in + let _:u32 = temp_1_ in + true) + (count, done <: (Core.Primitive.t_u32 & bool)) + (fun temp_0_ i -> + let count, done:(Core.Primitive.t_u32 & bool) = temp_0_ in + let i:u32 = i in + let (high_bit: Core.Primitive.t_u32):Core.Primitive.t_u32 = + Core.Convert.f_into #Core.Primitive.t_u8 + #Core.Primitive.t_u32 + #FStar.Tactics.Typeclasses.solve + (((Core.Clone.f_clone #Core.Primitive.t_u8 #FStar.Tactics.Typeclasses.solve x + <: + Core.Primitive.t_u8) <>! + (Core.Convert.f_into #Core.Primitive.t_u32 + #Core.Primitive.t_u32 + #FStar.Tactics.Typeclasses.solve + (v_BITS690311813 -! + (Core.Convert.f_into #u32 + #Core.Primitive.t_u32 + #FStar.Tactics.Typeclasses.solve + 1ul + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u8) + in + if + high_bit =. + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve 1ul + <: + Core.Primitive.t_u32) || + done + then + let done:bool = true in + count, done <: (Core.Primitive.t_u32 & bool) + else + let count:Core.Primitive.t_u32 = + count +! + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve 1ul + <: + Core.Primitive.t_u32) + in + count, done <: (Core.Primitive.t_u32 & bool)) + in + count + +let ctlz_usize (x: Core.Primitive.t_usize) : Core.Primitive.t_u32 = + let (count: Core.Primitive.t_u32):Core.Primitive.t_u32 = + Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve 0ul + in + let done:bool = false in + let count, done:(Core.Primitive.t_u32 & bool) = + Rust_primitives.Hax.Folds.fold_range 0ul + (Core.Convert.f_into #Core.Primitive.t_u32 + #u32 + #FStar.Tactics.Typeclasses.solve + v_BITS229952196 + <: + u32) + (fun temp_0_ temp_1_ -> + let count, done:(Core.Primitive.t_u32 & bool) = temp_0_ in + let _:u32 = temp_1_ in + true) + (count, done <: (Core.Primitive.t_u32 & bool)) + (fun temp_0_ i -> + let count, done:(Core.Primitive.t_u32 & bool) = temp_0_ in + let i:u32 = i in + let (high_bit: Core.Primitive.t_u32):Core.Primitive.t_u32 = + Core.Convert.f_into #Core.Primitive.t_usize + #Core.Primitive.t_u32 + #FStar.Tactics.Typeclasses.solve + (((Core.Clone.f_clone #Core.Primitive.t_usize #FStar.Tactics.Typeclasses.solve x + <: + Core.Primitive.t_usize) <>! + (Core.Convert.f_into #Core.Primitive.t_u32 + #Core.Primitive.t_u32 + #FStar.Tactics.Typeclasses.solve + (v_BITS229952196 -! + (Core.Convert.f_into #u32 + #Core.Primitive.t_u32 + #FStar.Tactics.Typeclasses.solve + 1ul + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_usize) + in + if + high_bit =. + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve 1ul + <: + Core.Primitive.t_u32) || + done + then + let done:bool = true in + count, done <: (Core.Primitive.t_u32 & bool) + else + let count:Core.Primitive.t_u32 = + count +! + (Core.Convert.f_into #u32 #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve 1ul + <: + Core.Primitive.t_u32) + in + count, done <: (Core.Primitive.t_u32 & bool)) + in + count + +let rotate_left_u128 (x: Core.Primitive.t_u128) (shift: Core.Primitive.t_u32) + : Core.Primitive.t_u128 = + let (shift: Core.Primitive.t_u32):Core.Primitive.t_u32 = shift %! v_BITS136999051 in + let (left: Core.Primitive.t_u128):Core.Primitive.t_u128 = + (Core.Clone.f_clone #Core.Primitive.t_u128 #FStar.Tactics.Typeclasses.solve x + <: + Core.Primitive.t_u128) <>! + (v_BITS136999051 -! + (Core.Clone.f_clone #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve shift + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u32) + in + left |. right + +let rotate_left_u16 (x: Core.Primitive.t_u16) (shift: Core.Primitive.t_u32) : Core.Primitive.t_u16 = + let (shift: Core.Primitive.t_u32):Core.Primitive.t_u32 = shift %! v_BITS277333551 in + let (left: Core.Primitive.t_u16):Core.Primitive.t_u16 = + (Core.Clone.f_clone #Core.Primitive.t_u16 #FStar.Tactics.Typeclasses.solve x + <: + Core.Primitive.t_u16) <>! + (v_BITS277333551 -! + (Core.Clone.f_clone #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve shift + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u32) + in + left |. right + +let rotate_left_u32 (x shift: Core.Primitive.t_u32) : Core.Primitive.t_u32 = + let (shift: Core.Primitive.t_u32):Core.Primitive.t_u32 = shift %! v_BITS473478051 in + let (left: Core.Primitive.t_u32):Core.Primitive.t_u32 = + (Core.Clone.f_clone #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve x + <: + Core.Primitive.t_u32) <>! + (v_BITS473478051 -! + (Core.Clone.f_clone #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve shift + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u32) + in + left |. right + +let rotate_left_u64 (x: Core.Primitive.t_u64) (shift: Core.Primitive.t_u32) : Core.Primitive.t_u64 = + let (shift: Core.Primitive.t_u32):Core.Primitive.t_u32 = shift %! v_BITS177666292 in + let (left: Core.Primitive.t_u64):Core.Primitive.t_u64 = + (Core.Clone.f_clone #Core.Primitive.t_u64 #FStar.Tactics.Typeclasses.solve x + <: + Core.Primitive.t_u64) <>! + (v_BITS177666292 -! + (Core.Clone.f_clone #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve shift + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u32) + in + left |. right + +let rotate_left_u8 (x: Core.Primitive.t_u8) (shift: Core.Primitive.t_u32) : Core.Primitive.t_u8 = + let (shift: Core.Primitive.t_u32):Core.Primitive.t_u32 = shift %! v_BITS690311813 in + let (left: Core.Primitive.t_u8):Core.Primitive.t_u8 = + (Core.Clone.f_clone #Core.Primitive.t_u8 #FStar.Tactics.Typeclasses.solve x + <: + Core.Primitive.t_u8) <>! + (v_BITS690311813 -! + (Core.Clone.f_clone #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve shift + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u32) + in + left |. right + +let rotate_left_usize (x: Core.Primitive.t_usize) (shift: Core.Primitive.t_u32) + : Core.Primitive.t_usize = + let (shift: Core.Primitive.t_u32):Core.Primitive.t_u32 = shift %! v_BITS229952196 in + let (left: Core.Primitive.t_usize):Core.Primitive.t_usize = + (Core.Clone.f_clone #Core.Primitive.t_usize #FStar.Tactics.Typeclasses.solve x + <: + Core.Primitive.t_usize) <>! + (v_BITS229952196 -! + (Core.Clone.f_clone #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve shift + <: + Core.Primitive.t_u32) + <: + Core.Primitive.t_u32) + in + left |. right + +let rotate_right_u128 (x: Core.Primitive.t_u128) (shift: Core.Primitive.t_u32) + : Core.Primitive.t_u128 = + let (shift: Core.Primitive.t_u32):Core.Primitive.t_u32 = shift %! v_BITS136999051 in + let (left: Core.Primitive.t_u128):Core.Primitive.t_u128 = + (Core.Clone.f_clone #Core.Primitive.t_u128 #FStar.Tactics.Typeclasses.solve x + <: + Core.Primitive.t_u128) >>! + (Core.Clone.f_clone #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve shift + <: + Core.Primitive.t_u32) + in + let (right: Core.Primitive.t_u128):Core.Primitive.t_u128 = + (Core.Clone.f_clone #Core.Primitive.t_u128 #FStar.Tactics.Typeclasses.solve x + <: + Core.Primitive.t_u128) <>! + (Core.Clone.f_clone #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve shift + <: + Core.Primitive.t_u32) + in + let (right: Core.Primitive.t_u16):Core.Primitive.t_u16 = + (Core.Clone.f_clone #Core.Primitive.t_u16 #FStar.Tactics.Typeclasses.solve x + <: + Core.Primitive.t_u16) <>! + (Core.Clone.f_clone #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve shift + <: + Core.Primitive.t_u32) + in + let (right: Core.Primitive.t_u32):Core.Primitive.t_u32 = + (Core.Clone.f_clone #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve x + <: + Core.Primitive.t_u32) <>! + (Core.Clone.f_clone #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve shift + <: + Core.Primitive.t_u32) + in + let (right: Core.Primitive.t_u64):Core.Primitive.t_u64 = + (Core.Clone.f_clone #Core.Primitive.t_u64 #FStar.Tactics.Typeclasses.solve x + <: + Core.Primitive.t_u64) <>! + (Core.Clone.f_clone #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve shift + <: + Core.Primitive.t_u32) + in + let (right: Core.Primitive.t_u8):Core.Primitive.t_u8 = + (Core.Clone.f_clone #Core.Primitive.t_u8 #FStar.Tactics.Typeclasses.solve x + <: + Core.Primitive.t_u8) <>! + (Core.Clone.f_clone #Core.Primitive.t_u32 #FStar.Tactics.Typeclasses.solve shift + <: + Core.Primitive.t_u32) + in + let (right: Core.Primitive.t_usize):Core.Primitive.t_usize = + (Core.Clone.f_clone #Core.Primitive.t_usize #FStar.Tactics.Typeclasses.solve x + <: + Core.Primitive.t_usize) < true); + f_neg_post = (fun (self: Core.Primitive.t_i8) (out: Core.Primitive.t_i8) -> true); + f_neg + = + fun (self: Core.Primitive.t_i8) -> + Core.Primitive.C_i8 + (Core.Ops.Arith.f_neg #Core.Base_interface.Int.t_I8 + #FStar.Tactics.Typeclasses.solve + self.Core.Primitive._0) + <: + Core.Primitive.t_i8 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_1: Core.Ops.Arith.t_Neg Core.Primitive.t_i16 = + { + f_Output = Core.Primitive.t_i16; + f_neg_pre = (fun (self: Core.Primitive.t_i16) -> true); + f_neg_post = (fun (self: Core.Primitive.t_i16) (out: Core.Primitive.t_i16) -> true); + f_neg + = + fun (self: Core.Primitive.t_i16) -> + Core.Primitive.C_i16 + (Core.Ops.Arith.f_neg #Core.Base_interface.Int.t_I16 + #FStar.Tactics.Typeclasses.solve + self.Core.Primitive._0) + <: + Core.Primitive.t_i16 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_2: Core.Ops.Arith.t_Neg Core.Primitive.t_i32 = + { + f_Output = Core.Primitive.t_i32; + f_neg_pre = (fun (self: Core.Primitive.t_i32) -> true); + f_neg_post = (fun (self: Core.Primitive.t_i32) (out: Core.Primitive.t_i32) -> true); + f_neg + = + fun (self: Core.Primitive.t_i32) -> + Core.Primitive.C_i32 + (Core.Ops.Arith.f_neg #Core.Base_interface.Int.t_I32 + #FStar.Tactics.Typeclasses.solve + self.Core.Primitive._0) + <: + Core.Primitive.t_i32 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_3: Core.Ops.Arith.t_Neg Core.Primitive.t_i64 = + { + f_Output = Core.Primitive.t_i64; + f_neg_pre = (fun (self: Core.Primitive.t_i64) -> true); + f_neg_post = (fun (self: Core.Primitive.t_i64) (out: Core.Primitive.t_i64) -> true); + f_neg + = + fun (self: Core.Primitive.t_i64) -> + Core.Primitive.C_i64 + (Core.Ops.Arith.f_neg #Core.Base_interface.Int.t_I64 + #FStar.Tactics.Typeclasses.solve + self.Core.Primitive._0) + <: + Core.Primitive.t_i64 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_4: Core.Ops.Arith.t_Neg Core.Primitive.t_i128 = + { + f_Output = Core.Primitive.t_i128; + f_neg_pre = (fun (self: Core.Primitive.t_i128) -> true); + f_neg_post = (fun (self: Core.Primitive.t_i128) (out: Core.Primitive.t_i128) -> true); + f_neg + = + fun (self: Core.Primitive.t_i128) -> + Core.Primitive.C_i128 + (Core.Ops.Arith.f_neg #Core.Base_interface.Int.t_I128 + #FStar.Tactics.Typeclasses.solve + self.Core.Primitive._0) + <: + Core.Primitive.t_i128 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_5: Core.Ops.Arith.t_Neg Core.Primitive.t_isize = + { + f_Output = Core.Primitive.t_isize; + f_neg_pre = (fun (self: Core.Primitive.t_isize) -> true); + f_neg_post = (fun (self: Core.Primitive.t_isize) (out: Core.Primitive.t_isize) -> true); + f_neg + = + fun (self: Core.Primitive.t_isize) -> + Core.Primitive.C_isize + (Core.Ops.Arith.f_neg #Core.Base_interface.Int.t_I64 + #FStar.Tactics.Typeclasses.solve + self.Core.Primitive._0) + <: + Core.Primitive.t_isize + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_12: Core.Ops.Arith.t_Add Core.Primitive.t_i8 Core.Primitive.t_i8 = + { + f_Output = Core.Primitive.t_i8; + f_add_pre = (fun (self: Core.Primitive.t_i8) (other: Core.Primitive.t_i8) -> true); + f_add_post + = + (fun (self: Core.Primitive.t_i8) (other: Core.Primitive.t_i8) (out: Core.Primitive.t_i8) -> true + ); + f_add + = + fun (self: Core.Primitive.t_i8) (other: Core.Primitive.t_i8) -> + Core.Primitive.C_i8 (self.Core.Primitive._0 +! other.Core.Primitive._0) <: Core.Primitive.t_i8 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_13: Core.Ops.Arith.t_Add Core.Primitive.t_i16 Core.Primitive.t_i16 = + { + f_Output = Core.Primitive.t_i16; + f_add_pre = (fun (self: Core.Primitive.t_i16) (other: Core.Primitive.t_i16) -> true); + f_add_post + = + (fun (self: Core.Primitive.t_i16) (other: Core.Primitive.t_i16) (out: Core.Primitive.t_i16) -> + true); + f_add + = + fun (self: Core.Primitive.t_i16) (other: Core.Primitive.t_i16) -> + Core.Primitive.C_i16 (self.Core.Primitive._0 +! other.Core.Primitive._0) + <: + Core.Primitive.t_i16 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_14: Core.Ops.Arith.t_Add Core.Primitive.t_i32 Core.Primitive.t_i32 = + { + f_Output = Core.Primitive.t_i32; + f_add_pre = (fun (self: Core.Primitive.t_i32) (other: Core.Primitive.t_i32) -> true); + f_add_post + = + (fun (self: Core.Primitive.t_i32) (other: Core.Primitive.t_i32) (out: Core.Primitive.t_i32) -> + true); + f_add + = + fun (self: Core.Primitive.t_i32) (other: Core.Primitive.t_i32) -> + Core.Primitive.C_i32 (self.Core.Primitive._0 +! other.Core.Primitive._0) + <: + Core.Primitive.t_i32 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_15: Core.Ops.Arith.t_Add Core.Primitive.t_i64 Core.Primitive.t_i64 = + { + f_Output = Core.Primitive.t_i64; + f_add_pre = (fun (self: Core.Primitive.t_i64) (other: Core.Primitive.t_i64) -> true); + f_add_post + = + (fun (self: Core.Primitive.t_i64) (other: Core.Primitive.t_i64) (out: Core.Primitive.t_i64) -> + true); + f_add + = + fun (self: Core.Primitive.t_i64) (other: Core.Primitive.t_i64) -> + Core.Primitive.C_i64 (self.Core.Primitive._0 +! other.Core.Primitive._0) + <: + Core.Primitive.t_i64 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_16: Core.Ops.Arith.t_Add Core.Primitive.t_i128 Core.Primitive.t_i128 = + { + f_Output = Core.Primitive.t_i128; + f_add_pre = (fun (self: Core.Primitive.t_i128) (other: Core.Primitive.t_i128) -> true); + f_add_post + = + (fun + (self: Core.Primitive.t_i128) + (other: Core.Primitive.t_i128) + (out: Core.Primitive.t_i128) + -> + true); + f_add + = + fun (self: Core.Primitive.t_i128) (other: Core.Primitive.t_i128) -> + Core.Primitive.C_i128 (self.Core.Primitive._0 +! other.Core.Primitive._0) + <: + Core.Primitive.t_i128 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_17: Core.Ops.Arith.t_Add Core.Primitive.t_isize Core.Primitive.t_isize = + { + f_Output = Core.Primitive.t_isize; + f_add_pre = (fun (self: Core.Primitive.t_isize) (other: Core.Primitive.t_isize) -> true); + f_add_post + = + (fun + (self: Core.Primitive.t_isize) + (other: Core.Primitive.t_isize) + (out: Core.Primitive.t_isize) + -> + true); + f_add + = + fun (self: Core.Primitive.t_isize) (other: Core.Primitive.t_isize) -> + Core.Primitive.C_isize (self.Core.Primitive._0 +! other.Core.Primitive._0) + <: + Core.Primitive.t_isize + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_24: Core.Ops.Arith.t_Sub Core.Primitive.t_i8 Core.Primitive.t_i8 = + { + f_Output = Core.Primitive.t_i8; + f_sub_pre = (fun (self: Core.Primitive.t_i8) (other: Core.Primitive.t_i8) -> true); + f_sub_post + = + (fun (self: Core.Primitive.t_i8) (other: Core.Primitive.t_i8) (out: Core.Primitive.t_i8) -> true + ); + f_sub + = + fun (self: Core.Primitive.t_i8) (other: Core.Primitive.t_i8) -> + Core.Primitive.C_i8 (self.Core.Primitive._0 -! other.Core.Primitive._0) <: Core.Primitive.t_i8 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_25: Core.Ops.Arith.t_Sub Core.Primitive.t_i16 Core.Primitive.t_i16 = + { + f_Output = Core.Primitive.t_i16; + f_sub_pre = (fun (self: Core.Primitive.t_i16) (other: Core.Primitive.t_i16) -> true); + f_sub_post + = + (fun (self: Core.Primitive.t_i16) (other: Core.Primitive.t_i16) (out: Core.Primitive.t_i16) -> + true); + f_sub + = + fun (self: Core.Primitive.t_i16) (other: Core.Primitive.t_i16) -> + Core.Primitive.C_i16 (self.Core.Primitive._0 -! other.Core.Primitive._0) + <: + Core.Primitive.t_i16 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_26: Core.Ops.Arith.t_Sub Core.Primitive.t_i32 Core.Primitive.t_i32 = + { + f_Output = Core.Primitive.t_i32; + f_sub_pre = (fun (self: Core.Primitive.t_i32) (other: Core.Primitive.t_i32) -> true); + f_sub_post + = + (fun (self: Core.Primitive.t_i32) (other: Core.Primitive.t_i32) (out: Core.Primitive.t_i32) -> + true); + f_sub + = + fun (self: Core.Primitive.t_i32) (other: Core.Primitive.t_i32) -> + Core.Primitive.C_i32 (self.Core.Primitive._0 -! other.Core.Primitive._0) + <: + Core.Primitive.t_i32 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_27: Core.Ops.Arith.t_Sub Core.Primitive.t_i64 Core.Primitive.t_i64 = + { + f_Output = Core.Primitive.t_i64; + f_sub_pre = (fun (self: Core.Primitive.t_i64) (other: Core.Primitive.t_i64) -> true); + f_sub_post + = + (fun (self: Core.Primitive.t_i64) (other: Core.Primitive.t_i64) (out: Core.Primitive.t_i64) -> + true); + f_sub + = + fun (self: Core.Primitive.t_i64) (other: Core.Primitive.t_i64) -> + Core.Primitive.C_i64 (self.Core.Primitive._0 -! other.Core.Primitive._0) + <: + Core.Primitive.t_i64 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_28: Core.Ops.Arith.t_Sub Core.Primitive.t_i128 Core.Primitive.t_i128 = + { + f_Output = Core.Primitive.t_i128; + f_sub_pre = (fun (self: Core.Primitive.t_i128) (other: Core.Primitive.t_i128) -> true); + f_sub_post + = + (fun + (self: Core.Primitive.t_i128) + (other: Core.Primitive.t_i128) + (out: Core.Primitive.t_i128) + -> + true); + f_sub + = + fun (self: Core.Primitive.t_i128) (other: Core.Primitive.t_i128) -> + Core.Primitive.C_i128 (self.Core.Primitive._0 -! other.Core.Primitive._0) + <: + Core.Primitive.t_i128 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_29: Core.Ops.Arith.t_Sub Core.Primitive.t_isize Core.Primitive.t_isize = + { + f_Output = Core.Primitive.t_isize; + f_sub_pre = (fun (self: Core.Primitive.t_isize) (other: Core.Primitive.t_isize) -> true); + f_sub_post + = + (fun + (self: Core.Primitive.t_isize) + (other: Core.Primitive.t_isize) + (out: Core.Primitive.t_isize) + -> + true); + f_sub + = + fun (self: Core.Primitive.t_isize) (other: Core.Primitive.t_isize) -> + Core.Primitive.C_isize (self.Core.Primitive._0 -! other.Core.Primitive._0) + <: + Core.Primitive.t_isize + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_6: Core.Ops.Arith.t_Add Core.Primitive.t_u8 Core.Primitive.t_u8 = + { + f_Output = Core.Primitive.t_u8; + f_add_pre = (fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u8) -> true); + f_add_post + = + (fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u8) (out: Core.Primitive.t_u8) -> true + ); + f_add + = + fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u8) -> + Core.Primitive.C_u8 (self.Core.Primitive._0 +! other.Core.Primitive._0) <: Core.Primitive.t_u8 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_7: Core.Ops.Arith.t_Add Core.Primitive.t_u16 Core.Primitive.t_u16 = + { + f_Output = Core.Primitive.t_u16; + f_add_pre = (fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u16) -> true); + f_add_post + = + (fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u16) (out: Core.Primitive.t_u16) -> + true); + f_add + = + fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u16) -> + Core.Primitive.C_u16 (self.Core.Primitive._0 +! other.Core.Primitive._0) + <: + Core.Primitive.t_u16 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_8: Core.Ops.Arith.t_Add Core.Primitive.t_u32 Core.Primitive.t_u32 = + { + f_Output = Core.Primitive.t_u32; + f_add_pre = (fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u32) -> true); + f_add_post + = + (fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u32) (out: Core.Primitive.t_u32) -> + true); + f_add + = + fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u32) -> + Core.Primitive.C_u32 (self.Core.Primitive._0 +! other.Core.Primitive._0) + <: + Core.Primitive.t_u32 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_9: Core.Ops.Arith.t_Add Core.Primitive.t_u64 Core.Primitive.t_u64 = + { + f_Output = Core.Primitive.t_u64; + f_add_pre = (fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u64) -> true); + f_add_post + = + (fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u64) (out: Core.Primitive.t_u64) -> + true); + f_add + = + fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u64) -> + Core.Primitive.C_u64 (self.Core.Primitive._0 +! other.Core.Primitive._0) + <: + Core.Primitive.t_u64 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_10: Core.Ops.Arith.t_Add Core.Primitive.t_u128 Core.Primitive.t_u128 = + { + f_Output = Core.Primitive.t_u128; + f_add_pre = (fun (self: Core.Primitive.t_u128) (other: Core.Primitive.t_u128) -> true); + f_add_post + = + (fun + (self: Core.Primitive.t_u128) + (other: Core.Primitive.t_u128) + (out: Core.Primitive.t_u128) + -> + true); + f_add + = + fun (self: Core.Primitive.t_u128) (other: Core.Primitive.t_u128) -> + Core.Primitive.C_u128 (self.Core.Primitive._0 +! other.Core.Primitive._0) + <: + Core.Primitive.t_u128 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_11: Core.Ops.Arith.t_Add Core.Primitive.t_usize Core.Primitive.t_usize = + { + f_Output = Core.Primitive.t_usize; + f_add_pre = (fun (self: Core.Primitive.t_usize) (other: Core.Primitive.t_usize) -> true); + f_add_post + = + (fun + (self: Core.Primitive.t_usize) + (other: Core.Primitive.t_usize) + (out: Core.Primitive.t_usize) + -> + true); + f_add + = + fun (self: Core.Primitive.t_usize) (other: Core.Primitive.t_usize) -> + Core.Primitive.C_usize (self.Core.Primitive._0 +! other.Core.Primitive._0) + <: + Core.Primitive.t_usize + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_30: Core.Ops.Arith.t_Mul Core.Primitive.t_u8 Core.Primitive.t_u8 = + { + f_Output = Core.Primitive.t_u8; + f_mul_pre = (fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u8) -> true); + f_mul_post + = + (fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u8) (out: Core.Primitive.t_u8) -> true + ); + f_mul + = + fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u8) -> + Core.Primitive.C_u8 (self.Core.Primitive._0 *! other.Core.Primitive._0) <: Core.Primitive.t_u8 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_31: Core.Ops.Arith.t_Mul Core.Primitive.t_u16 Core.Primitive.t_u16 = + { + f_Output = Core.Primitive.t_u16; + f_mul_pre = (fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u16) -> true); + f_mul_post + = + (fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u16) (out: Core.Primitive.t_u16) -> + true); + f_mul + = + fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u16) -> + Core.Primitive.C_u16 (self.Core.Primitive._0 *! other.Core.Primitive._0) + <: + Core.Primitive.t_u16 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_32: Core.Ops.Arith.t_Mul Core.Primitive.t_u32 Core.Primitive.t_u32 = + { + f_Output = Core.Primitive.t_u32; + f_mul_pre = (fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u32) -> true); + f_mul_post + = + (fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u32) (out: Core.Primitive.t_u32) -> + true); + f_mul + = + fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u32) -> + Core.Primitive.C_u32 (self.Core.Primitive._0 *! other.Core.Primitive._0) + <: + Core.Primitive.t_u32 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_33: Core.Ops.Arith.t_Mul Core.Primitive.t_u64 Core.Primitive.t_u64 = + { + f_Output = Core.Primitive.t_u64; + f_mul_pre = (fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u64) -> true); + f_mul_post + = + (fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u64) (out: Core.Primitive.t_u64) -> + true); + f_mul + = + fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u64) -> + Core.Primitive.C_u64 (self.Core.Primitive._0 *! other.Core.Primitive._0) + <: + Core.Primitive.t_u64 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_34: Core.Ops.Arith.t_Mul Core.Primitive.t_u128 Core.Primitive.t_u128 = + { + f_Output = Core.Primitive.t_u128; + f_mul_pre = (fun (self: Core.Primitive.t_u128) (other: Core.Primitive.t_u128) -> true); + f_mul_post + = + (fun + (self: Core.Primitive.t_u128) + (other: Core.Primitive.t_u128) + (out: Core.Primitive.t_u128) + -> + true); + f_mul + = + fun (self: Core.Primitive.t_u128) (other: Core.Primitive.t_u128) -> + Core.Primitive.C_u128 (self.Core.Primitive._0 *! other.Core.Primitive._0) + <: + Core.Primitive.t_u128 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_35: Core.Ops.Arith.t_Mul Core.Primitive.t_usize Core.Primitive.t_usize = + { + f_Output = Core.Primitive.t_usize; + f_mul_pre = (fun (self: Core.Primitive.t_usize) (other: Core.Primitive.t_usize) -> true); + f_mul_post + = + (fun + (self: Core.Primitive.t_usize) + (other: Core.Primitive.t_usize) + (out: Core.Primitive.t_usize) + -> + true); + f_mul + = + fun (self: Core.Primitive.t_usize) (other: Core.Primitive.t_usize) -> + Core.Primitive.C_usize (self.Core.Primitive._0 *! other.Core.Primitive._0) + <: + Core.Primitive.t_usize + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_36: Core.Ops.Arith.t_Mul Core.Primitive.t_i8 Core.Primitive.t_i8 = + { + f_Output = Core.Primitive.t_i8; + f_mul_pre = (fun (self: Core.Primitive.t_i8) (other: Core.Primitive.t_i8) -> true); + f_mul_post + = + (fun (self: Core.Primitive.t_i8) (other: Core.Primitive.t_i8) (out: Core.Primitive.t_i8) -> true + ); + f_mul + = + fun (self: Core.Primitive.t_i8) (other: Core.Primitive.t_i8) -> + Core.Primitive.C_i8 (self.Core.Primitive._0 *! other.Core.Primitive._0) <: Core.Primitive.t_i8 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_37: Core.Ops.Arith.t_Mul Core.Primitive.t_i16 Core.Primitive.t_i16 = + { + f_Output = Core.Primitive.t_i16; + f_mul_pre = (fun (self: Core.Primitive.t_i16) (other: Core.Primitive.t_i16) -> true); + f_mul_post + = + (fun (self: Core.Primitive.t_i16) (other: Core.Primitive.t_i16) (out: Core.Primitive.t_i16) -> + true); + f_mul + = + fun (self: Core.Primitive.t_i16) (other: Core.Primitive.t_i16) -> + Core.Primitive.C_i16 (self.Core.Primitive._0 *! other.Core.Primitive._0) + <: + Core.Primitive.t_i16 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_38: Core.Ops.Arith.t_Mul Core.Primitive.t_i32 Core.Primitive.t_i32 = + { + f_Output = Core.Primitive.t_i32; + f_mul_pre = (fun (self: Core.Primitive.t_i32) (other: Core.Primitive.t_i32) -> true); + f_mul_post + = + (fun (self: Core.Primitive.t_i32) (other: Core.Primitive.t_i32) (out: Core.Primitive.t_i32) -> + true); + f_mul + = + fun (self: Core.Primitive.t_i32) (other: Core.Primitive.t_i32) -> + Core.Primitive.C_i32 (self.Core.Primitive._0 *! other.Core.Primitive._0) + <: + Core.Primitive.t_i32 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_39: Core.Ops.Arith.t_Mul Core.Primitive.t_i64 Core.Primitive.t_i64 = + { + f_Output = Core.Primitive.t_i64; + f_mul_pre = (fun (self: Core.Primitive.t_i64) (other: Core.Primitive.t_i64) -> true); + f_mul_post + = + (fun (self: Core.Primitive.t_i64) (other: Core.Primitive.t_i64) (out: Core.Primitive.t_i64) -> + true); + f_mul + = + fun (self: Core.Primitive.t_i64) (other: Core.Primitive.t_i64) -> + Core.Primitive.C_i64 (self.Core.Primitive._0 *! other.Core.Primitive._0) + <: + Core.Primitive.t_i64 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_40: Core.Ops.Arith.t_Mul Core.Primitive.t_i128 Core.Primitive.t_i128 = + { + f_Output = Core.Primitive.t_i128; + f_mul_pre = (fun (self: Core.Primitive.t_i128) (other: Core.Primitive.t_i128) -> true); + f_mul_post + = + (fun + (self: Core.Primitive.t_i128) + (other: Core.Primitive.t_i128) + (out: Core.Primitive.t_i128) + -> + true); + f_mul + = + fun (self: Core.Primitive.t_i128) (other: Core.Primitive.t_i128) -> + Core.Primitive.C_i128 (self.Core.Primitive._0 *! other.Core.Primitive._0) + <: + Core.Primitive.t_i128 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_41: Core.Ops.Arith.t_Mul Core.Primitive.t_isize Core.Primitive.t_isize = + { + f_Output = Core.Primitive.t_isize; + f_mul_pre = (fun (self: Core.Primitive.t_isize) (other: Core.Primitive.t_isize) -> true); + f_mul_post + = + (fun + (self: Core.Primitive.t_isize) + (other: Core.Primitive.t_isize) + (out: Core.Primitive.t_isize) + -> + true); + f_mul + = + fun (self: Core.Primitive.t_isize) (other: Core.Primitive.t_isize) -> + Core.Primitive.C_isize (self.Core.Primitive._0 *! other.Core.Primitive._0) + <: + Core.Primitive.t_isize + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_42: Core.Ops.Arith.t_Div Core.Primitive.t_u8 Core.Primitive.t_u8 = + { + f_Output = Core.Primitive.t_u8; + f_div_pre = (fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u8) -> true); + f_div_post + = + (fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u8) (out: Core.Primitive.t_u8) -> true + ); + f_div + = + fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u8) -> + Core.Primitive.C_u8 (self.Core.Primitive._0 /! other.Core.Primitive._0) <: Core.Primitive.t_u8 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_43: Core.Ops.Arith.t_Div Core.Primitive.t_u16 Core.Primitive.t_u16 = + { + f_Output = Core.Primitive.t_u16; + f_div_pre = (fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u16) -> true); + f_div_post + = + (fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u16) (out: Core.Primitive.t_u16) -> + true); + f_div + = + fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u16) -> + Core.Primitive.C_u16 (self.Core.Primitive._0 /! other.Core.Primitive._0) + <: + Core.Primitive.t_u16 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_44: Core.Ops.Arith.t_Div Core.Primitive.t_u32 Core.Primitive.t_u32 = + { + f_Output = Core.Primitive.t_u32; + f_div_pre = (fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u32) -> true); + f_div_post + = + (fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u32) (out: Core.Primitive.t_u32) -> + true); + f_div + = + fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u32) -> + Core.Primitive.C_u32 (self.Core.Primitive._0 /! other.Core.Primitive._0) + <: + Core.Primitive.t_u32 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_45: Core.Ops.Arith.t_Div Core.Primitive.t_u64 Core.Primitive.t_u64 = + { + f_Output = Core.Primitive.t_u64; + f_div_pre = (fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u64) -> true); + f_div_post + = + (fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u64) (out: Core.Primitive.t_u64) -> + true); + f_div + = + fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u64) -> + Core.Primitive.C_u64 (self.Core.Primitive._0 /! other.Core.Primitive._0) + <: + Core.Primitive.t_u64 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_46: Core.Ops.Arith.t_Div Core.Primitive.t_u128 Core.Primitive.t_u128 = + { + f_Output = Core.Primitive.t_u128; + f_div_pre = (fun (self: Core.Primitive.t_u128) (other: Core.Primitive.t_u128) -> true); + f_div_post + = + (fun + (self: Core.Primitive.t_u128) + (other: Core.Primitive.t_u128) + (out: Core.Primitive.t_u128) + -> + true); + f_div + = + fun (self: Core.Primitive.t_u128) (other: Core.Primitive.t_u128) -> + Core.Primitive.C_u128 (self.Core.Primitive._0 /! other.Core.Primitive._0) + <: + Core.Primitive.t_u128 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_47: Core.Ops.Arith.t_Div Core.Primitive.t_usize Core.Primitive.t_usize = + { + f_Output = Core.Primitive.t_usize; + f_div_pre = (fun (self: Core.Primitive.t_usize) (other: Core.Primitive.t_usize) -> true); + f_div_post + = + (fun + (self: Core.Primitive.t_usize) + (other: Core.Primitive.t_usize) + (out: Core.Primitive.t_usize) + -> + true); + f_div + = + fun (self: Core.Primitive.t_usize) (other: Core.Primitive.t_usize) -> + Core.Primitive.C_usize (self.Core.Primitive._0 /! other.Core.Primitive._0) + <: + Core.Primitive.t_usize + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_54: Core.Ops.Arith.t_Rem Core.Primitive.t_u8 Core.Primitive.t_u8 = + { + f_Output = Core.Primitive.t_u8; + f_rem_pre = (fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u8) -> true); + f_rem_post + = + (fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u8) (out: Core.Primitive.t_u8) -> true + ); + f_rem + = + fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u8) -> + Core.Primitive.C_u8 (self.Core.Primitive._0 %! other.Core.Primitive._0) <: Core.Primitive.t_u8 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_55: Core.Ops.Arith.t_Rem Core.Primitive.t_u16 Core.Primitive.t_u16 = + { + f_Output = Core.Primitive.t_u16; + f_rem_pre = (fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u16) -> true); + f_rem_post + = + (fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u16) (out: Core.Primitive.t_u16) -> + true); + f_rem + = + fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u16) -> + Core.Primitive.C_u16 (self.Core.Primitive._0 %! other.Core.Primitive._0) + <: + Core.Primitive.t_u16 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_56: Core.Ops.Arith.t_Rem Core.Primitive.t_u32 Core.Primitive.t_u32 = + { + f_Output = Core.Primitive.t_u32; + f_rem_pre = (fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u32) -> true); + f_rem_post + = + (fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u32) (out: Core.Primitive.t_u32) -> + true); + f_rem + = + fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u32) -> + Core.Primitive.C_u32 (self.Core.Primitive._0 %! other.Core.Primitive._0) + <: + Core.Primitive.t_u32 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_57: Core.Ops.Arith.t_Rem Core.Primitive.t_u64 Core.Primitive.t_u64 = + { + f_Output = Core.Primitive.t_u64; + f_rem_pre = (fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u64) -> true); + f_rem_post + = + (fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u64) (out: Core.Primitive.t_u64) -> + true); + f_rem + = + fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u64) -> + Core.Primitive.C_u64 (self.Core.Primitive._0 %! other.Core.Primitive._0) + <: + Core.Primitive.t_u64 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_58: Core.Ops.Arith.t_Rem Core.Primitive.t_u128 Core.Primitive.t_u128 = + { + f_Output = Core.Primitive.t_u128; + f_rem_pre = (fun (self: Core.Primitive.t_u128) (other: Core.Primitive.t_u128) -> true); + f_rem_post + = + (fun + (self: Core.Primitive.t_u128) + (other: Core.Primitive.t_u128) + (out: Core.Primitive.t_u128) + -> + true); + f_rem + = + fun (self: Core.Primitive.t_u128) (other: Core.Primitive.t_u128) -> + Core.Primitive.C_u128 (self.Core.Primitive._0 %! other.Core.Primitive._0) + <: + Core.Primitive.t_u128 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_59: Core.Ops.Arith.t_Rem Core.Primitive.t_usize Core.Primitive.t_usize = + { + f_Output = Core.Primitive.t_usize; + f_rem_pre = (fun (self: Core.Primitive.t_usize) (other: Core.Primitive.t_usize) -> true); + f_rem_post + = + (fun + (self: Core.Primitive.t_usize) + (other: Core.Primitive.t_usize) + (out: Core.Primitive.t_usize) + -> + true); + f_rem + = + fun (self: Core.Primitive.t_usize) (other: Core.Primitive.t_usize) -> + Core.Primitive.C_usize (self.Core.Primitive._0 %! other.Core.Primitive._0) + <: + Core.Primitive.t_usize + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_18: Core.Ops.Arith.t_Sub Core.Primitive.t_u8 Core.Primitive.t_u8 = + { + f_Output = Core.Primitive.t_u8; + f_sub_pre = (fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u8) -> true); + f_sub_post + = + (fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u8) (out: Core.Primitive.t_u8) -> true + ); + f_sub + = + fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u8) -> + Core.Primitive.C_u8 (self.Core.Primitive._0 -! other.Core.Primitive._0) <: Core.Primitive.t_u8 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_19: Core.Ops.Arith.t_Sub Core.Primitive.t_u16 Core.Primitive.t_u16 = + { + f_Output = Core.Primitive.t_u16; + f_sub_pre = (fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u16) -> true); + f_sub_post + = + (fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u16) (out: Core.Primitive.t_u16) -> + true); + f_sub + = + fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u16) -> + Core.Primitive.C_u16 (self.Core.Primitive._0 -! other.Core.Primitive._0) + <: + Core.Primitive.t_u16 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_20: Core.Ops.Arith.t_Sub Core.Primitive.t_u32 Core.Primitive.t_u32 = + { + f_Output = Core.Primitive.t_u32; + f_sub_pre = (fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u32) -> true); + f_sub_post + = + (fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u32) (out: Core.Primitive.t_u32) -> + true); + f_sub + = + fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u32) -> + Core.Primitive.C_u32 (self.Core.Primitive._0 -! other.Core.Primitive._0) + <: + Core.Primitive.t_u32 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_21: Core.Ops.Arith.t_Sub Core.Primitive.t_u64 Core.Primitive.t_u64 = + { + f_Output = Core.Primitive.t_u64; + f_sub_pre = (fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u64) -> true); + f_sub_post + = + (fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u64) (out: Core.Primitive.t_u64) -> + true); + f_sub + = + fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u64) -> + Core.Primitive.C_u64 (self.Core.Primitive._0 -! other.Core.Primitive._0) + <: + Core.Primitive.t_u64 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_22: Core.Ops.Arith.t_Sub Core.Primitive.t_u128 Core.Primitive.t_u128 = + { + f_Output = Core.Primitive.t_u128; + f_sub_pre = (fun (self: Core.Primitive.t_u128) (other: Core.Primitive.t_u128) -> true); + f_sub_post + = + (fun + (self: Core.Primitive.t_u128) + (other: Core.Primitive.t_u128) + (out: Core.Primitive.t_u128) + -> + true); + f_sub + = + fun (self: Core.Primitive.t_u128) (other: Core.Primitive.t_u128) -> + Core.Primitive.C_u128 (self.Core.Primitive._0 -! other.Core.Primitive._0) + <: + Core.Primitive.t_u128 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_23: Core.Ops.Arith.t_Sub Core.Primitive.t_usize Core.Primitive.t_usize = + { + f_Output = Core.Primitive.t_usize; + f_sub_pre = (fun (self: Core.Primitive.t_usize) (other: Core.Primitive.t_usize) -> true); + f_sub_post + = + (fun + (self: Core.Primitive.t_usize) + (other: Core.Primitive.t_usize) + (out: Core.Primitive.t_usize) + -> + true); + f_sub + = + fun (self: Core.Primitive.t_usize) (other: Core.Primitive.t_usize) -> + Core.Primitive.C_usize (self.Core.Primitive._0 -! other.Core.Primitive._0) + <: + Core.Primitive.t_usize + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_48: Core.Ops.Arith.t_Div Core.Primitive.t_i8 Core.Primitive.t_i8 = + { + f_Output = Core.Primitive.t_i8; + f_div_pre = (fun (self: Core.Primitive.t_i8) (other: Core.Primitive.t_i8) -> true); + f_div_post + = + (fun (self: Core.Primitive.t_i8) (other: Core.Primitive.t_i8) (out: Core.Primitive.t_i8) -> true + ); + f_div + = + fun (self: Core.Primitive.t_i8) (other: Core.Primitive.t_i8) -> + Core.Primitive.C_i8 (self.Core.Primitive._0 /! other.Core.Primitive._0) <: Core.Primitive.t_i8 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_49: Core.Ops.Arith.t_Div Core.Primitive.t_i16 Core.Primitive.t_i16 = + { + f_Output = Core.Primitive.t_i16; + f_div_pre = (fun (self: Core.Primitive.t_i16) (other: Core.Primitive.t_i16) -> true); + f_div_post + = + (fun (self: Core.Primitive.t_i16) (other: Core.Primitive.t_i16) (out: Core.Primitive.t_i16) -> + true); + f_div + = + fun (self: Core.Primitive.t_i16) (other: Core.Primitive.t_i16) -> + Core.Primitive.C_i16 (self.Core.Primitive._0 /! other.Core.Primitive._0) + <: + Core.Primitive.t_i16 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_50: Core.Ops.Arith.t_Div Core.Primitive.t_i32 Core.Primitive.t_i32 = + { + f_Output = Core.Primitive.t_i32; + f_div_pre = (fun (self: Core.Primitive.t_i32) (other: Core.Primitive.t_i32) -> true); + f_div_post + = + (fun (self: Core.Primitive.t_i32) (other: Core.Primitive.t_i32) (out: Core.Primitive.t_i32) -> + true); + f_div + = + fun (self: Core.Primitive.t_i32) (other: Core.Primitive.t_i32) -> + Core.Primitive.C_i32 (self.Core.Primitive._0 /! other.Core.Primitive._0) + <: + Core.Primitive.t_i32 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_51: Core.Ops.Arith.t_Div Core.Primitive.t_i64 Core.Primitive.t_i64 = + { + f_Output = Core.Primitive.t_i64; + f_div_pre = (fun (self: Core.Primitive.t_i64) (other: Core.Primitive.t_i64) -> true); + f_div_post + = + (fun (self: Core.Primitive.t_i64) (other: Core.Primitive.t_i64) (out: Core.Primitive.t_i64) -> + true); + f_div + = + fun (self: Core.Primitive.t_i64) (other: Core.Primitive.t_i64) -> + Core.Primitive.C_i64 (self.Core.Primitive._0 /! other.Core.Primitive._0) + <: + Core.Primitive.t_i64 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_52: Core.Ops.Arith.t_Div Core.Primitive.t_i128 Core.Primitive.t_i128 = + { + f_Output = Core.Primitive.t_i128; + f_div_pre = (fun (self: Core.Primitive.t_i128) (other: Core.Primitive.t_i128) -> true); + f_div_post + = + (fun + (self: Core.Primitive.t_i128) + (other: Core.Primitive.t_i128) + (out: Core.Primitive.t_i128) + -> + true); + f_div + = + fun (self: Core.Primitive.t_i128) (other: Core.Primitive.t_i128) -> + Core.Primitive.C_i128 (self.Core.Primitive._0 /! other.Core.Primitive._0) + <: + Core.Primitive.t_i128 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_53: Core.Ops.Arith.t_Div Core.Primitive.t_isize Core.Primitive.t_isize = + { + f_Output = Core.Primitive.t_isize; + f_div_pre = (fun (self: Core.Primitive.t_isize) (other: Core.Primitive.t_isize) -> true); + f_div_post + = + (fun + (self: Core.Primitive.t_isize) + (other: Core.Primitive.t_isize) + (out: Core.Primitive.t_isize) + -> + true); + f_div + = + fun (self: Core.Primitive.t_isize) (other: Core.Primitive.t_isize) -> + Core.Primitive.C_isize (self.Core.Primitive._0 /! other.Core.Primitive._0) + <: + Core.Primitive.t_isize + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_60: Core.Ops.Arith.t_Rem Core.Primitive.t_i8 Core.Primitive.t_i8 = + { + f_Output = Core.Primitive.t_i8; + f_rem_pre = (fun (self: Core.Primitive.t_i8) (other: Core.Primitive.t_i8) -> true); + f_rem_post + = + (fun (self: Core.Primitive.t_i8) (other: Core.Primitive.t_i8) (out: Core.Primitive.t_i8) -> true + ); + f_rem + = + fun (self: Core.Primitive.t_i8) (other: Core.Primitive.t_i8) -> + Core.Primitive.C_i8 (self.Core.Primitive._0 %! other.Core.Primitive._0) <: Core.Primitive.t_i8 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_61: Core.Ops.Arith.t_Rem Core.Primitive.t_i16 Core.Primitive.t_i16 = + { + f_Output = Core.Primitive.t_i16; + f_rem_pre = (fun (self: Core.Primitive.t_i16) (other: Core.Primitive.t_i16) -> true); + f_rem_post + = + (fun (self: Core.Primitive.t_i16) (other: Core.Primitive.t_i16) (out: Core.Primitive.t_i16) -> + true); + f_rem + = + fun (self: Core.Primitive.t_i16) (other: Core.Primitive.t_i16) -> + Core.Primitive.C_i16 (self.Core.Primitive._0 %! other.Core.Primitive._0) + <: + Core.Primitive.t_i16 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_62: Core.Ops.Arith.t_Rem Core.Primitive.t_i32 Core.Primitive.t_i32 = + { + f_Output = Core.Primitive.t_i32; + f_rem_pre = (fun (self: Core.Primitive.t_i32) (other: Core.Primitive.t_i32) -> true); + f_rem_post + = + (fun (self: Core.Primitive.t_i32) (other: Core.Primitive.t_i32) (out: Core.Primitive.t_i32) -> + true); + f_rem + = + fun (self: Core.Primitive.t_i32) (other: Core.Primitive.t_i32) -> + Core.Primitive.C_i32 (self.Core.Primitive._0 %! other.Core.Primitive._0) + <: + Core.Primitive.t_i32 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_63: Core.Ops.Arith.t_Rem Core.Primitive.t_i64 Core.Primitive.t_i64 = + { + f_Output = Core.Primitive.t_i64; + f_rem_pre = (fun (self: Core.Primitive.t_i64) (other: Core.Primitive.t_i64) -> true); + f_rem_post + = + (fun (self: Core.Primitive.t_i64) (other: Core.Primitive.t_i64) (out: Core.Primitive.t_i64) -> + true); + f_rem + = + fun (self: Core.Primitive.t_i64) (other: Core.Primitive.t_i64) -> + Core.Primitive.C_i64 (self.Core.Primitive._0 %! other.Core.Primitive._0) + <: + Core.Primitive.t_i64 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_64: Core.Ops.Arith.t_Rem Core.Primitive.t_i128 Core.Primitive.t_i128 = + { + f_Output = Core.Primitive.t_i128; + f_rem_pre = (fun (self: Core.Primitive.t_i128) (other: Core.Primitive.t_i128) -> true); + f_rem_post + = + (fun + (self: Core.Primitive.t_i128) + (other: Core.Primitive.t_i128) + (out: Core.Primitive.t_i128) + -> + true); + f_rem + = + fun (self: Core.Primitive.t_i128) (other: Core.Primitive.t_i128) -> + Core.Primitive.C_i128 (self.Core.Primitive._0 %! other.Core.Primitive._0) + <: + Core.Primitive.t_i128 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_65: Core.Ops.Arith.t_Rem Core.Primitive.t_isize Core.Primitive.t_isize = + { + f_Output = Core.Primitive.t_isize; + f_rem_pre = (fun (self: Core.Primitive.t_isize) (other: Core.Primitive.t_isize) -> true); + f_rem_post + = + (fun + (self: Core.Primitive.t_isize) + (other: Core.Primitive.t_isize) + (out: Core.Primitive.t_isize) + -> + true); + f_rem + = + fun (self: Core.Primitive.t_isize) (other: Core.Primitive.t_isize) -> + Core.Primitive.C_isize (self.Core.Primitive._0 %! other.Core.Primitive._0) + <: + Core.Primitive.t_isize + } diff --git a/proof-libs/fstar/generated_core/Core.Ops.Arith.fst b/proof-libs/fstar/generated_core/Core.Ops.Arith.fst new file mode 100644 index 000000000..7bbf57888 --- /dev/null +++ b/proof-libs/fstar/generated_core/Core.Ops.Arith.fst @@ -0,0 +1,51 @@ +module Core.Ops.Arith +#set-options "--fuel 0 --ifuel 1 --z3rlimit 15" +open Core +open FStar.Mul + +class t_Add (v_Self: Type0) (v_Rhs: Type0) = { + f_Output:Type0; + f_add_pre:v_Self -> v_Rhs -> Type0; + f_add_post:v_Self -> v_Rhs -> f_Output -> Type0; + f_add:x0: v_Self -> x1: v_Rhs + -> Prims.Pure f_Output (f_add_pre x0 x1) (fun result -> f_add_post x0 x1 result) +} + +class t_Div (v_Self: Type0) (v_Rhs: Type0) = { + f_Output:Type0; + f_div_pre:v_Self -> v_Rhs -> Type0; + f_div_post:v_Self -> v_Rhs -> f_Output -> Type0; + f_div:x0: v_Self -> x1: v_Rhs + -> Prims.Pure f_Output (f_div_pre x0 x1) (fun result -> f_div_post x0 x1 result) +} + +class t_Mul (v_Self: Type0) (v_Rhs: Type0) = { + f_Output:Type0; + f_mul_pre:v_Self -> v_Rhs -> Type0; + f_mul_post:v_Self -> v_Rhs -> f_Output -> Type0; + f_mul:x0: v_Self -> x1: v_Rhs + -> Prims.Pure f_Output (f_mul_pre x0 x1) (fun result -> f_mul_post x0 x1 result) +} + +class t_Neg (v_Self: Type0) = { + f_Output:Type0; + f_neg_pre:v_Self -> Type0; + f_neg_post:v_Self -> f_Output -> Type0; + f_neg:x0: v_Self -> Prims.Pure f_Output (f_neg_pre x0) (fun result -> f_neg_post x0 result) +} + +class t_Rem (v_Self: Type0) (v_Rhs: Type0) = { + f_Output:Type0; + f_rem_pre:v_Self -> v_Rhs -> Type0; + f_rem_post:v_Self -> v_Rhs -> f_Output -> Type0; + f_rem:x0: v_Self -> x1: v_Rhs + -> Prims.Pure f_Output (f_rem_pre x0 x1) (fun result -> f_rem_post x0 x1 result) +} + +class t_Sub (v_Self: Type0) (v_Rhs: Type0) = { + f_Output:Type0; + f_sub_pre:v_Self -> v_Rhs -> Type0; + f_sub_post:v_Self -> v_Rhs -> f_Output -> Type0; + f_sub:x0: v_Self -> x1: v_Rhs + -> Prims.Pure f_Output (f_sub_pre x0 x1) (fun result -> f_sub_post x0 x1 result) +} diff --git a/proof-libs/fstar/generated_core/Core.Ops.Bit.Impls_for_prims.fst b/proof-libs/fstar/generated_core/Core.Ops.Bit.Impls_for_prims.fst new file mode 100644 index 000000000..e517afe1f --- /dev/null +++ b/proof-libs/fstar/generated_core/Core.Ops.Bit.Impls_for_prims.fst @@ -0,0 +1,1796 @@ +module Core.Ops.Bit.Impls_for_prims +#set-options "--fuel 0 --ifuel 1 --z3rlimit 15" +open Core +open FStar.Mul + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_84: Core.Ops.Bit.t_BitOr Core.Primitive.t_i8 Core.Primitive.t_i8 = + { + f_Output = Core.Primitive.t_i8; + f_bitor_pre = (fun (self: Core.Primitive.t_i8) (other: Core.Primitive.t_i8) -> true); + f_bitor_post + = + (fun (self: Core.Primitive.t_i8) (other: Core.Primitive.t_i8) (out: Core.Primitive.t_i8) -> true + ); + f_bitor + = + fun (self: Core.Primitive.t_i8) (other: Core.Primitive.t_i8) -> + Core.Primitive.C_i8 (self.Core.Primitive._0 |. other.Core.Primitive._0) <: Core.Primitive.t_i8 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_85: Core.Ops.Bit.t_BitOr Core.Primitive.t_i16 Core.Primitive.t_i16 = + { + f_Output = Core.Primitive.t_i16; + f_bitor_pre = (fun (self: Core.Primitive.t_i16) (other: Core.Primitive.t_i16) -> true); + f_bitor_post + = + (fun (self: Core.Primitive.t_i16) (other: Core.Primitive.t_i16) (out: Core.Primitive.t_i16) -> + true); + f_bitor + = + fun (self: Core.Primitive.t_i16) (other: Core.Primitive.t_i16) -> + Core.Primitive.C_i16 (self.Core.Primitive._0 |. other.Core.Primitive._0) + <: + Core.Primitive.t_i16 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_86: Core.Ops.Bit.t_BitOr Core.Primitive.t_i32 Core.Primitive.t_i32 = + { + f_Output = Core.Primitive.t_i32; + f_bitor_pre = (fun (self: Core.Primitive.t_i32) (other: Core.Primitive.t_i32) -> true); + f_bitor_post + = + (fun (self: Core.Primitive.t_i32) (other: Core.Primitive.t_i32) (out: Core.Primitive.t_i32) -> + true); + f_bitor + = + fun (self: Core.Primitive.t_i32) (other: Core.Primitive.t_i32) -> + Core.Primitive.C_i32 (self.Core.Primitive._0 |. other.Core.Primitive._0) + <: + Core.Primitive.t_i32 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_87: Core.Ops.Bit.t_BitOr Core.Primitive.t_i64 Core.Primitive.t_i64 = + { + f_Output = Core.Primitive.t_i64; + f_bitor_pre = (fun (self: Core.Primitive.t_i64) (other: Core.Primitive.t_i64) -> true); + f_bitor_post + = + (fun (self: Core.Primitive.t_i64) (other: Core.Primitive.t_i64) (out: Core.Primitive.t_i64) -> + true); + f_bitor + = + fun (self: Core.Primitive.t_i64) (other: Core.Primitive.t_i64) -> + Core.Primitive.C_i64 (self.Core.Primitive._0 |. other.Core.Primitive._0) + <: + Core.Primitive.t_i64 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_88: Core.Ops.Bit.t_BitOr Core.Primitive.t_i128 Core.Primitive.t_i128 = + { + f_Output = Core.Primitive.t_i128; + f_bitor_pre = (fun (self: Core.Primitive.t_i128) (other: Core.Primitive.t_i128) -> true); + f_bitor_post + = + (fun + (self: Core.Primitive.t_i128) + (other: Core.Primitive.t_i128) + (out: Core.Primitive.t_i128) + -> + true); + f_bitor + = + fun (self: Core.Primitive.t_i128) (other: Core.Primitive.t_i128) -> + Core.Primitive.C_i128 (self.Core.Primitive._0 |. other.Core.Primitive._0) + <: + Core.Primitive.t_i128 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_89: Core.Ops.Bit.t_BitOr Core.Primitive.t_isize Core.Primitive.t_isize = + { + f_Output = Core.Primitive.t_isize; + f_bitor_pre = (fun (self: Core.Primitive.t_isize) (other: Core.Primitive.t_isize) -> true); + f_bitor_post + = + (fun + (self: Core.Primitive.t_isize) + (other: Core.Primitive.t_isize) + (out: Core.Primitive.t_isize) + -> + true); + f_bitor + = + fun (self: Core.Primitive.t_isize) (other: Core.Primitive.t_isize) -> + Core.Primitive.C_isize (self.Core.Primitive._0 |. other.Core.Primitive._0) + <: + Core.Primitive.t_isize + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_6: Core.Ops.Bit.t_Shr Core.Primitive.t_u8 Core.Primitive.t_u8 = + { + f_Output = Core.Primitive.t_u8; + f_shr_pre = (fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u8) -> true); + f_shr_post + = + (fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u8) (out: Core.Primitive.t_u8) -> true + ); + f_shr + = + fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u8) -> + Core.Primitive.C_u8 (self.Core.Primitive._0 >>! other.Core.Primitive._0) + <: + Core.Primitive.t_u8 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_7: Core.Ops.Bit.t_Shr Core.Primitive.t_u8 Core.Primitive.t_u16 = + { + f_Output = Core.Primitive.t_u8; + f_shr_pre = (fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u16) -> true); + f_shr_post + = + (fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u16) (out: Core.Primitive.t_u8) -> + true); + f_shr + = + fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u16) -> + Core.Primitive.C_u8 (self.Core.Primitive._0 >>! other.Core.Primitive._0) + <: + Core.Primitive.t_u8 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_8: Core.Ops.Bit.t_Shr Core.Primitive.t_u8 Core.Primitive.t_u32 = + { + f_Output = Core.Primitive.t_u8; + f_shr_pre = (fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u32) -> true); + f_shr_post + = + (fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u32) (out: Core.Primitive.t_u8) -> + true); + f_shr + = + fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u32) -> + Core.Primitive.C_u8 (self.Core.Primitive._0 >>! other.Core.Primitive._0) + <: + Core.Primitive.t_u8 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_9: Core.Ops.Bit.t_Shr Core.Primitive.t_u8 Core.Primitive.t_u64 = + { + f_Output = Core.Primitive.t_u8; + f_shr_pre = (fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u64) -> true); + f_shr_post + = + (fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u64) (out: Core.Primitive.t_u8) -> + true); + f_shr + = + fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u64) -> + Core.Primitive.C_u8 (self.Core.Primitive._0 >>! other.Core.Primitive._0) + <: + Core.Primitive.t_u8 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_10: Core.Ops.Bit.t_Shr Core.Primitive.t_u8 Core.Primitive.t_u128 = + { + f_Output = Core.Primitive.t_u8; + f_shr_pre = (fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u128) -> true); + f_shr_post + = + (fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u128) (out: Core.Primitive.t_u8) -> + true); + f_shr + = + fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u128) -> + Core.Primitive.C_u8 (self.Core.Primitive._0 >>! other.Core.Primitive._0) + <: + Core.Primitive.t_u8 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_11: Core.Ops.Bit.t_Shr Core.Primitive.t_u8 Core.Primitive.t_usize = + { + f_Output = Core.Primitive.t_u8; + f_shr_pre = (fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_usize) -> true); + f_shr_post + = + (fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_usize) (out: Core.Primitive.t_u8) -> + true); + f_shr + = + fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_usize) -> + Core.Primitive.C_u8 (self.Core.Primitive._0 >>! other.Core.Primitive._0) + <: + Core.Primitive.t_u8 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_12: Core.Ops.Bit.t_Shr Core.Primitive.t_u16 Core.Primitive.t_u8 = + { + f_Output = Core.Primitive.t_u16; + f_shr_pre = (fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u8) -> true); + f_shr_post + = + (fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u8) (out: Core.Primitive.t_u16) -> + true); + f_shr + = + fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u8) -> + Core.Primitive.C_u16 (self.Core.Primitive._0 >>! other.Core.Primitive._0) + <: + Core.Primitive.t_u16 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_13: Core.Ops.Bit.t_Shr Core.Primitive.t_u16 Core.Primitive.t_u16 = + { + f_Output = Core.Primitive.t_u16; + f_shr_pre = (fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u16) -> true); + f_shr_post + = + (fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u16) (out: Core.Primitive.t_u16) -> + true); + f_shr + = + fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u16) -> + Core.Primitive.C_u16 (self.Core.Primitive._0 >>! other.Core.Primitive._0) + <: + Core.Primitive.t_u16 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_14: Core.Ops.Bit.t_Shr Core.Primitive.t_u16 Core.Primitive.t_u32 = + { + f_Output = Core.Primitive.t_u16; + f_shr_pre = (fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u32) -> true); + f_shr_post + = + (fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u32) (out: Core.Primitive.t_u16) -> + true); + f_shr + = + fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u32) -> + Core.Primitive.C_u16 (self.Core.Primitive._0 >>! other.Core.Primitive._0) + <: + Core.Primitive.t_u16 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_15: Core.Ops.Bit.t_Shr Core.Primitive.t_u16 Core.Primitive.t_u64 = + { + f_Output = Core.Primitive.t_u16; + f_shr_pre = (fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u64) -> true); + f_shr_post + = + (fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u64) (out: Core.Primitive.t_u16) -> + true); + f_shr + = + fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u64) -> + Core.Primitive.C_u16 (self.Core.Primitive._0 >>! other.Core.Primitive._0) + <: + Core.Primitive.t_u16 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_16: Core.Ops.Bit.t_Shr Core.Primitive.t_u16 Core.Primitive.t_u128 = + { + f_Output = Core.Primitive.t_u16; + f_shr_pre = (fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u128) -> true); + f_shr_post + = + (fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u128) (out: Core.Primitive.t_u16) -> + true); + f_shr + = + fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u128) -> + Core.Primitive.C_u16 (self.Core.Primitive._0 >>! other.Core.Primitive._0) + <: + Core.Primitive.t_u16 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_17: Core.Ops.Bit.t_Shr Core.Primitive.t_u16 Core.Primitive.t_usize = + { + f_Output = Core.Primitive.t_u16; + f_shr_pre = (fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_usize) -> true); + f_shr_post + = + (fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_usize) (out: Core.Primitive.t_u16) -> + true); + f_shr + = + fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_usize) -> + Core.Primitive.C_u16 (self.Core.Primitive._0 >>! other.Core.Primitive._0) + <: + Core.Primitive.t_u16 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_18: Core.Ops.Bit.t_Shr Core.Primitive.t_u32 Core.Primitive.t_u8 = + { + f_Output = Core.Primitive.t_u32; + f_shr_pre = (fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u8) -> true); + f_shr_post + = + (fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u8) (out: Core.Primitive.t_u32) -> + true); + f_shr + = + fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u8) -> + Core.Primitive.C_u32 (self.Core.Primitive._0 >>! other.Core.Primitive._0) + <: + Core.Primitive.t_u32 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_19: Core.Ops.Bit.t_Shr Core.Primitive.t_u32 Core.Primitive.t_u16 = + { + f_Output = Core.Primitive.t_u32; + f_shr_pre = (fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u16) -> true); + f_shr_post + = + (fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u16) (out: Core.Primitive.t_u32) -> + true); + f_shr + = + fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u16) -> + Core.Primitive.C_u32 (self.Core.Primitive._0 >>! other.Core.Primitive._0) + <: + Core.Primitive.t_u32 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_20: Core.Ops.Bit.t_Shr Core.Primitive.t_u32 Core.Primitive.t_u32 = + { + f_Output = Core.Primitive.t_u32; + f_shr_pre = (fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u32) -> true); + f_shr_post + = + (fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u32) (out: Core.Primitive.t_u32) -> + true); + f_shr + = + fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u32) -> + Core.Primitive.C_u32 (self.Core.Primitive._0 >>! other.Core.Primitive._0) + <: + Core.Primitive.t_u32 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_21: Core.Ops.Bit.t_Shr Core.Primitive.t_u32 Core.Primitive.t_u64 = + { + f_Output = Core.Primitive.t_u32; + f_shr_pre = (fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u64) -> true); + f_shr_post + = + (fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u64) (out: Core.Primitive.t_u32) -> + true); + f_shr + = + fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u64) -> + Core.Primitive.C_u32 (self.Core.Primitive._0 >>! other.Core.Primitive._0) + <: + Core.Primitive.t_u32 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_22: Core.Ops.Bit.t_Shr Core.Primitive.t_u32 Core.Primitive.t_u128 = + { + f_Output = Core.Primitive.t_u32; + f_shr_pre = (fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u128) -> true); + f_shr_post + = + (fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u128) (out: Core.Primitive.t_u32) -> + true); + f_shr + = + fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u128) -> + Core.Primitive.C_u32 (self.Core.Primitive._0 >>! other.Core.Primitive._0) + <: + Core.Primitive.t_u32 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_23: Core.Ops.Bit.t_Shr Core.Primitive.t_u32 Core.Primitive.t_usize = + { + f_Output = Core.Primitive.t_u32; + f_shr_pre = (fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_usize) -> true); + f_shr_post + = + (fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_usize) (out: Core.Primitive.t_u32) -> + true); + f_shr + = + fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_usize) -> + Core.Primitive.C_u32 (self.Core.Primitive._0 >>! other.Core.Primitive._0) + <: + Core.Primitive.t_u32 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_24: Core.Ops.Bit.t_Shr Core.Primitive.t_u64 Core.Primitive.t_u8 = + { + f_Output = Core.Primitive.t_u64; + f_shr_pre = (fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u8) -> true); + f_shr_post + = + (fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u8) (out: Core.Primitive.t_u64) -> + true); + f_shr + = + fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u8) -> + Core.Primitive.C_u64 (self.Core.Primitive._0 >>! other.Core.Primitive._0) + <: + Core.Primitive.t_u64 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_25: Core.Ops.Bit.t_Shr Core.Primitive.t_u64 Core.Primitive.t_u16 = + { + f_Output = Core.Primitive.t_u64; + f_shr_pre = (fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u16) -> true); + f_shr_post + = + (fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u16) (out: Core.Primitive.t_u64) -> + true); + f_shr + = + fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u16) -> + Core.Primitive.C_u64 (self.Core.Primitive._0 >>! other.Core.Primitive._0) + <: + Core.Primitive.t_u64 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_26: Core.Ops.Bit.t_Shr Core.Primitive.t_u64 Core.Primitive.t_u32 = + { + f_Output = Core.Primitive.t_u64; + f_shr_pre = (fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u32) -> true); + f_shr_post + = + (fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u32) (out: Core.Primitive.t_u64) -> + true); + f_shr + = + fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u32) -> + Core.Primitive.C_u64 (self.Core.Primitive._0 >>! other.Core.Primitive._0) + <: + Core.Primitive.t_u64 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_27: Core.Ops.Bit.t_Shr Core.Primitive.t_u64 Core.Primitive.t_u64 = + { + f_Output = Core.Primitive.t_u64; + f_shr_pre = (fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u64) -> true); + f_shr_post + = + (fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u64) (out: Core.Primitive.t_u64) -> + true); + f_shr + = + fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u64) -> + Core.Primitive.C_u64 (self.Core.Primitive._0 >>! other.Core.Primitive._0) + <: + Core.Primitive.t_u64 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_28: Core.Ops.Bit.t_Shr Core.Primitive.t_u64 Core.Primitive.t_u128 = + { + f_Output = Core.Primitive.t_u64; + f_shr_pre = (fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u128) -> true); + f_shr_post + = + (fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u128) (out: Core.Primitive.t_u64) -> + true); + f_shr + = + fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u128) -> + Core.Primitive.C_u64 (self.Core.Primitive._0 >>! other.Core.Primitive._0) + <: + Core.Primitive.t_u64 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_29: Core.Ops.Bit.t_Shr Core.Primitive.t_u64 Core.Primitive.t_usize = + { + f_Output = Core.Primitive.t_u64; + f_shr_pre = (fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_usize) -> true); + f_shr_post + = + (fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_usize) (out: Core.Primitive.t_u64) -> + true); + f_shr + = + fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_usize) -> + Core.Primitive.C_u64 (self.Core.Primitive._0 >>! other.Core.Primitive._0) + <: + Core.Primitive.t_u64 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_30: Core.Ops.Bit.t_Shr Core.Primitive.t_u128 Core.Primitive.t_u8 = + { + f_Output = Core.Primitive.t_u128; + f_shr_pre = (fun (self: Core.Primitive.t_u128) (other: Core.Primitive.t_u8) -> true); + f_shr_post + = + (fun (self: Core.Primitive.t_u128) (other: Core.Primitive.t_u8) (out: Core.Primitive.t_u128) -> + true); + f_shr + = + fun (self: Core.Primitive.t_u128) (other: Core.Primitive.t_u8) -> + Core.Primitive.C_u128 (self.Core.Primitive._0 >>! other.Core.Primitive._0) + <: + Core.Primitive.t_u128 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_31: Core.Ops.Bit.t_Shr Core.Primitive.t_u128 Core.Primitive.t_u16 = + { + f_Output = Core.Primitive.t_u128; + f_shr_pre = (fun (self: Core.Primitive.t_u128) (other: Core.Primitive.t_u16) -> true); + f_shr_post + = + (fun (self: Core.Primitive.t_u128) (other: Core.Primitive.t_u16) (out: Core.Primitive.t_u128) -> + true); + f_shr + = + fun (self: Core.Primitive.t_u128) (other: Core.Primitive.t_u16) -> + Core.Primitive.C_u128 (self.Core.Primitive._0 >>! other.Core.Primitive._0) + <: + Core.Primitive.t_u128 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_32: Core.Ops.Bit.t_Shr Core.Primitive.t_u128 Core.Primitive.t_u32 = + { + f_Output = Core.Primitive.t_u128; + f_shr_pre = (fun (self: Core.Primitive.t_u128) (other: Core.Primitive.t_u32) -> true); + f_shr_post + = + (fun (self: Core.Primitive.t_u128) (other: Core.Primitive.t_u32) (out: Core.Primitive.t_u128) -> + true); + f_shr + = + fun (self: Core.Primitive.t_u128) (other: Core.Primitive.t_u32) -> + Core.Primitive.C_u128 (self.Core.Primitive._0 >>! other.Core.Primitive._0) + <: + Core.Primitive.t_u128 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_33: Core.Ops.Bit.t_Shr Core.Primitive.t_u128 Core.Primitive.t_u64 = + { + f_Output = Core.Primitive.t_u128; + f_shr_pre = (fun (self: Core.Primitive.t_u128) (other: Core.Primitive.t_u64) -> true); + f_shr_post + = + (fun (self: Core.Primitive.t_u128) (other: Core.Primitive.t_u64) (out: Core.Primitive.t_u128) -> + true); + f_shr + = + fun (self: Core.Primitive.t_u128) (other: Core.Primitive.t_u64) -> + Core.Primitive.C_u128 (self.Core.Primitive._0 >>! other.Core.Primitive._0) + <: + Core.Primitive.t_u128 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_34: Core.Ops.Bit.t_Shr Core.Primitive.t_u128 Core.Primitive.t_u128 = + { + f_Output = Core.Primitive.t_u128; + f_shr_pre = (fun (self: Core.Primitive.t_u128) (other: Core.Primitive.t_u128) -> true); + f_shr_post + = + (fun + (self: Core.Primitive.t_u128) + (other: Core.Primitive.t_u128) + (out: Core.Primitive.t_u128) + -> + true); + f_shr + = + fun (self: Core.Primitive.t_u128) (other: Core.Primitive.t_u128) -> + Core.Primitive.C_u128 (self.Core.Primitive._0 >>! other.Core.Primitive._0) + <: + Core.Primitive.t_u128 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_35: Core.Ops.Bit.t_Shr Core.Primitive.t_u128 Core.Primitive.t_usize = + { + f_Output = Core.Primitive.t_u128; + f_shr_pre = (fun (self: Core.Primitive.t_u128) (other: Core.Primitive.t_usize) -> true); + f_shr_post + = + (fun + (self: Core.Primitive.t_u128) + (other: Core.Primitive.t_usize) + (out: Core.Primitive.t_u128) + -> + true); + f_shr + = + fun (self: Core.Primitive.t_u128) (other: Core.Primitive.t_usize) -> + Core.Primitive.C_u128 (self.Core.Primitive._0 >>! other.Core.Primitive._0) + <: + Core.Primitive.t_u128 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_36: Core.Ops.Bit.t_Shr Core.Primitive.t_usize Core.Primitive.t_u8 = + { + f_Output = Core.Primitive.t_usize; + f_shr_pre = (fun (self: Core.Primitive.t_usize) (other: Core.Primitive.t_u8) -> true); + f_shr_post + = + (fun + (self: Core.Primitive.t_usize) + (other: Core.Primitive.t_u8) + (out: Core.Primitive.t_usize) + -> + true); + f_shr + = + fun (self: Core.Primitive.t_usize) (other: Core.Primitive.t_u8) -> + Core.Primitive.C_usize (self.Core.Primitive._0 >>! other.Core.Primitive._0) + <: + Core.Primitive.t_usize + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_37: Core.Ops.Bit.t_Shr Core.Primitive.t_usize Core.Primitive.t_u16 = + { + f_Output = Core.Primitive.t_usize; + f_shr_pre = (fun (self: Core.Primitive.t_usize) (other: Core.Primitive.t_u16) -> true); + f_shr_post + = + (fun + (self: Core.Primitive.t_usize) + (other: Core.Primitive.t_u16) + (out: Core.Primitive.t_usize) + -> + true); + f_shr + = + fun (self: Core.Primitive.t_usize) (other: Core.Primitive.t_u16) -> + Core.Primitive.C_usize (self.Core.Primitive._0 >>! other.Core.Primitive._0) + <: + Core.Primitive.t_usize + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_38: Core.Ops.Bit.t_Shr Core.Primitive.t_usize Core.Primitive.t_u32 = + { + f_Output = Core.Primitive.t_usize; + f_shr_pre = (fun (self: Core.Primitive.t_usize) (other: Core.Primitive.t_u32) -> true); + f_shr_post + = + (fun + (self: Core.Primitive.t_usize) + (other: Core.Primitive.t_u32) + (out: Core.Primitive.t_usize) + -> + true); + f_shr + = + fun (self: Core.Primitive.t_usize) (other: Core.Primitive.t_u32) -> + Core.Primitive.C_usize (self.Core.Primitive._0 >>! other.Core.Primitive._0) + <: + Core.Primitive.t_usize + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_39: Core.Ops.Bit.t_Shr Core.Primitive.t_usize Core.Primitive.t_u64 = + { + f_Output = Core.Primitive.t_usize; + f_shr_pre = (fun (self: Core.Primitive.t_usize) (other: Core.Primitive.t_u64) -> true); + f_shr_post + = + (fun + (self: Core.Primitive.t_usize) + (other: Core.Primitive.t_u64) + (out: Core.Primitive.t_usize) + -> + true); + f_shr + = + fun (self: Core.Primitive.t_usize) (other: Core.Primitive.t_u64) -> + Core.Primitive.C_usize (self.Core.Primitive._0 >>! other.Core.Primitive._0) + <: + Core.Primitive.t_usize + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_40: Core.Ops.Bit.t_Shr Core.Primitive.t_usize Core.Primitive.t_u128 = + { + f_Output = Core.Primitive.t_usize; + f_shr_pre = (fun (self: Core.Primitive.t_usize) (other: Core.Primitive.t_u128) -> true); + f_shr_post + = + (fun + (self: Core.Primitive.t_usize) + (other: Core.Primitive.t_u128) + (out: Core.Primitive.t_usize) + -> + true); + f_shr + = + fun (self: Core.Primitive.t_usize) (other: Core.Primitive.t_u128) -> + Core.Primitive.C_usize (self.Core.Primitive._0 >>! other.Core.Primitive._0) + <: + Core.Primitive.t_usize + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_41: Core.Ops.Bit.t_Shr Core.Primitive.t_usize Core.Primitive.t_usize = + { + f_Output = Core.Primitive.t_usize; + f_shr_pre = (fun (self: Core.Primitive.t_usize) (other: Core.Primitive.t_usize) -> true); + f_shr_post + = + (fun + (self: Core.Primitive.t_usize) + (other: Core.Primitive.t_usize) + (out: Core.Primitive.t_usize) + -> + true); + f_shr + = + fun (self: Core.Primitive.t_usize) (other: Core.Primitive.t_usize) -> + Core.Primitive.C_usize (self.Core.Primitive._0 >>! other.Core.Primitive._0) + <: + Core.Primitive.t_usize + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_42: Core.Ops.Bit.t_Shl Core.Primitive.t_u8 Core.Primitive.t_u8 = + { + f_Output = Core.Primitive.t_u8; + f_shl_pre = (fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u8) -> true); + f_shl_post + = + (fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u8) (out: Core.Primitive.t_u8) -> true + ); + f_shl + = + fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u8) -> + Core.Primitive.C_u8 (self.Core.Primitive._0 < true); + f_shl_post + = + (fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u16) (out: Core.Primitive.t_u8) -> + true); + f_shl + = + fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u16) -> + Core.Primitive.C_u8 (self.Core.Primitive._0 < true); + f_shl_post + = + (fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u32) (out: Core.Primitive.t_u8) -> + true); + f_shl + = + fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u32) -> + Core.Primitive.C_u8 (self.Core.Primitive._0 < true); + f_shl_post + = + (fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u64) (out: Core.Primitive.t_u8) -> + true); + f_shl + = + fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u64) -> + Core.Primitive.C_u8 (self.Core.Primitive._0 < true); + f_shl_post + = + (fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u128) (out: Core.Primitive.t_u8) -> + true); + f_shl + = + fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u128) -> + Core.Primitive.C_u8 (self.Core.Primitive._0 < true); + f_shl_post + = + (fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_usize) (out: Core.Primitive.t_u8) -> + true); + f_shl + = + fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_usize) -> + Core.Primitive.C_u8 (self.Core.Primitive._0 < true); + f_shl_post + = + (fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u8) (out: Core.Primitive.t_u16) -> + true); + f_shl + = + fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u8) -> + Core.Primitive.C_u16 (self.Core.Primitive._0 < true); + f_shl_post + = + (fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u16) (out: Core.Primitive.t_u16) -> + true); + f_shl + = + fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u16) -> + Core.Primitive.C_u16 (self.Core.Primitive._0 < true); + f_shl_post + = + (fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u32) (out: Core.Primitive.t_u16) -> + true); + f_shl + = + fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u32) -> + Core.Primitive.C_u16 (self.Core.Primitive._0 < true); + f_shl_post + = + (fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u64) (out: Core.Primitive.t_u16) -> + true); + f_shl + = + fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u64) -> + Core.Primitive.C_u16 (self.Core.Primitive._0 < true); + f_shl_post + = + (fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u128) (out: Core.Primitive.t_u16) -> + true); + f_shl + = + fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u128) -> + Core.Primitive.C_u16 (self.Core.Primitive._0 < true); + f_shl_post + = + (fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_usize) (out: Core.Primitive.t_u16) -> + true); + f_shl + = + fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_usize) -> + Core.Primitive.C_u16 (self.Core.Primitive._0 < true); + f_shl_post + = + (fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u8) (out: Core.Primitive.t_u32) -> + true); + f_shl + = + fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u8) -> + Core.Primitive.C_u32 (self.Core.Primitive._0 < true); + f_shl_post + = + (fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u16) (out: Core.Primitive.t_u32) -> + true); + f_shl + = + fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u16) -> + Core.Primitive.C_u32 (self.Core.Primitive._0 < true); + f_shl_post + = + (fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u32) (out: Core.Primitive.t_u32) -> + true); + f_shl + = + fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u32) -> + Core.Primitive.C_u32 (self.Core.Primitive._0 < true); + f_shl_post + = + (fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u64) (out: Core.Primitive.t_u32) -> + true); + f_shl + = + fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u64) -> + Core.Primitive.C_u32 (self.Core.Primitive._0 < true); + f_shl_post + = + (fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u128) (out: Core.Primitive.t_u32) -> + true); + f_shl + = + fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u128) -> + Core.Primitive.C_u32 (self.Core.Primitive._0 < true); + f_shl_post + = + (fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_usize) (out: Core.Primitive.t_u32) -> + true); + f_shl + = + fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_usize) -> + Core.Primitive.C_u32 (self.Core.Primitive._0 < true); + f_shl_post + = + (fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u8) (out: Core.Primitive.t_u64) -> + true); + f_shl + = + fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u8) -> + Core.Primitive.C_u64 (self.Core.Primitive._0 < true); + f_shl_post + = + (fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u16) (out: Core.Primitive.t_u64) -> + true); + f_shl + = + fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u16) -> + Core.Primitive.C_u64 (self.Core.Primitive._0 < true); + f_shl_post + = + (fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u32) (out: Core.Primitive.t_u64) -> + true); + f_shl + = + fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u32) -> + Core.Primitive.C_u64 (self.Core.Primitive._0 < true); + f_shl_post + = + (fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u64) (out: Core.Primitive.t_u64) -> + true); + f_shl + = + fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u64) -> + Core.Primitive.C_u64 (self.Core.Primitive._0 < true); + f_shl_post + = + (fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u128) (out: Core.Primitive.t_u64) -> + true); + f_shl + = + fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u128) -> + Core.Primitive.C_u64 (self.Core.Primitive._0 < true); + f_shl_post + = + (fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_usize) (out: Core.Primitive.t_u64) -> + true); + f_shl + = + fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_usize) -> + Core.Primitive.C_u64 (self.Core.Primitive._0 < true); + f_shl_post + = + (fun (self: Core.Primitive.t_u128) (other: Core.Primitive.t_u8) (out: Core.Primitive.t_u128) -> + true); + f_shl + = + fun (self: Core.Primitive.t_u128) (other: Core.Primitive.t_u8) -> + Core.Primitive.C_u128 (self.Core.Primitive._0 < true); + f_shl_post + = + (fun (self: Core.Primitive.t_u128) (other: Core.Primitive.t_u16) (out: Core.Primitive.t_u128) -> + true); + f_shl + = + fun (self: Core.Primitive.t_u128) (other: Core.Primitive.t_u16) -> + Core.Primitive.C_u128 (self.Core.Primitive._0 < true); + f_shl_post + = + (fun (self: Core.Primitive.t_u128) (other: Core.Primitive.t_u32) (out: Core.Primitive.t_u128) -> + true); + f_shl + = + fun (self: Core.Primitive.t_u128) (other: Core.Primitive.t_u32) -> + Core.Primitive.C_u128 (self.Core.Primitive._0 < true); + f_shl_post + = + (fun (self: Core.Primitive.t_u128) (other: Core.Primitive.t_u64) (out: Core.Primitive.t_u128) -> + true); + f_shl + = + fun (self: Core.Primitive.t_u128) (other: Core.Primitive.t_u64) -> + Core.Primitive.C_u128 (self.Core.Primitive._0 < true); + f_shl_post + = + (fun + (self: Core.Primitive.t_u128) + (other: Core.Primitive.t_u128) + (out: Core.Primitive.t_u128) + -> + true); + f_shl + = + fun (self: Core.Primitive.t_u128) (other: Core.Primitive.t_u128) -> + Core.Primitive.C_u128 (self.Core.Primitive._0 < true); + f_shl_post + = + (fun + (self: Core.Primitive.t_u128) + (other: Core.Primitive.t_usize) + (out: Core.Primitive.t_u128) + -> + true); + f_shl + = + fun (self: Core.Primitive.t_u128) (other: Core.Primitive.t_usize) -> + Core.Primitive.C_u128 (self.Core.Primitive._0 < true); + f_shl_post + = + (fun + (self: Core.Primitive.t_usize) + (other: Core.Primitive.t_u8) + (out: Core.Primitive.t_usize) + -> + true); + f_shl + = + fun (self: Core.Primitive.t_usize) (other: Core.Primitive.t_u8) -> + Core.Primitive.C_usize (self.Core.Primitive._0 < true); + f_shl_post + = + (fun + (self: Core.Primitive.t_usize) + (other: Core.Primitive.t_u16) + (out: Core.Primitive.t_usize) + -> + true); + f_shl + = + fun (self: Core.Primitive.t_usize) (other: Core.Primitive.t_u16) -> + Core.Primitive.C_usize (self.Core.Primitive._0 < true); + f_shl_post + = + (fun + (self: Core.Primitive.t_usize) + (other: Core.Primitive.t_u32) + (out: Core.Primitive.t_usize) + -> + true); + f_shl + = + fun (self: Core.Primitive.t_usize) (other: Core.Primitive.t_u32) -> + Core.Primitive.C_usize (self.Core.Primitive._0 < true); + f_shl_post + = + (fun + (self: Core.Primitive.t_usize) + (other: Core.Primitive.t_u64) + (out: Core.Primitive.t_usize) + -> + true); + f_shl + = + fun (self: Core.Primitive.t_usize) (other: Core.Primitive.t_u64) -> + Core.Primitive.C_usize (self.Core.Primitive._0 < true); + f_shl_post + = + (fun + (self: Core.Primitive.t_usize) + (other: Core.Primitive.t_u128) + (out: Core.Primitive.t_usize) + -> + true); + f_shl + = + fun (self: Core.Primitive.t_usize) (other: Core.Primitive.t_u128) -> + Core.Primitive.C_usize (self.Core.Primitive._0 < true); + f_shl_post + = + (fun + (self: Core.Primitive.t_usize) + (other: Core.Primitive.t_usize) + (out: Core.Primitive.t_usize) + -> + true); + f_shl + = + fun (self: Core.Primitive.t_usize) (other: Core.Primitive.t_usize) -> + Core.Primitive.C_usize (self.Core.Primitive._0 < true); + f_bitor_post + = + (fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u8) (out: Core.Primitive.t_u8) -> true + ); + f_bitor + = + fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u8) -> + Core.Primitive.C_u8 (self.Core.Primitive._0 |. other.Core.Primitive._0) <: Core.Primitive.t_u8 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_79: Core.Ops.Bit.t_BitOr Core.Primitive.t_u16 Core.Primitive.t_u16 = + { + f_Output = Core.Primitive.t_u16; + f_bitor_pre = (fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u16) -> true); + f_bitor_post + = + (fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u16) (out: Core.Primitive.t_u16) -> + true); + f_bitor + = + fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u16) -> + Core.Primitive.C_u16 (self.Core.Primitive._0 |. other.Core.Primitive._0) + <: + Core.Primitive.t_u16 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_80: Core.Ops.Bit.t_BitOr Core.Primitive.t_u32 Core.Primitive.t_u32 = + { + f_Output = Core.Primitive.t_u32; + f_bitor_pre = (fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u32) -> true); + f_bitor_post + = + (fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u32) (out: Core.Primitive.t_u32) -> + true); + f_bitor + = + fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u32) -> + Core.Primitive.C_u32 (self.Core.Primitive._0 |. other.Core.Primitive._0) + <: + Core.Primitive.t_u32 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_81: Core.Ops.Bit.t_BitOr Core.Primitive.t_u64 Core.Primitive.t_u64 = + { + f_Output = Core.Primitive.t_u64; + f_bitor_pre = (fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u64) -> true); + f_bitor_post + = + (fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u64) (out: Core.Primitive.t_u64) -> + true); + f_bitor + = + fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u64) -> + Core.Primitive.C_u64 (self.Core.Primitive._0 |. other.Core.Primitive._0) + <: + Core.Primitive.t_u64 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_82: Core.Ops.Bit.t_BitOr Core.Primitive.t_u128 Core.Primitive.t_u128 = + { + f_Output = Core.Primitive.t_u128; + f_bitor_pre = (fun (self: Core.Primitive.t_u128) (other: Core.Primitive.t_u128) -> true); + f_bitor_post + = + (fun + (self: Core.Primitive.t_u128) + (other: Core.Primitive.t_u128) + (out: Core.Primitive.t_u128) + -> + true); + f_bitor + = + fun (self: Core.Primitive.t_u128) (other: Core.Primitive.t_u128) -> + Core.Primitive.C_u128 (self.Core.Primitive._0 |. other.Core.Primitive._0) + <: + Core.Primitive.t_u128 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_83: Core.Ops.Bit.t_BitOr Core.Primitive.t_usize Core.Primitive.t_usize = + { + f_Output = Core.Primitive.t_usize; + f_bitor_pre = (fun (self: Core.Primitive.t_usize) (other: Core.Primitive.t_usize) -> true); + f_bitor_post + = + (fun + (self: Core.Primitive.t_usize) + (other: Core.Primitive.t_usize) + (out: Core.Primitive.t_usize) + -> + true); + f_bitor + = + fun (self: Core.Primitive.t_usize) (other: Core.Primitive.t_usize) -> + Core.Primitive.C_usize (self.Core.Primitive._0 |. other.Core.Primitive._0) + <: + Core.Primitive.t_usize + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_90: Core.Ops.Bit.t_BitXor Core.Primitive.t_u8 Core.Primitive.t_u8 = + { + f_Output = Core.Primitive.t_u8; + f_bitxor_pre = (fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u8) -> true); + f_bitxor_post + = + (fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u8) (out: Core.Primitive.t_u8) -> true + ); + f_bitxor + = + fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u8) -> + Core.Primitive.C_u8 (self.Core.Primitive._0 ^. other.Core.Primitive._0) <: Core.Primitive.t_u8 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_91: Core.Ops.Bit.t_BitXor Core.Primitive.t_u16 Core.Primitive.t_u16 = + { + f_Output = Core.Primitive.t_u16; + f_bitxor_pre = (fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u16) -> true); + f_bitxor_post + = + (fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u16) (out: Core.Primitive.t_u16) -> + true); + f_bitxor + = + fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u16) -> + Core.Primitive.C_u16 (self.Core.Primitive._0 ^. other.Core.Primitive._0) + <: + Core.Primitive.t_u16 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_92: Core.Ops.Bit.t_BitXor Core.Primitive.t_u32 Core.Primitive.t_u32 = + { + f_Output = Core.Primitive.t_u32; + f_bitxor_pre = (fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u32) -> true); + f_bitxor_post + = + (fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u32) (out: Core.Primitive.t_u32) -> + true); + f_bitxor + = + fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u32) -> + Core.Primitive.C_u32 (self.Core.Primitive._0 ^. other.Core.Primitive._0) + <: + Core.Primitive.t_u32 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_93: Core.Ops.Bit.t_BitXor Core.Primitive.t_u64 Core.Primitive.t_u64 = + { + f_Output = Core.Primitive.t_u64; + f_bitxor_pre = (fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u64) -> true); + f_bitxor_post + = + (fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u64) (out: Core.Primitive.t_u64) -> + true); + f_bitxor + = + fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u64) -> + Core.Primitive.C_u64 (self.Core.Primitive._0 ^. other.Core.Primitive._0) + <: + Core.Primitive.t_u64 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_94: Core.Ops.Bit.t_BitXor Core.Primitive.t_u128 Core.Primitive.t_u128 = + { + f_Output = Core.Primitive.t_u128; + f_bitxor_pre = (fun (self: Core.Primitive.t_u128) (other: Core.Primitive.t_u128) -> true); + f_bitxor_post + = + (fun + (self: Core.Primitive.t_u128) + (other: Core.Primitive.t_u128) + (out: Core.Primitive.t_u128) + -> + true); + f_bitxor + = + fun (self: Core.Primitive.t_u128) (other: Core.Primitive.t_u128) -> + Core.Primitive.C_u128 (self.Core.Primitive._0 ^. other.Core.Primitive._0) + <: + Core.Primitive.t_u128 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_95: Core.Ops.Bit.t_BitXor Core.Primitive.t_usize Core.Primitive.t_usize = + { + f_Output = Core.Primitive.t_usize; + f_bitxor_pre = (fun (self: Core.Primitive.t_usize) (other: Core.Primitive.t_usize) -> true); + f_bitxor_post + = + (fun + (self: Core.Primitive.t_usize) + (other: Core.Primitive.t_usize) + (out: Core.Primitive.t_usize) + -> + true); + f_bitxor + = + fun (self: Core.Primitive.t_usize) (other: Core.Primitive.t_usize) -> + Core.Primitive.C_usize (self.Core.Primitive._0 ^. other.Core.Primitive._0) + <: + Core.Primitive.t_usize + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_96: Core.Ops.Bit.t_BitAnd Core.Primitive.t_u8 Core.Primitive.t_u8 = + { + f_Output = Core.Primitive.t_u8; + f_bitand_pre = (fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u8) -> true); + f_bitand_post + = + (fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u8) (out: Core.Primitive.t_u8) -> true + ); + f_bitand + = + fun (self: Core.Primitive.t_u8) (other: Core.Primitive.t_u8) -> + Core.Primitive.C_u8 (self.Core.Primitive._0 &. other.Core.Primitive._0) <: Core.Primitive.t_u8 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_97: Core.Ops.Bit.t_BitAnd Core.Primitive.t_u16 Core.Primitive.t_u16 = + { + f_Output = Core.Primitive.t_u16; + f_bitand_pre = (fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u16) -> true); + f_bitand_post + = + (fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u16) (out: Core.Primitive.t_u16) -> + true); + f_bitand + = + fun (self: Core.Primitive.t_u16) (other: Core.Primitive.t_u16) -> + Core.Primitive.C_u16 (self.Core.Primitive._0 &. other.Core.Primitive._0) + <: + Core.Primitive.t_u16 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_98: Core.Ops.Bit.t_BitAnd Core.Primitive.t_u32 Core.Primitive.t_u32 = + { + f_Output = Core.Primitive.t_u32; + f_bitand_pre = (fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u32) -> true); + f_bitand_post + = + (fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u32) (out: Core.Primitive.t_u32) -> + true); + f_bitand + = + fun (self: Core.Primitive.t_u32) (other: Core.Primitive.t_u32) -> + Core.Primitive.C_u32 (self.Core.Primitive._0 &. other.Core.Primitive._0) + <: + Core.Primitive.t_u32 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_99: Core.Ops.Bit.t_BitAnd Core.Primitive.t_u64 Core.Primitive.t_u64 = + { + f_Output = Core.Primitive.t_u64; + f_bitand_pre = (fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u64) -> true); + f_bitand_post + = + (fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u64) (out: Core.Primitive.t_u64) -> + true); + f_bitand + = + fun (self: Core.Primitive.t_u64) (other: Core.Primitive.t_u64) -> + Core.Primitive.C_u64 (self.Core.Primitive._0 &. other.Core.Primitive._0) + <: + Core.Primitive.t_u64 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_100: Core.Ops.Bit.t_BitAnd Core.Primitive.t_u128 Core.Primitive.t_u128 = + { + f_Output = Core.Primitive.t_u128; + f_bitand_pre = (fun (self: Core.Primitive.t_u128) (other: Core.Primitive.t_u128) -> true); + f_bitand_post + = + (fun + (self: Core.Primitive.t_u128) + (other: Core.Primitive.t_u128) + (out: Core.Primitive.t_u128) + -> + true); + f_bitand + = + fun (self: Core.Primitive.t_u128) (other: Core.Primitive.t_u128) -> + Core.Primitive.C_u128 (self.Core.Primitive._0 &. other.Core.Primitive._0) + <: + Core.Primitive.t_u128 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_101: Core.Ops.Bit.t_BitAnd Core.Primitive.t_usize Core.Primitive.t_usize = + { + f_Output = Core.Primitive.t_usize; + f_bitand_pre = (fun (self: Core.Primitive.t_usize) (other: Core.Primitive.t_usize) -> true); + f_bitand_post + = + (fun + (self: Core.Primitive.t_usize) + (other: Core.Primitive.t_usize) + (out: Core.Primitive.t_usize) + -> + true); + f_bitand + = + fun (self: Core.Primitive.t_usize) (other: Core.Primitive.t_usize) -> + Core.Primitive.C_usize (self.Core.Primitive._0 &. other.Core.Primitive._0) + <: + Core.Primitive.t_usize + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl: Core.Ops.Bit.t_Not Core.Primitive.t_u8 = + { + f_Output = Core.Primitive.t_u8; + f_not_pre = (fun (self: Core.Primitive.t_u8) -> true); + f_not_post = (fun (self: Core.Primitive.t_u8) (out: Core.Primitive.t_u8) -> true); + f_not + = + fun (self: Core.Primitive.t_u8) -> + Core.Primitive.C_u8 ~.self.Core.Primitive._0 <: Core.Primitive.t_u8 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_1: Core.Ops.Bit.t_Not Core.Primitive.t_u16 = + { + f_Output = Core.Primitive.t_u16; + f_not_pre = (fun (self: Core.Primitive.t_u16) -> true); + f_not_post = (fun (self: Core.Primitive.t_u16) (out: Core.Primitive.t_u16) -> true); + f_not + = + fun (self: Core.Primitive.t_u16) -> + Core.Primitive.C_u16 ~.self.Core.Primitive._0 <: Core.Primitive.t_u16 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_2: Core.Ops.Bit.t_Not Core.Primitive.t_u32 = + { + f_Output = Core.Primitive.t_u32; + f_not_pre = (fun (self: Core.Primitive.t_u32) -> true); + f_not_post = (fun (self: Core.Primitive.t_u32) (out: Core.Primitive.t_u32) -> true); + f_not + = + fun (self: Core.Primitive.t_u32) -> + Core.Primitive.C_u32 ~.self.Core.Primitive._0 <: Core.Primitive.t_u32 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_3: Core.Ops.Bit.t_Not Core.Primitive.t_u64 = + { + f_Output = Core.Primitive.t_u64; + f_not_pre = (fun (self: Core.Primitive.t_u64) -> true); + f_not_post = (fun (self: Core.Primitive.t_u64) (out: Core.Primitive.t_u64) -> true); + f_not + = + fun (self: Core.Primitive.t_u64) -> + Core.Primitive.C_u64 ~.self.Core.Primitive._0 <: Core.Primitive.t_u64 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_4: Core.Ops.Bit.t_Not Core.Primitive.t_u128 = + { + f_Output = Core.Primitive.t_u128; + f_not_pre = (fun (self: Core.Primitive.t_u128) -> true); + f_not_post = (fun (self: Core.Primitive.t_u128) (out: Core.Primitive.t_u128) -> true); + f_not + = + fun (self: Core.Primitive.t_u128) -> + Core.Primitive.C_u128 ~.self.Core.Primitive._0 <: Core.Primitive.t_u128 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_5: Core.Ops.Bit.t_Not Core.Primitive.t_usize = + { + f_Output = Core.Primitive.t_usize; + f_not_pre = (fun (self: Core.Primitive.t_usize) -> true); + f_not_post = (fun (self: Core.Primitive.t_usize) (out: Core.Primitive.t_usize) -> true); + f_not + = + fun (self: Core.Primitive.t_usize) -> + Core.Primitive.C_usize ~.self.Core.Primitive._0 <: Core.Primitive.t_usize + } diff --git a/proof-libs/fstar/generated_core/Core.Ops.Bit.fst b/proof-libs/fstar/generated_core/Core.Ops.Bit.fst new file mode 100644 index 000000000..60b876097 --- /dev/null +++ b/proof-libs/fstar/generated_core/Core.Ops.Bit.fst @@ -0,0 +1,51 @@ +module Core.Ops.Bit +#set-options "--fuel 0 --ifuel 1 --z3rlimit 15" +open Core +open FStar.Mul + +class t_BitAnd (v_Self: Type0) (v_Rhs: Type0) = { + f_Output:Type0; + f_bitand_pre:v_Self -> v_Rhs -> Type0; + f_bitand_post:v_Self -> v_Rhs -> f_Output -> Type0; + f_bitand:x0: v_Self -> x1: v_Rhs + -> Prims.Pure f_Output (f_bitand_pre x0 x1) (fun result -> f_bitand_post x0 x1 result) +} + +class t_BitOr (v_Self: Type0) (v_Rhs: Type0) = { + f_Output:Type0; + f_bitor_pre:v_Self -> v_Rhs -> Type0; + f_bitor_post:v_Self -> v_Rhs -> f_Output -> Type0; + f_bitor:x0: v_Self -> x1: v_Rhs + -> Prims.Pure f_Output (f_bitor_pre x0 x1) (fun result -> f_bitor_post x0 x1 result) +} + +class t_BitXor (v_Self: Type0) (v_Rhs: Type0) = { + f_Output:Type0; + f_bitxor_pre:v_Self -> v_Rhs -> Type0; + f_bitxor_post:v_Self -> v_Rhs -> f_Output -> Type0; + f_bitxor:x0: v_Self -> x1: v_Rhs + -> Prims.Pure f_Output (f_bitxor_pre x0 x1) (fun result -> f_bitxor_post x0 x1 result) +} + +class t_Not (v_Self: Type0) = { + f_Output:Type0; + f_not_pre:v_Self -> Type0; + f_not_post:v_Self -> f_Output -> Type0; + f_not:x0: v_Self -> Prims.Pure f_Output (f_not_pre x0) (fun result -> f_not_post x0 result) +} + +class t_Shl (v_Self: Type0) (v_Rhs: Type0) = { + f_Output:Type0; + f_shl_pre:v_Self -> v_Rhs -> Type0; + f_shl_post:v_Self -> v_Rhs -> f_Output -> Type0; + f_shl:x0: v_Self -> x1: v_Rhs + -> Prims.Pure f_Output (f_shl_pre x0 x1) (fun result -> f_shl_post x0 x1 result) +} + +class t_Shr (v_Self: Type0) (v_Rhs: Type0) = { + f_Output:Type0; + f_shr_pre:v_Self -> v_Rhs -> Type0; + f_shr_post:v_Self -> v_Rhs -> f_Output -> Type0; + f_shr:x0: v_Self -> x1: v_Rhs + -> Prims.Pure f_Output (f_shr_pre x0 x1) (fun result -> f_shr_post x0 x1 result) +} diff --git a/proof-libs/fstar/generated_core/Core.Option.fst b/proof-libs/fstar/generated_core/Core.Option.fst new file mode 100644 index 000000000..317328122 --- /dev/null +++ b/proof-libs/fstar/generated_core/Core.Option.fst @@ -0,0 +1,47 @@ +module Core.Option +#set-options "--fuel 0 --ifuel 1 --z3rlimit 15" +open Core +open FStar.Mul + +type t_Option (v_T: Type0) = + | Option_None : t_Option v_T + | Option_Some : v_T -> t_Option v_T + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl (#v_T: Type0) (#[FStar.Tactics.Typeclasses.tcresolve ()] i1: Core.Clone.t_Clone v_T) + : Core.Clone.t_Clone (t_Option v_T) = + { + f_clone_pre = (fun (self: t_Option v_T) -> true); + f_clone_post = (fun (self: t_Option v_T) (out: t_Option v_T) -> true); + f_clone + = + fun (self: t_Option v_T) -> + match self with + | Option_Some x -> + Option_Some (Core.Clone.f_clone #v_T #FStar.Tactics.Typeclasses.solve x) <: t_Option v_T + | Option_None -> Option_None <: t_Option v_T + } + +let impl_1__is_some (#v_T: Type0) (self: t_Option v_T) : bool = + match self with + | Option_Some _ -> true + | _ -> false + +let unwrap_failed (_: Prims.unit) : Rust_primitives.Hax.t_Never = + Core.Panicking.panic "called `Option::unwrap()` on a `None` value" + +let impl_1__unwrap (#v_T: Type0) (self: t_Option v_T) + : Prims.Pure v_T (requires impl_1__is_some #v_T self___) (fun _ -> Prims.l_True) = + match self with + | Option_Some v_val -> v_val + | Option_None -> + Rust_primitives.Hax.never_to_any (unwrap_failed () <: Rust_primitives.Hax.t_Never) + +let expect_failed (msg: string) : Rust_primitives.Hax.t_Never = + Core.Panicking.panic_display #string msg + +let impl_1__expect (#v_T: Type0) (self: t_Option v_T) (msg: string) : v_T = + match self with + | Option_Some v_val -> v_val + | Option_None -> + Rust_primitives.Hax.never_to_any (expect_failed msg <: Rust_primitives.Hax.t_Never) diff --git a/proof-libs/fstar/generated_core/Core.Panicking.fst b/proof-libs/fstar/generated_core/Core.Panicking.fst new file mode 100644 index 000000000..6b444e304 --- /dev/null +++ b/proof-libs/fstar/generated_core/Core.Panicking.fst @@ -0,0 +1,51 @@ +module Core.Panicking +#set-options "--fuel 0 --ifuel 1 --z3rlimit 15" +open Core +open FStar.Mul + +type t_AssertKind = + | AssertKind_Eq : t_AssertKind + | AssertKind_Ne : t_AssertKind + | AssertKind_Match : t_AssertKind + +let t_AssertKind_cast_to_repr (x: t_AssertKind) : isize = + match x with + | AssertKind_Eq -> isz 0 + | AssertKind_Ne -> isz 1 + | AssertKind_Match -> isz 3 + +type t_Never = + +let t_Never_cast_to_repr (x: t_Never) : Rust_primitives.Hax.t_Never = match x with + +let never_to_any (#v_T: Type0) (x: t_Never) : v_T = Rust_primitives.Hax.never_to_any (match x with ) + +let rec panic_fmt (fmt: Core.Fmt.t_Arguments) : Rust_primitives.Hax.t_Never = panic_fmt fmt + +/// The underlying implementation of core's `panic!` macro when no formatting is used. +let panic (expr: string) : Rust_primitives.Hax.t_Never = + panic_fmt (Core.Fmt.impl_2__new_const (sz 1) + (let list = [expr] in + FStar.Pervasives.assert_norm (Prims.eq2 (List.Tot.length list) 1); + Rust_primitives.Hax.array_of_list 1 list) + <: + Core.Fmt.t_Arguments) + +let panic_display + (#v_T: Type0) + (#[FStar.Tactics.Typeclasses.tcresolve ()] i1: Core.Fmt.t_Display v_T) + (x: v_T) + : Rust_primitives.Hax.t_Never = + panic_fmt (Core.Fmt.impl_2__new_v1 (sz 1) + (sz 1) + (let list = [""] in + FStar.Pervasives.assert_norm (Prims.eq2 (List.Tot.length list) 1); + Rust_primitives.Hax.array_of_list 1 list) + (let list = [Core.Fmt.Rt.impl_1__new_display #v_T x <: Core.Fmt.Rt.t_Argument] in + FStar.Pervasives.assert_norm (Prims.eq2 (List.Tot.length list) 1); + Rust_primitives.Hax.array_of_list 1 list) + <: + Core.Fmt.t_Arguments) + +let panic_explicit (_: Prims.unit) : Rust_primitives.Hax.t_Never = + panic_display #string "explicit panic" diff --git a/proof-libs/fstar/generated_core/Core.Primitive.Number_conversion.fst b/proof-libs/fstar/generated_core/Core.Primitive.Number_conversion.fst new file mode 100644 index 000000000..7b96d497b --- /dev/null +++ b/proof-libs/fstar/generated_core/Core.Primitive.Number_conversion.fst @@ -0,0 +1,88 @@ +module Core.Primitive.Number_conversion +#set-options "--fuel 0 --ifuel 1 --z3rlimit 15" +open Core +open FStar.Mul + +include Core.Intrinsics.Rec_bundle_253787241 {impl_31 as impl_31} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_40 as impl_40} + +include Core.Intrinsics.Rec_bundle_253787241 {impl as impl} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_1 as impl_1} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_2 as impl_2} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_3 as impl_3} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_4 as impl_4} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_5 as impl_5} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_6 as impl_6} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_7 as impl_7} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_8 as impl_8} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_9 as impl_9} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_10 as impl_10} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_11 as impl_11} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_12 as impl_12} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_13 as impl_13} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_14 as impl_14} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_15 as impl_15} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_16 as impl_16} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_17 as impl_17} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_18 as impl_18} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_19 as impl_19} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_20 as impl_20} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_21 as impl_21} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_22 as impl_22} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_23 as impl_23} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_24 as impl_24} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_25 as impl_25} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_26 as impl_26} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_27 as impl_27} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_28 as impl_28} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_29 as impl_29} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_30 as impl_30} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_32 as impl_32} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_33 as impl_33} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_34 as impl_34} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_35 as impl_35} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_36 as impl_36} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_37 as impl_37} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_38 as impl_38} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_39 as impl_39} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_41 as impl_41} diff --git a/proof-libs/fstar/generated_core/Core.Primitive.Number_conversion_i.fst b/proof-libs/fstar/generated_core/Core.Primitive.Number_conversion_i.fst new file mode 100644 index 000000000..cdb9c0714 --- /dev/null +++ b/proof-libs/fstar/generated_core/Core.Primitive.Number_conversion_i.fst @@ -0,0 +1,88 @@ +module Core.Primitive.Number_conversion_i +#set-options "--fuel 0 --ifuel 1 --z3rlimit 15" +open Core +open FStar.Mul + +include Core.Intrinsics.Rec_bundle_253787241 {impl_31 as impl_31} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_40 as impl_40} + +include Core.Intrinsics.Rec_bundle_253787241 {impl as impl} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_1 as impl_1} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_2 as impl_2} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_3 as impl_3} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_4 as impl_4} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_5 as impl_5} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_6 as impl_6} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_7 as impl_7} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_8 as impl_8} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_9 as impl_9} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_10 as impl_10} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_11 as impl_11} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_12 as impl_12} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_13 as impl_13} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_14 as impl_14} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_15 as impl_15} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_16 as impl_16} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_17 as impl_17} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_18 as impl_18} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_19 as impl_19} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_20 as impl_20} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_21 as impl_21} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_22 as impl_22} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_23 as impl_23} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_24 as impl_24} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_25 as impl_25} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_26 as impl_26} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_27 as impl_27} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_28 as impl_28} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_29 as impl_29} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_30 as impl_30} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_32 as impl_32} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_33 as impl_33} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_34 as impl_34} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_35 as impl_35} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_36 as impl_36} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_37 as impl_37} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_38 as impl_38} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_39 as impl_39} + +include Core.Intrinsics.Rec_bundle_253787241 {impl_41 as impl_41} diff --git a/proof-libs/fstar/generated_core/Core.Primitive.fst b/proof-libs/fstar/generated_core/Core.Primitive.fst new file mode 100644 index 000000000..14bd09b7d --- /dev/null +++ b/proof-libs/fstar/generated_core/Core.Primitive.fst @@ -0,0 +1,1240 @@ +module Core.Primitive +#set-options "--fuel 0 --ifuel 1 --z3rlimit 15" +open Core +open FStar.Mul + +type t_i128 = | C_i128 : Core.Base_interface.Int.t_I128 -> t_i128 + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_20: Core.Clone.t_Clone t_i128 = + { + f_clone_pre = (fun (self: t_i128) -> true); + f_clone_post = (fun (self: t_i128) (out: t_i128) -> true); + f_clone + = + fun (self: t_i128) -> + C_i128 + (Core.Clone.f_clone #Core.Base_interface.Int.t_I128 #FStar.Tactics.Typeclasses.solve self._0) + <: + t_i128 + } + +type t_i16 = | C_i16 : Core.Base_interface.Int.t_I16 -> t_i16 + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_14: Core.Clone.t_Clone t_i16 = + { + f_clone_pre = (fun (self: t_i16) -> true); + f_clone_post = (fun (self: t_i16) (out: t_i16) -> true); + f_clone + = + fun (self: t_i16) -> + C_i16 + (Core.Clone.f_clone #Core.Base_interface.Int.t_I16 #FStar.Tactics.Typeclasses.solve self._0) + <: + t_i16 + } + +type t_i32 = | C_i32 : Core.Base_interface.Int.t_I32 -> t_i32 + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_16: Core.Clone.t_Clone t_i32 = + { + f_clone_pre = (fun (self: t_i32) -> true); + f_clone_post = (fun (self: t_i32) (out: t_i32) -> true); + f_clone + = + fun (self: t_i32) -> + C_i32 + (Core.Clone.f_clone #Core.Base_interface.Int.t_I32 #FStar.Tactics.Typeclasses.solve self._0) + <: + t_i32 + } + +type t_i64 = | C_i64 : Core.Base_interface.Int.t_I64 -> t_i64 + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_18: Core.Clone.t_Clone t_i64 = + { + f_clone_pre = (fun (self: t_i64) -> true); + f_clone_post = (fun (self: t_i64) (out: t_i64) -> true); + f_clone + = + fun (self: t_i64) -> + C_i64 + (Core.Clone.f_clone #Core.Base_interface.Int.t_I64 #FStar.Tactics.Typeclasses.solve self._0) + <: + t_i64 + } + +type t_i8 = | C_i8 : Core.Base_interface.Int.t_I8 -> t_i8 + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_12: Core.Clone.t_Clone t_i8 = + { + f_clone_pre = (fun (self: t_i8) -> true); + f_clone_post = (fun (self: t_i8) (out: t_i8) -> true); + f_clone + = + fun (self: t_i8) -> + C_i8 + (Core.Clone.f_clone #Core.Base_interface.Int.t_I8 #FStar.Tactics.Typeclasses.solve self._0) + <: + t_i8 + } + +type t_isize = | C_isize : Core.Base_interface.Int.t_I64 -> t_isize + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_22: Core.Clone.t_Clone t_isize = + { + f_clone_pre = (fun (self: t_isize) -> true); + f_clone_post = (fun (self: t_isize) (out: t_isize) -> true); + f_clone + = + fun (self: t_isize) -> + C_isize + (Core.Clone.f_clone #Core.Base_interface.Int.t_I64 #FStar.Tactics.Typeclasses.solve self._0) + <: + t_isize + } + +type t_u128 = | C_u128 : Core.Base_interface.Int.t_U128 -> t_u128 + +type t_u16 = | C_u16 : Core.Base_interface.Int.t_U16 -> t_u16 + +type t_u32 = | C_u32 : Core.Base_interface.Int.t_U32 -> t_u32 + +type t_u64 = | C_u64 : Core.Base_interface.Int.t_U64 -> t_u64 + +type t_u8 = | C_u8 : Core.Base_interface.Int.t_U8 -> t_u8 + +type t_usize = | C_usize : Core.Base_interface.Int.t_U64 -> t_usize + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl: Core.Clone.t_Clone t_u8 = + { + f_clone_pre = (fun (self: t_u8) -> true); + f_clone_post = (fun (self: t_u8) (out: t_u8) -> true); + f_clone + = + fun (self: t_u8) -> + C_u8 + (Core.Clone.f_clone #Core.Base_interface.Int.t_U8 #FStar.Tactics.Typeclasses.solve self._0) + <: + t_u8 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_2: Core.Clone.t_Clone t_u16 = + { + f_clone_pre = (fun (self: t_u16) -> true); + f_clone_post = (fun (self: t_u16) (out: t_u16) -> true); + f_clone + = + fun (self: t_u16) -> + C_u16 + (Core.Clone.f_clone #Core.Base_interface.Int.t_U16 #FStar.Tactics.Typeclasses.solve self._0) + <: + t_u16 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_4: Core.Clone.t_Clone t_u32 = + { + f_clone_pre = (fun (self: t_u32) -> true); + f_clone_post = (fun (self: t_u32) (out: t_u32) -> true); + f_clone + = + fun (self: t_u32) -> + C_u32 + (Core.Clone.f_clone #Core.Base_interface.Int.t_U32 #FStar.Tactics.Typeclasses.solve self._0) + <: + t_u32 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_6: Core.Clone.t_Clone t_u64 = + { + f_clone_pre = (fun (self: t_u64) -> true); + f_clone_post = (fun (self: t_u64) (out: t_u64) -> true); + f_clone + = + fun (self: t_u64) -> + C_u64 + (Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve self._0) + <: + t_u64 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_8: Core.Clone.t_Clone t_u128 = + { + f_clone_pre = (fun (self: t_u128) -> true); + f_clone_post = (fun (self: t_u128) (out: t_u128) -> true); + f_clone + = + fun (self: t_u128) -> + C_u128 + (Core.Clone.f_clone #Core.Base_interface.Int.t_U128 #FStar.Tactics.Typeclasses.solve self._0) + <: + t_u128 + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_10: Core.Clone.t_Clone t_usize = + { + f_clone_pre = (fun (self: t_usize) -> true); + f_clone_post = (fun (self: t_usize) (out: t_usize) -> true); + f_clone + = + fun (self: t_usize) -> + C_usize + (Core.Clone.f_clone #Core.Base_interface.Int.t_U64 #FStar.Tactics.Typeclasses.solve self._0) + <: + t_usize + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_24: Core.Cmp.t_PartialEq t_u8 t_u8 = + { + f_eq_pre = (fun (self: t_u8) (rhs: t_u8) -> true); + f_eq_post = (fun (self: t_u8) (rhs: t_u8) (out: bool) -> true); + f_eq = (fun (self: t_u8) (rhs: t_u8) -> self._0 =. rhs._0); + f_ne_pre = (fun (self: t_u8) (rhs: t_u8) -> true); + f_ne_post = (fun (self: t_u8) (rhs: t_u8) (out: bool) -> true); + f_ne = fun (self: t_u8) (rhs: t_u8) -> ~.(self._0 =. rhs._0 <: bool) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_25: Core.Cmp.t_PartialOrd t_u8 t_u8 = + { + _super_9014672428308350468 = FStar.Tactics.Typeclasses.solve; + f_partial_cmp_pre = (fun (self: t_u8) (rhs: t_u8) -> true); + f_partial_cmp_post + = + (fun (self: t_u8) (rhs: t_u8) (out: Core.Option.t_Option Core.Cmp.t_Ordering) -> true); + f_partial_cmp + = + (fun (self: t_u8) (rhs: t_u8) -> + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_U8 + #Core.Base_interface.Int.t_U8 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0); + f_lt_pre = (fun (self: t_u8) (rhs: t_u8) -> true); + f_lt_post = (fun (self: t_u8) (rhs: t_u8) (out: bool) -> true); + f_lt + = + (fun (self: t_u8) (rhs: t_u8) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_U8 + #Core.Base_interface.Int.t_U8 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Less ) -> true + | _ -> false); + f_le_pre = (fun (self: t_u8) (rhs: t_u8) -> true); + f_le_post = (fun (self: t_u8) (rhs: t_u8) (out: bool) -> true); + f_le + = + (fun (self: t_u8) (rhs: t_u8) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_U8 + #Core.Base_interface.Int.t_U8 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Less ) + | Core.Option.Option_Some (Core.Cmp.Ordering_Equal ) -> true + | _ -> false); + f_gt_pre = (fun (self: t_u8) (rhs: t_u8) -> true); + f_gt_post = (fun (self: t_u8) (rhs: t_u8) (out: bool) -> true); + f_gt + = + (fun (self: t_u8) (rhs: t_u8) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_U8 + #Core.Base_interface.Int.t_U8 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Greater ) -> true + | _ -> false); + f_ge_pre = (fun (self: t_u8) (rhs: t_u8) -> true); + f_ge_post = (fun (self: t_u8) (rhs: t_u8) (out: bool) -> true); + f_ge + = + fun (self: t_u8) (rhs: t_u8) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_U8 + #Core.Base_interface.Int.t_U8 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Greater ) + | Core.Option.Option_Some (Core.Cmp.Ordering_Equal ) -> true + | _ -> false + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_26: Core.Cmp.t_PartialEq t_u16 t_u16 = + { + f_eq_pre = (fun (self: t_u16) (rhs: t_u16) -> true); + f_eq_post = (fun (self: t_u16) (rhs: t_u16) (out: bool) -> true); + f_eq = (fun (self: t_u16) (rhs: t_u16) -> self._0 =. rhs._0); + f_ne_pre = (fun (self: t_u16) (rhs: t_u16) -> true); + f_ne_post = (fun (self: t_u16) (rhs: t_u16) (out: bool) -> true); + f_ne = fun (self: t_u16) (rhs: t_u16) -> ~.(self._0 =. rhs._0 <: bool) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_27: Core.Cmp.t_PartialOrd t_u16 t_u16 = + { + _super_9014672428308350468 = FStar.Tactics.Typeclasses.solve; + f_partial_cmp_pre = (fun (self: t_u16) (rhs: t_u16) -> true); + f_partial_cmp_post + = + (fun (self: t_u16) (rhs: t_u16) (out: Core.Option.t_Option Core.Cmp.t_Ordering) -> true); + f_partial_cmp + = + (fun (self: t_u16) (rhs: t_u16) -> + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_U16 + #Core.Base_interface.Int.t_U16 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0); + f_lt_pre = (fun (self: t_u16) (rhs: t_u16) -> true); + f_lt_post = (fun (self: t_u16) (rhs: t_u16) (out: bool) -> true); + f_lt + = + (fun (self: t_u16) (rhs: t_u16) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_U16 + #Core.Base_interface.Int.t_U16 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Less ) -> true + | _ -> false); + f_le_pre = (fun (self: t_u16) (rhs: t_u16) -> true); + f_le_post = (fun (self: t_u16) (rhs: t_u16) (out: bool) -> true); + f_le + = + (fun (self: t_u16) (rhs: t_u16) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_U16 + #Core.Base_interface.Int.t_U16 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Less ) + | Core.Option.Option_Some (Core.Cmp.Ordering_Equal ) -> true + | _ -> false); + f_gt_pre = (fun (self: t_u16) (rhs: t_u16) -> true); + f_gt_post = (fun (self: t_u16) (rhs: t_u16) (out: bool) -> true); + f_gt + = + (fun (self: t_u16) (rhs: t_u16) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_U16 + #Core.Base_interface.Int.t_U16 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Greater ) -> true + | _ -> false); + f_ge_pre = (fun (self: t_u16) (rhs: t_u16) -> true); + f_ge_post = (fun (self: t_u16) (rhs: t_u16) (out: bool) -> true); + f_ge + = + fun (self: t_u16) (rhs: t_u16) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_U16 + #Core.Base_interface.Int.t_U16 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Greater ) + | Core.Option.Option_Some (Core.Cmp.Ordering_Equal ) -> true + | _ -> false + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_28: Core.Cmp.t_PartialEq t_u32 t_u32 = + { + f_eq_pre = (fun (self: t_u32) (rhs: t_u32) -> true); + f_eq_post = (fun (self: t_u32) (rhs: t_u32) (out: bool) -> true); + f_eq = (fun (self: t_u32) (rhs: t_u32) -> self._0 =. rhs._0); + f_ne_pre = (fun (self: t_u32) (rhs: t_u32) -> true); + f_ne_post = (fun (self: t_u32) (rhs: t_u32) (out: bool) -> true); + f_ne = fun (self: t_u32) (rhs: t_u32) -> ~.(self._0 =. rhs._0 <: bool) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_29: Core.Cmp.t_PartialOrd t_u32 t_u32 = + { + _super_9014672428308350468 = FStar.Tactics.Typeclasses.solve; + f_partial_cmp_pre = (fun (self: t_u32) (rhs: t_u32) -> true); + f_partial_cmp_post + = + (fun (self: t_u32) (rhs: t_u32) (out: Core.Option.t_Option Core.Cmp.t_Ordering) -> true); + f_partial_cmp + = + (fun (self: t_u32) (rhs: t_u32) -> + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_U32 + #Core.Base_interface.Int.t_U32 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0); + f_lt_pre = (fun (self: t_u32) (rhs: t_u32) -> true); + f_lt_post = (fun (self: t_u32) (rhs: t_u32) (out: bool) -> true); + f_lt + = + (fun (self: t_u32) (rhs: t_u32) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_U32 + #Core.Base_interface.Int.t_U32 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Less ) -> true + | _ -> false); + f_le_pre = (fun (self: t_u32) (rhs: t_u32) -> true); + f_le_post = (fun (self: t_u32) (rhs: t_u32) (out: bool) -> true); + f_le + = + (fun (self: t_u32) (rhs: t_u32) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_U32 + #Core.Base_interface.Int.t_U32 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Less ) + | Core.Option.Option_Some (Core.Cmp.Ordering_Equal ) -> true + | _ -> false); + f_gt_pre = (fun (self: t_u32) (rhs: t_u32) -> true); + f_gt_post = (fun (self: t_u32) (rhs: t_u32) (out: bool) -> true); + f_gt + = + (fun (self: t_u32) (rhs: t_u32) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_U32 + #Core.Base_interface.Int.t_U32 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Greater ) -> true + | _ -> false); + f_ge_pre = (fun (self: t_u32) (rhs: t_u32) -> true); + f_ge_post = (fun (self: t_u32) (rhs: t_u32) (out: bool) -> true); + f_ge + = + fun (self: t_u32) (rhs: t_u32) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_U32 + #Core.Base_interface.Int.t_U32 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Greater ) + | Core.Option.Option_Some (Core.Cmp.Ordering_Equal ) -> true + | _ -> false + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_30: Core.Cmp.t_PartialEq t_u64 t_u64 = + { + f_eq_pre = (fun (self: t_u64) (rhs: t_u64) -> true); + f_eq_post = (fun (self: t_u64) (rhs: t_u64) (out: bool) -> true); + f_eq = (fun (self: t_u64) (rhs: t_u64) -> self._0 =. rhs._0); + f_ne_pre = (fun (self: t_u64) (rhs: t_u64) -> true); + f_ne_post = (fun (self: t_u64) (rhs: t_u64) (out: bool) -> true); + f_ne = fun (self: t_u64) (rhs: t_u64) -> ~.(self._0 =. rhs._0 <: bool) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_31: Core.Cmp.t_PartialOrd t_u64 t_u64 = + { + _super_9014672428308350468 = FStar.Tactics.Typeclasses.solve; + f_partial_cmp_pre = (fun (self: t_u64) (rhs: t_u64) -> true); + f_partial_cmp_post + = + (fun (self: t_u64) (rhs: t_u64) (out: Core.Option.t_Option Core.Cmp.t_Ordering) -> true); + f_partial_cmp + = + (fun (self: t_u64) (rhs: t_u64) -> + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_U64 + #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0); + f_lt_pre = (fun (self: t_u64) (rhs: t_u64) -> true); + f_lt_post = (fun (self: t_u64) (rhs: t_u64) (out: bool) -> true); + f_lt + = + (fun (self: t_u64) (rhs: t_u64) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_U64 + #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Less ) -> true + | _ -> false); + f_le_pre = (fun (self: t_u64) (rhs: t_u64) -> true); + f_le_post = (fun (self: t_u64) (rhs: t_u64) (out: bool) -> true); + f_le + = + (fun (self: t_u64) (rhs: t_u64) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_U64 + #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Less ) + | Core.Option.Option_Some (Core.Cmp.Ordering_Equal ) -> true + | _ -> false); + f_gt_pre = (fun (self: t_u64) (rhs: t_u64) -> true); + f_gt_post = (fun (self: t_u64) (rhs: t_u64) (out: bool) -> true); + f_gt + = + (fun (self: t_u64) (rhs: t_u64) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_U64 + #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Greater ) -> true + | _ -> false); + f_ge_pre = (fun (self: t_u64) (rhs: t_u64) -> true); + f_ge_post = (fun (self: t_u64) (rhs: t_u64) (out: bool) -> true); + f_ge + = + fun (self: t_u64) (rhs: t_u64) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_U64 + #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Greater ) + | Core.Option.Option_Some (Core.Cmp.Ordering_Equal ) -> true + | _ -> false + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_32: Core.Cmp.t_PartialEq t_u128 t_u128 = + { + f_eq_pre = (fun (self: t_u128) (rhs: t_u128) -> true); + f_eq_post = (fun (self: t_u128) (rhs: t_u128) (out: bool) -> true); + f_eq = (fun (self: t_u128) (rhs: t_u128) -> self._0 =. rhs._0); + f_ne_pre = (fun (self: t_u128) (rhs: t_u128) -> true); + f_ne_post = (fun (self: t_u128) (rhs: t_u128) (out: bool) -> true); + f_ne = fun (self: t_u128) (rhs: t_u128) -> ~.(self._0 =. rhs._0 <: bool) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_33: Core.Cmp.t_PartialOrd t_u128 t_u128 = + { + _super_9014672428308350468 = FStar.Tactics.Typeclasses.solve; + f_partial_cmp_pre = (fun (self: t_u128) (rhs: t_u128) -> true); + f_partial_cmp_post + = + (fun (self: t_u128) (rhs: t_u128) (out: Core.Option.t_Option Core.Cmp.t_Ordering) -> true); + f_partial_cmp + = + (fun (self: t_u128) (rhs: t_u128) -> + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_U128 + #Core.Base_interface.Int.t_U128 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0); + f_lt_pre = (fun (self: t_u128) (rhs: t_u128) -> true); + f_lt_post = (fun (self: t_u128) (rhs: t_u128) (out: bool) -> true); + f_lt + = + (fun (self: t_u128) (rhs: t_u128) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_U128 + #Core.Base_interface.Int.t_U128 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Less ) -> true + | _ -> false); + f_le_pre = (fun (self: t_u128) (rhs: t_u128) -> true); + f_le_post = (fun (self: t_u128) (rhs: t_u128) (out: bool) -> true); + f_le + = + (fun (self: t_u128) (rhs: t_u128) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_U128 + #Core.Base_interface.Int.t_U128 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Less ) + | Core.Option.Option_Some (Core.Cmp.Ordering_Equal ) -> true + | _ -> false); + f_gt_pre = (fun (self: t_u128) (rhs: t_u128) -> true); + f_gt_post = (fun (self: t_u128) (rhs: t_u128) (out: bool) -> true); + f_gt + = + (fun (self: t_u128) (rhs: t_u128) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_U128 + #Core.Base_interface.Int.t_U128 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Greater ) -> true + | _ -> false); + f_ge_pre = (fun (self: t_u128) (rhs: t_u128) -> true); + f_ge_post = (fun (self: t_u128) (rhs: t_u128) (out: bool) -> true); + f_ge + = + fun (self: t_u128) (rhs: t_u128) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_U128 + #Core.Base_interface.Int.t_U128 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Greater ) + | Core.Option.Option_Some (Core.Cmp.Ordering_Equal ) -> true + | _ -> false + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_34: Core.Cmp.t_PartialEq t_usize t_usize = + { + f_eq_pre = (fun (self: t_usize) (rhs: t_usize) -> true); + f_eq_post = (fun (self: t_usize) (rhs: t_usize) (out: bool) -> true); + f_eq = (fun (self: t_usize) (rhs: t_usize) -> self._0 =. rhs._0); + f_ne_pre = (fun (self: t_usize) (rhs: t_usize) -> true); + f_ne_post = (fun (self: t_usize) (rhs: t_usize) (out: bool) -> true); + f_ne = fun (self: t_usize) (rhs: t_usize) -> ~.(self._0 =. rhs._0 <: bool) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_35: Core.Cmp.t_PartialOrd t_usize t_usize = + { + _super_9014672428308350468 = FStar.Tactics.Typeclasses.solve; + f_partial_cmp_pre = (fun (self: t_usize) (rhs: t_usize) -> true); + f_partial_cmp_post + = + (fun (self: t_usize) (rhs: t_usize) (out: Core.Option.t_Option Core.Cmp.t_Ordering) -> true); + f_partial_cmp + = + (fun (self: t_usize) (rhs: t_usize) -> + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_U64 + #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0); + f_lt_pre = (fun (self: t_usize) (rhs: t_usize) -> true); + f_lt_post = (fun (self: t_usize) (rhs: t_usize) (out: bool) -> true); + f_lt + = + (fun (self: t_usize) (rhs: t_usize) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_U64 + #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Less ) -> true + | _ -> false); + f_le_pre = (fun (self: t_usize) (rhs: t_usize) -> true); + f_le_post = (fun (self: t_usize) (rhs: t_usize) (out: bool) -> true); + f_le + = + (fun (self: t_usize) (rhs: t_usize) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_U64 + #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Less ) + | Core.Option.Option_Some (Core.Cmp.Ordering_Equal ) -> true + | _ -> false); + f_gt_pre = (fun (self: t_usize) (rhs: t_usize) -> true); + f_gt_post = (fun (self: t_usize) (rhs: t_usize) (out: bool) -> true); + f_gt + = + (fun (self: t_usize) (rhs: t_usize) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_U64 + #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Greater ) -> true + | _ -> false); + f_ge_pre = (fun (self: t_usize) (rhs: t_usize) -> true); + f_ge_post = (fun (self: t_usize) (rhs: t_usize) (out: bool) -> true); + f_ge + = + fun (self: t_usize) (rhs: t_usize) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_U64 + #Core.Base_interface.Int.t_U64 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Greater ) + | Core.Option.Option_Some (Core.Cmp.Ordering_Equal ) -> true + | _ -> false + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_36: Core.Cmp.t_PartialEq t_i8 t_i8 = + { + f_eq_pre = (fun (self: t_i8) (rhs: t_i8) -> true); + f_eq_post = (fun (self: t_i8) (rhs: t_i8) (out: bool) -> true); + f_eq = (fun (self: t_i8) (rhs: t_i8) -> self._0 =. rhs._0); + f_ne_pre = (fun (self: t_i8) (rhs: t_i8) -> true); + f_ne_post = (fun (self: t_i8) (rhs: t_i8) (out: bool) -> true); + f_ne = fun (self: t_i8) (rhs: t_i8) -> ~.(self._0 =. rhs._0 <: bool) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_37: Core.Cmp.t_PartialOrd t_i8 t_i8 = + { + _super_9014672428308350468 = FStar.Tactics.Typeclasses.solve; + f_partial_cmp_pre = (fun (self: t_i8) (rhs: t_i8) -> true); + f_partial_cmp_post + = + (fun (self: t_i8) (rhs: t_i8) (out: Core.Option.t_Option Core.Cmp.t_Ordering) -> true); + f_partial_cmp + = + (fun (self: t_i8) (rhs: t_i8) -> + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_I8 + #Core.Base_interface.Int.t_I8 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0); + f_lt_pre = (fun (self: t_i8) (rhs: t_i8) -> true); + f_lt_post = (fun (self: t_i8) (rhs: t_i8) (out: bool) -> true); + f_lt + = + (fun (self: t_i8) (rhs: t_i8) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_I8 + #Core.Base_interface.Int.t_I8 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Less ) -> true + | _ -> false); + f_le_pre = (fun (self: t_i8) (rhs: t_i8) -> true); + f_le_post = (fun (self: t_i8) (rhs: t_i8) (out: bool) -> true); + f_le + = + (fun (self: t_i8) (rhs: t_i8) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_I8 + #Core.Base_interface.Int.t_I8 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Less ) + | Core.Option.Option_Some (Core.Cmp.Ordering_Equal ) -> true + | _ -> false); + f_gt_pre = (fun (self: t_i8) (rhs: t_i8) -> true); + f_gt_post = (fun (self: t_i8) (rhs: t_i8) (out: bool) -> true); + f_gt + = + (fun (self: t_i8) (rhs: t_i8) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_I8 + #Core.Base_interface.Int.t_I8 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Greater ) -> true + | _ -> false); + f_ge_pre = (fun (self: t_i8) (rhs: t_i8) -> true); + f_ge_post = (fun (self: t_i8) (rhs: t_i8) (out: bool) -> true); + f_ge + = + fun (self: t_i8) (rhs: t_i8) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_I8 + #Core.Base_interface.Int.t_I8 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Greater ) + | Core.Option.Option_Some (Core.Cmp.Ordering_Equal ) -> true + | _ -> false + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_38: Core.Cmp.t_PartialEq t_i16 t_i16 = + { + f_eq_pre = (fun (self: t_i16) (rhs: t_i16) -> true); + f_eq_post = (fun (self: t_i16) (rhs: t_i16) (out: bool) -> true); + f_eq = (fun (self: t_i16) (rhs: t_i16) -> self._0 =. rhs._0); + f_ne_pre = (fun (self: t_i16) (rhs: t_i16) -> true); + f_ne_post = (fun (self: t_i16) (rhs: t_i16) (out: bool) -> true); + f_ne = fun (self: t_i16) (rhs: t_i16) -> ~.(self._0 =. rhs._0 <: bool) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_39: Core.Cmp.t_PartialOrd t_i16 t_i16 = + { + _super_9014672428308350468 = FStar.Tactics.Typeclasses.solve; + f_partial_cmp_pre = (fun (self: t_i16) (rhs: t_i16) -> true); + f_partial_cmp_post + = + (fun (self: t_i16) (rhs: t_i16) (out: Core.Option.t_Option Core.Cmp.t_Ordering) -> true); + f_partial_cmp + = + (fun (self: t_i16) (rhs: t_i16) -> + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_I16 + #Core.Base_interface.Int.t_I16 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0); + f_lt_pre = (fun (self: t_i16) (rhs: t_i16) -> true); + f_lt_post = (fun (self: t_i16) (rhs: t_i16) (out: bool) -> true); + f_lt + = + (fun (self: t_i16) (rhs: t_i16) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_I16 + #Core.Base_interface.Int.t_I16 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Less ) -> true + | _ -> false); + f_le_pre = (fun (self: t_i16) (rhs: t_i16) -> true); + f_le_post = (fun (self: t_i16) (rhs: t_i16) (out: bool) -> true); + f_le + = + (fun (self: t_i16) (rhs: t_i16) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_I16 + #Core.Base_interface.Int.t_I16 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Less ) + | Core.Option.Option_Some (Core.Cmp.Ordering_Equal ) -> true + | _ -> false); + f_gt_pre = (fun (self: t_i16) (rhs: t_i16) -> true); + f_gt_post = (fun (self: t_i16) (rhs: t_i16) (out: bool) -> true); + f_gt + = + (fun (self: t_i16) (rhs: t_i16) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_I16 + #Core.Base_interface.Int.t_I16 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Greater ) -> true + | _ -> false); + f_ge_pre = (fun (self: t_i16) (rhs: t_i16) -> true); + f_ge_post = (fun (self: t_i16) (rhs: t_i16) (out: bool) -> true); + f_ge + = + fun (self: t_i16) (rhs: t_i16) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_I16 + #Core.Base_interface.Int.t_I16 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Greater ) + | Core.Option.Option_Some (Core.Cmp.Ordering_Equal ) -> true + | _ -> false + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_40: Core.Cmp.t_PartialEq t_i32 t_i32 = + { + f_eq_pre = (fun (self: t_i32) (rhs: t_i32) -> true); + f_eq_post = (fun (self: t_i32) (rhs: t_i32) (out: bool) -> true); + f_eq = (fun (self: t_i32) (rhs: t_i32) -> self._0 =. rhs._0); + f_ne_pre = (fun (self: t_i32) (rhs: t_i32) -> true); + f_ne_post = (fun (self: t_i32) (rhs: t_i32) (out: bool) -> true); + f_ne = fun (self: t_i32) (rhs: t_i32) -> ~.(self._0 =. rhs._0 <: bool) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_41: Core.Cmp.t_PartialOrd t_i32 t_i32 = + { + _super_9014672428308350468 = FStar.Tactics.Typeclasses.solve; + f_partial_cmp_pre = (fun (self: t_i32) (rhs: t_i32) -> true); + f_partial_cmp_post + = + (fun (self: t_i32) (rhs: t_i32) (out: Core.Option.t_Option Core.Cmp.t_Ordering) -> true); + f_partial_cmp + = + (fun (self: t_i32) (rhs: t_i32) -> + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_I32 + #Core.Base_interface.Int.t_I32 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0); + f_lt_pre = (fun (self: t_i32) (rhs: t_i32) -> true); + f_lt_post = (fun (self: t_i32) (rhs: t_i32) (out: bool) -> true); + f_lt + = + (fun (self: t_i32) (rhs: t_i32) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_I32 + #Core.Base_interface.Int.t_I32 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Less ) -> true + | _ -> false); + f_le_pre = (fun (self: t_i32) (rhs: t_i32) -> true); + f_le_post = (fun (self: t_i32) (rhs: t_i32) (out: bool) -> true); + f_le + = + (fun (self: t_i32) (rhs: t_i32) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_I32 + #Core.Base_interface.Int.t_I32 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Less ) + | Core.Option.Option_Some (Core.Cmp.Ordering_Equal ) -> true + | _ -> false); + f_gt_pre = (fun (self: t_i32) (rhs: t_i32) -> true); + f_gt_post = (fun (self: t_i32) (rhs: t_i32) (out: bool) -> true); + f_gt + = + (fun (self: t_i32) (rhs: t_i32) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_I32 + #Core.Base_interface.Int.t_I32 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Greater ) -> true + | _ -> false); + f_ge_pre = (fun (self: t_i32) (rhs: t_i32) -> true); + f_ge_post = (fun (self: t_i32) (rhs: t_i32) (out: bool) -> true); + f_ge + = + fun (self: t_i32) (rhs: t_i32) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_I32 + #Core.Base_interface.Int.t_I32 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Greater ) + | Core.Option.Option_Some (Core.Cmp.Ordering_Equal ) -> true + | _ -> false + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_42: Core.Cmp.t_PartialEq t_i64 t_i64 = + { + f_eq_pre = (fun (self: t_i64) (rhs: t_i64) -> true); + f_eq_post = (fun (self: t_i64) (rhs: t_i64) (out: bool) -> true); + f_eq = (fun (self: t_i64) (rhs: t_i64) -> self._0 =. rhs._0); + f_ne_pre = (fun (self: t_i64) (rhs: t_i64) -> true); + f_ne_post = (fun (self: t_i64) (rhs: t_i64) (out: bool) -> true); + f_ne = fun (self: t_i64) (rhs: t_i64) -> ~.(self._0 =. rhs._0 <: bool) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_43: Core.Cmp.t_PartialOrd t_i64 t_i64 = + { + _super_9014672428308350468 = FStar.Tactics.Typeclasses.solve; + f_partial_cmp_pre = (fun (self: t_i64) (rhs: t_i64) -> true); + f_partial_cmp_post + = + (fun (self: t_i64) (rhs: t_i64) (out: Core.Option.t_Option Core.Cmp.t_Ordering) -> true); + f_partial_cmp + = + (fun (self: t_i64) (rhs: t_i64) -> + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_I64 + #Core.Base_interface.Int.t_I64 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0); + f_lt_pre = (fun (self: t_i64) (rhs: t_i64) -> true); + f_lt_post = (fun (self: t_i64) (rhs: t_i64) (out: bool) -> true); + f_lt + = + (fun (self: t_i64) (rhs: t_i64) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_I64 + #Core.Base_interface.Int.t_I64 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Less ) -> true + | _ -> false); + f_le_pre = (fun (self: t_i64) (rhs: t_i64) -> true); + f_le_post = (fun (self: t_i64) (rhs: t_i64) (out: bool) -> true); + f_le + = + (fun (self: t_i64) (rhs: t_i64) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_I64 + #Core.Base_interface.Int.t_I64 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Less ) + | Core.Option.Option_Some (Core.Cmp.Ordering_Equal ) -> true + | _ -> false); + f_gt_pre = (fun (self: t_i64) (rhs: t_i64) -> true); + f_gt_post = (fun (self: t_i64) (rhs: t_i64) (out: bool) -> true); + f_gt + = + (fun (self: t_i64) (rhs: t_i64) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_I64 + #Core.Base_interface.Int.t_I64 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Greater ) -> true + | _ -> false); + f_ge_pre = (fun (self: t_i64) (rhs: t_i64) -> true); + f_ge_post = (fun (self: t_i64) (rhs: t_i64) (out: bool) -> true); + f_ge + = + fun (self: t_i64) (rhs: t_i64) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_I64 + #Core.Base_interface.Int.t_I64 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Greater ) + | Core.Option.Option_Some (Core.Cmp.Ordering_Equal ) -> true + | _ -> false + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_44: Core.Cmp.t_PartialEq t_i128 t_i128 = + { + f_eq_pre = (fun (self: t_i128) (rhs: t_i128) -> true); + f_eq_post = (fun (self: t_i128) (rhs: t_i128) (out: bool) -> true); + f_eq = (fun (self: t_i128) (rhs: t_i128) -> self._0 =. rhs._0); + f_ne_pre = (fun (self: t_i128) (rhs: t_i128) -> true); + f_ne_post = (fun (self: t_i128) (rhs: t_i128) (out: bool) -> true); + f_ne = fun (self: t_i128) (rhs: t_i128) -> ~.(self._0 =. rhs._0 <: bool) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_45: Core.Cmp.t_PartialOrd t_i128 t_i128 = + { + _super_9014672428308350468 = FStar.Tactics.Typeclasses.solve; + f_partial_cmp_pre = (fun (self: t_i128) (rhs: t_i128) -> true); + f_partial_cmp_post + = + (fun (self: t_i128) (rhs: t_i128) (out: Core.Option.t_Option Core.Cmp.t_Ordering) -> true); + f_partial_cmp + = + (fun (self: t_i128) (rhs: t_i128) -> + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_I128 + #Core.Base_interface.Int.t_I128 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0); + f_lt_pre = (fun (self: t_i128) (rhs: t_i128) -> true); + f_lt_post = (fun (self: t_i128) (rhs: t_i128) (out: bool) -> true); + f_lt + = + (fun (self: t_i128) (rhs: t_i128) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_I128 + #Core.Base_interface.Int.t_I128 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Less ) -> true + | _ -> false); + f_le_pre = (fun (self: t_i128) (rhs: t_i128) -> true); + f_le_post = (fun (self: t_i128) (rhs: t_i128) (out: bool) -> true); + f_le + = + (fun (self: t_i128) (rhs: t_i128) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_I128 + #Core.Base_interface.Int.t_I128 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Less ) + | Core.Option.Option_Some (Core.Cmp.Ordering_Equal ) -> true + | _ -> false); + f_gt_pre = (fun (self: t_i128) (rhs: t_i128) -> true); + f_gt_post = (fun (self: t_i128) (rhs: t_i128) (out: bool) -> true); + f_gt + = + (fun (self: t_i128) (rhs: t_i128) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_I128 + #Core.Base_interface.Int.t_I128 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Greater ) -> true + | _ -> false); + f_ge_pre = (fun (self: t_i128) (rhs: t_i128) -> true); + f_ge_post = (fun (self: t_i128) (rhs: t_i128) (out: bool) -> true); + f_ge + = + fun (self: t_i128) (rhs: t_i128) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_I128 + #Core.Base_interface.Int.t_I128 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Greater ) + | Core.Option.Option_Some (Core.Cmp.Ordering_Equal ) -> true + | _ -> false + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_46: Core.Cmp.t_PartialEq t_isize t_isize = + { + f_eq_pre = (fun (self: t_isize) (rhs: t_isize) -> true); + f_eq_post = (fun (self: t_isize) (rhs: t_isize) (out: bool) -> true); + f_eq = (fun (self: t_isize) (rhs: t_isize) -> self._0 =. rhs._0); + f_ne_pre = (fun (self: t_isize) (rhs: t_isize) -> true); + f_ne_post = (fun (self: t_isize) (rhs: t_isize) (out: bool) -> true); + f_ne = fun (self: t_isize) (rhs: t_isize) -> ~.(self._0 =. rhs._0 <: bool) + } + +[@@ FStar.Tactics.Typeclasses.tcinstance] +let impl_47: Core.Cmp.t_PartialOrd t_isize t_isize = + { + _super_9014672428308350468 = FStar.Tactics.Typeclasses.solve; + f_partial_cmp_pre = (fun (self: t_isize) (rhs: t_isize) -> true); + f_partial_cmp_post + = + (fun (self: t_isize) (rhs: t_isize) (out: Core.Option.t_Option Core.Cmp.t_Ordering) -> true); + f_partial_cmp + = + (fun (self: t_isize) (rhs: t_isize) -> + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_I64 + #Core.Base_interface.Int.t_I64 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0); + f_lt_pre = (fun (self: t_isize) (rhs: t_isize) -> true); + f_lt_post = (fun (self: t_isize) (rhs: t_isize) (out: bool) -> true); + f_lt + = + (fun (self: t_isize) (rhs: t_isize) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_I64 + #Core.Base_interface.Int.t_I64 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Less ) -> true + | _ -> false); + f_le_pre = (fun (self: t_isize) (rhs: t_isize) -> true); + f_le_post = (fun (self: t_isize) (rhs: t_isize) (out: bool) -> true); + f_le + = + (fun (self: t_isize) (rhs: t_isize) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_I64 + #Core.Base_interface.Int.t_I64 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Less ) + | Core.Option.Option_Some (Core.Cmp.Ordering_Equal ) -> true + | _ -> false); + f_gt_pre = (fun (self: t_isize) (rhs: t_isize) -> true); + f_gt_post = (fun (self: t_isize) (rhs: t_isize) (out: bool) -> true); + f_gt + = + (fun (self: t_isize) (rhs: t_isize) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_I64 + #Core.Base_interface.Int.t_I64 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Greater ) -> true + | _ -> false); + f_ge_pre = (fun (self: t_isize) (rhs: t_isize) -> true); + f_ge_post = (fun (self: t_isize) (rhs: t_isize) (out: bool) -> true); + f_ge + = + fun (self: t_isize) (rhs: t_isize) -> + match + Core.Cmp.f_partial_cmp #Core.Base_interface.Int.t_I64 + #Core.Base_interface.Int.t_I64 + #FStar.Tactics.Typeclasses.solve + self._0 + rhs._0 + with + | Core.Option.Option_Some (Core.Cmp.Ordering_Greater ) + | Core.Option.Option_Some (Core.Cmp.Ordering_Equal ) -> true + | _ -> false + } diff --git a/proof-libs/fstar/generated_core/Core.Result.fst b/proof-libs/fstar/generated_core/Core.Result.fst new file mode 100644 index 000000000..cd4873cfe --- /dev/null +++ b/proof-libs/fstar/generated_core/Core.Result.fst @@ -0,0 +1,13 @@ +module Core.Result +#set-options "--fuel 0 --ifuel 1 --z3rlimit 15" +open Core +open FStar.Mul + +type t_Result (v_T: Type0) (v_E: Type0) = + | Result_Ok : v_T -> t_Result v_T v_E + | Result_Err : v_E -> t_Result v_T v_E + +let impl__ok (#v_T #v_E: Type0) (self: t_Result v_T v_E) : Core.Option.t_Option v_T = + match self with + | Result_Ok x -> Core.Option.Option_Some x <: Core.Option.t_Option v_T + | Result_Err _ -> Core.Option.Option_None <: Core.Option.t_Option v_T