; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(set-option :global-decls false)
(set-option :smt.mbqi false)
(set-option :auto_config false)
(set-option :produce-unsat-cores true)
(set-option :model true)
(set-option :smt.case_split 3)
(set-option :smt.relevancy 2)
(set-option :rewriter.enable_der false)
(set-option :rewriter.sort_disjunctions false)
(set-option :pi.decompose_patterns false)
(set-option :smt.arith.solver 6)
(set-option :random-seed 0)


(declare-sort FString)
(declare-fun FString_constr_id (FString) Int)

(declare-sort Term)
(declare-fun Term_constr_id (Term) Int)
(declare-sort Dummy_sort)
(declare-fun Dummy_value () Dummy_sort)
(declare-datatypes () ((Fuel 
(ZFuel) 
(SFuel (prec Fuel)))))
(declare-fun MaxIFuel () Fuel)
(declare-fun MaxFuel () Fuel)
(declare-fun PreType (Term) Term)
(declare-fun Valid (Term) Bool)
(declare-fun HasTypeFuel (Fuel Term Term) Bool)
(define-fun HasTypeZ ((x Term) (t Term)) Bool
(HasTypeFuel ZFuel x t))
(define-fun HasType ((x Term) (t Term)) Bool
(HasTypeFuel MaxIFuel x t))
(declare-fun IsTotFun (Term) Bool)

                ;;fuel irrelevance
(assert (forall ((f Fuel) (x Term) (t Term))
(! (= (HasTypeFuel (SFuel f) x t)
(HasTypeZ x t))
:pattern ((HasTypeFuel (SFuel f) x t)))))
(declare-fun NoHoist (Term Bool) Bool)
;;no-hoist
(assert (forall ((dummy Term) (b Bool))
(! (= (NoHoist dummy b) b)
:pattern ((NoHoist dummy b)))))
(define-fun  IsTyped ((x Term)) Bool
(exists ((t Term)) (HasTypeZ x t)))
(declare-fun ApplyTF (Term Fuel) Term)
(declare-fun ApplyTT (Term Term) Term)
(declare-fun Prec (Term Term) Bool)
(assert (forall ((x Term) (y Term) (z Term))
(! (implies (and (Prec x y) (Prec y z)) (Prec x z))
:pattern ((Prec x z) (Prec x y)))))
(assert (forall ((x Term) (y Term))
(implies (Prec x y)
(not (Prec y x)))))
(declare-fun Closure (Term) Term)
(declare-fun ConsTerm (Term Term) Term)
(declare-fun ConsFuel (Fuel Term) Term)
(declare-fun Tm_uvar (Int) Term)
(define-fun Reify ((x Term)) Term x)
(declare-fun Prims.precedes (Term Term Term Term) Term)
(declare-fun Range_const (Int) Term)
(declare-fun _mul (Int Int) Int)
(declare-fun _div (Int Int) Int)
(declare-fun _mod (Int Int) Int)
(declare-fun __uu__PartialApp () Term)
(assert (forall ((x Int) (y Int)) (! (= (_mul x y) (* x y)) :pattern ((_mul x y)))))
(assert (forall ((x Int) (y Int)) (! (= (_div x y) (div x y)) :pattern ((_div x y)))))
(assert (forall ((x Int) (y Int)) (! (= (_mod x y) (mod x y)) :pattern ((_mod x y)))))
(declare-fun _rmul (Real Real) Real)
(declare-fun _rdiv (Real Real) Real)
(assert (forall ((x Real) (y Real)) (! (= (_rmul x y) (* x y)) :pattern ((_rmul x y)))))
(assert (forall ((x Real) (y Real)) (! (= (_rdiv x y) (/ x y)) :pattern ((_rdiv x y)))))
(define-fun Unreachable () Bool false); <start constructor FString_const>
; Constructor
(declare-fun FString_const (Int) FString)
; Constructor distinct
;;; Fact-ids: 
(assert
 (! (forall ((@u0 Int))
   (! (= 0 (FString_constr_id (FString_const @u0)))
    :pattern ((FString_const @u0))
    :qid constructor_distinct_FString_const))
  :named constructor_distinct_FString_const))
; Projector
(declare-fun FString_const_proj_0 (FString) Int)
; Projection inverse
;;; Fact-ids: 
(assert
 (! (forall ((@u0 Int))
   (! (= (FString_const_proj_0 (FString_const @u0)) @u0)
    :pattern ((FString_const @u0))
    :qid projection_inverse_FString_const_proj_0))
  :named projection_inverse_FString_const_proj_0))
; Discriminator definition
(define-fun is-FString_const ((__@u0 FString)) Bool
 (and (= (FString_constr_id __@u0) 0) (= __@u0 (FString_const (FString_const_proj_0 __@u0)))))
; </end constructor FString_const>
; <start constructor Tm_type>
; Constructor
(declare-fun Tm_type () Term)
; Constructor distinct
;;; Fact-ids: 
(assert (! (= 2 (Term_constr_id Tm_type)) :named constructor_distinct_Tm_type))
; Discriminator definition
(define-fun is-Tm_type ((__@x0 Term)) Bool (and (= (Term_constr_id __@x0) 2) (= __@x0 Tm_type)))
; </end constructor Tm_type>
; <start constructor Tm_arrow>
; Constructor
(declare-fun Tm_arrow (Int) Term)
; Constructor distinct
;;; Fact-ids: 
(assert
 (! (forall ((@u0 Int))
   (! (= 3 (Term_constr_id (Tm_arrow @u0)))
    :pattern ((Tm_arrow @u0))
    :qid constructor_distinct_Tm_arrow))
  :named constructor_distinct_Tm_arrow))
; Projector
(declare-fun Tm_arrow_id (Term) Int)
; Projection inverse
;;; Fact-ids: 
(assert
 (! (forall ((@u0 Int))
   (! (= (Tm_arrow_id (Tm_arrow @u0)) @u0)
    :pattern ((Tm_arrow @u0))
    :qid projection_inverse_Tm_arrow_id))
  :named projection_inverse_Tm_arrow_id))
; Discriminator definition
(define-fun is-Tm_arrow ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0) 3) (= __@x0 (Tm_arrow (Tm_arrow_id __@x0)))))
; </end constructor Tm_arrow>
; <start constructor Tm_unit>
; Constructor
(declare-fun Tm_unit () Term)
; Constructor distinct
;;; Fact-ids: 
(assert (! (= 6 (Term_constr_id Tm_unit)) :named constructor_distinct_Tm_unit))
; Discriminator definition
(define-fun is-Tm_unit ((__@x0 Term)) Bool (and (= (Term_constr_id __@x0) 6) (= __@x0 Tm_unit)))
; </end constructor Tm_unit>
; <start constructor BoxInt>
; Constructor
(declare-fun BoxInt (Int) Term)
; Constructor distinct
;;; Fact-ids: 
(assert
 (! (forall ((@u0 Int))
   (! (= 7 (Term_constr_id (BoxInt @u0))) :pattern ((BoxInt @u0)) :qid constructor_distinct_BoxInt))
  :named constructor_distinct_BoxInt))
; Projector
(declare-fun BoxInt_proj_0 (Term) Int)
; Projection inverse
;;; Fact-ids: 
(assert
 (! (forall ((@u0 Int))
   (! (= (BoxInt_proj_0 (BoxInt @u0)) @u0)
    :pattern ((BoxInt @u0))
    :qid projection_inverse_BoxInt_proj_0))
  :named projection_inverse_BoxInt_proj_0))
; Discriminator definition
(define-fun is-BoxInt ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0) 7) (= __@x0 (BoxInt (BoxInt_proj_0 __@x0)))))
; </end constructor BoxInt>
; <start constructor BoxBool>
; Constructor
(declare-fun BoxBool (Bool) Term)
; Constructor distinct
;;; Fact-ids: 
(assert
 (! (forall ((@u0 Bool))
   (! (= 8 (Term_constr_id (BoxBool @u0)))
    :pattern ((BoxBool @u0))
    :qid constructor_distinct_BoxBool))
  :named constructor_distinct_BoxBool))
; Projector
(declare-fun BoxBool_proj_0 (Term) Bool)
; Projection inverse
;;; Fact-ids: 
(assert
 (! (forall ((@u0 Bool))
   (! (= (BoxBool_proj_0 (BoxBool @u0)) @u0)
    :pattern ((BoxBool @u0))
    :qid projection_inverse_BoxBool_proj_0))
  :named projection_inverse_BoxBool_proj_0))
; Discriminator definition
(define-fun is-BoxBool ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0) 8) (= __@x0 (BoxBool (BoxBool_proj_0 __@x0)))))
; </end constructor BoxBool>
; <start constructor BoxString>
; Constructor
(declare-fun BoxString (FString) Term)
; Constructor distinct
;;; Fact-ids: 
(assert
 (! (forall ((@u0 FString))
   (! (= 9 (Term_constr_id (BoxString @u0)))
    :pattern ((BoxString @u0))
    :qid constructor_distinct_BoxString))
  :named constructor_distinct_BoxString))
; Projector
(declare-fun BoxString_proj_0 (Term) FString)
; Projection inverse
;;; Fact-ids: 
(assert
 (! (forall ((@u0 FString))
   (! (= (BoxString_proj_0 (BoxString @u0)) @u0)
    :pattern ((BoxString @u0))
    :qid projection_inverse_BoxString_proj_0))
  :named projection_inverse_BoxString_proj_0))
; Discriminator definition
(define-fun is-BoxString ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0) 9) (= __@x0 (BoxString (BoxString_proj_0 __@x0)))))
; </end constructor BoxString>
; <start constructor BoxReal>
; Constructor
(declare-fun BoxReal (Real) Term)
; Constructor distinct
;;; Fact-ids: 
(assert
 (! (forall ((@u0 Real))
   (! (= 10 (Term_constr_id (BoxReal @u0)))
    :pattern ((BoxReal @u0))
    :qid constructor_distinct_BoxReal))
  :named constructor_distinct_BoxReal))
; Projector
(declare-fun BoxReal_proj_0 (Term) Real)
; Projection inverse
;;; Fact-ids: 
(assert
 (! (forall ((@u0 Real))
   (! (= (BoxReal_proj_0 (BoxReal @u0)) @u0)
    :pattern ((BoxReal @u0))
    :qid projection_inverse_BoxReal_proj_0))
  :named projection_inverse_BoxReal_proj_0))
; Discriminator definition
(define-fun is-BoxReal ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0) 10) (= __@x0 (BoxReal (BoxReal_proj_0 __@x0)))))
; </end constructor BoxReal>
(declare-fun Prims.precedes@tok () Term)
(assert
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
(! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.precedes@tok @x0) @x1) @x2) @x3)
        (Prims.precedes @x0 @x1 @x2 @x3))
:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.precedes@tok @x0) @x1) @x2) @x3)))))

(declare-fun Prims.lex_t () Term)
(assert (forall ((t1 Term) (t2 Term) (e1 Term) (e2 Term))
(! (iff (Valid (Prims.precedes t1 t2 e1 e2))
(Valid (Prims.precedes Prims.lex_t Prims.lex_t e1 e2)))
:pattern (Prims.precedes t1 t2 e1 e2))))
(assert (forall ((t1 Term) (t2 Term))
(! (iff (Valid (Prims.precedes Prims.lex_t Prims.lex_t t1 t2)) 
(Prec t1 t2))
:pattern ((Prims.precedes Prims.lex_t Prims.lex_t t1 t2)))))
(assert (forall ((e Term) (t Term))
(! (implies (HasType e t)
(Valid t))
:pattern ((HasType e t)
(Valid t))
:qid __prelude_valid_intro)))

; Externals for module Prims
; <Start encoding val Prims.attribute>
(declare-fun Prims.attribute () Term)
; </end encoding val Prims.attribute>

; <Start encoding val Prims.cps>
(declare-fun Prims.cps () Term)
; </end encoding val Prims.cps>

; <Start encoding val Prims.tac_opaque>
(declare-fun Prims.tac_opaque () Term)
; </end encoding val Prims.tac_opaque>

; <Start encoding val Prims.projector>
(declare-fun Prims.projector () Term)
; </end encoding val Prims.projector>

; <Start encoding val Prims.discriminator>
(declare-fun Prims.discriminator () Term)
; </end encoding val Prims.discriminator>

; <Start encoding val Prims.unrefine>
(declare-fun Prims.unrefine () Term)
; </end encoding val Prims.unrefine>

; <Start encoding val Prims.do_not_unrefine>
(declare-fun Prims.do_not_unrefine () Term)
; </end encoding val Prims.do_not_unrefine>

; <Start encoding val Prims.hasEq>
(declare-fun Prims.hasEq (Term) Term)
(declare-fun Tm_arrow_ef9cb512a25ee351fa5536d617490497 () Term)
(declare-fun Prims.hasEq@tok () Term)
; </end encoding val Prims.hasEq>

; <Start encoding let eqtype>
(declare-fun Prims.eqtype () Term)
(declare-fun Tm_refine_414d0a9f578ab0048252f8c8f552b99f () Term)
; </end encoding let eqtype>

; <Start encoding val Prims.bool>
(declare-fun Prims.bool () Term)
; </end encoding val Prims.bool>

; <Start encoding type Prims.empty>
; Constructor
(declare-fun Prims.empty () Term)
; <start constructor Prims.empty>
; Discriminator definition
(define-fun is-Prims.empty ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0) 111) (= __@x0 Prims.empty)))
; </end constructor Prims.empty>
; </end encoding type Prims.empty>

; <Start encoding type Prims.trivial>
; Constructor
(declare-fun Prims.trivial () Term)
; Constructor
(declare-fun Prims.T () Term)
; data constructor proxy: Prims.T
(declare-fun Prims.T@tok () Term)
; <start constructor Prims.trivial>
; Discriminator definition
(define-fun is-Prims.trivial ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0) 116) (= __@x0 Prims.trivial)))
; </end constructor Prims.trivial>
; <start constructor Prims.T>
; Discriminator definition
(define-fun is-Prims.T ((__@x0 Term)) Bool (and (= (Term_constr_id __@x0) 122) (= __@x0 Prims.T)))
; </end constructor Prims.T>
; </end encoding type Prims.trivial>

; <Start encoding val Prims.uu___is_T>
(declare-fun Prims.uu___is_T (Term) Term)
(declare-fun Tm_arrow_053f01f066524059a49c5dc621e6494a () Term)
(declare-fun Prims.uu___is_T@tok () Term)
; </end encoding val Prims.uu___is_T>

; <Start encoding val Prims.unit>
(declare-fun Prims.unit () Term)
; </end encoding val Prims.unit>

; <Start encoding let squash>
(declare-fun Prims.squash (Term) Term)

(declare-fun Prims.squash@tok () Term)
(declare-fun Tm_refine_2de20c066034c13bf76e9c0b94f4806c (Term) Term)
; </end encoding let squash>

; <Start encoding let auto_squash>
(declare-fun Prims.auto_squash (Term) Term)

(declare-fun Prims.auto_squash@tok () Term)
; </end encoding let auto_squash>

; <Start encoding let logical>
(declare-fun Prims.logical () Term)
; </end encoding let logical>

; <Start encoding val Prims.smt_theory_symbol>
(declare-fun Prims.smt_theory_symbol () Term)
; </end encoding val Prims.smt_theory_symbol>

; <Start encoding let l_True>
(declare-fun Prims.l_True () Term)
; </end encoding let l_True>

; <Start encoding let l_False>
(declare-fun Prims.l_False () Term)
; </end encoding let l_False>

; <Start encoding type Prims.equals>
; Constructor
(declare-fun Prims.equals (Term Term Term) Term)
; token
(declare-fun Prims.equals@tok () Term)
; Constructor
(declare-fun Prims.Refl (Term Term) Term)
; Constructor base
(declare-fun Prims.Refl@base () Term)
; data constructor proxy: Prims.Refl
(declare-fun Prims.Refl@tok () Term)
(declare-fun Tm_arrow_8e00c6263684633abbc1d1a87608e391 () Term)
; <start constructor Prims.equals>
; Discriminator definition
(define-fun is-Prims.equals ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 134)
  (exists ((@x0 Term) (@x1 Term) (@x2 Term))
   (! (= __@x0 (Prims.equals @x0 @x1 @x2)) :qid is-Prims.equals))))
; </end constructor Prims.equals>
; <start constructor Prims.Refl>
; Discriminator definition
(define-fun is-Prims.Refl ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 141)
  (exists ((@x0 Term) (@x1 Term)) (! (= __@x0 (Prims.Refl @x0 @x1)) :qid is-Prims.Refl))))
; </end constructor Prims.Refl>
; </end encoding type Prims.equals>

; <Start encoding val Prims.uu___is_Refl>
(declare-fun Prims.uu___is_Refl (Term Term Term Term) Term)
(declare-fun Tm_arrow_2a4540f76c8969717ea911077d7b4d15 () Term)
(declare-fun Prims.uu___is_Refl@tok () Term)
; </end encoding val Prims.uu___is_Refl>

; <Start encoding let eq2>
(declare-fun Prims.eq2 (Term Term Term) Term)
(declare-fun Tm_arrow_1ec40cec1da281b45a559c74dd57f3b7 () Term)
(declare-fun Prims.eq2@tok () Term)
; </end encoding let eq2>

; <Start encoding let b2t>
(declare-fun Prims.b2t (Term) Term)
; </end encoding let b2t>

; <Start encoding type Prims.pair>
; Constructor
(declare-fun Prims.pair (Term Term) Term)
; token
(declare-fun Prims.pair@tok () Term)
; Constructor
(declare-fun Prims.Pair (Term Term Term Term) Term)
; Projector
(declare-fun Prims.Pair_p (Term) Term)
; Projector
(declare-fun Prims.Pair_q (Term) Term)
; Projector
(declare-fun Prims.Pair__1 (Term) Term)
; Projector
(declare-fun Prims.Pair__2 (Term) Term)
; data constructor proxy: Prims.Pair
(declare-fun Prims.Pair@tok () Term)
(declare-fun Tm_arrow_e2b0096073073582c70f249d40f91c5d () Term)
; <start constructor Prims.pair>
; Discriminator definition
(define-fun is-Prims.pair ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 150)
  (exists ((@x0 Term) (@x1 Term)) (! (= __@x0 (Prims.pair @x0 @x1)) :qid is-Prims.pair))))
; </end constructor Prims.pair>
; <start constructor Prims.Pair>
; Discriminator definition
(define-fun is-Prims.Pair ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 157)
  (=
   __@x0
   (Prims.Pair (Prims.Pair_p __@x0) (Prims.Pair_q __@x0) (Prims.Pair__1 __@x0) (Prims.Pair__2 __@x0)))))
; </end constructor Prims.Pair>
; </end encoding type Prims.pair>

; <Start encoding val Prims.uu___is_Pair>
(declare-fun Prims.uu___is_Pair (Term Term Term) Term)
(declare-fun Tm_arrow_0a519c999e1325381ee4c9b1d93a06b2 () Term)
(declare-fun Prims.uu___is_Pair@tok () Term)
; </end encoding val Prims.uu___is_Pair>

; <Start encoding val Prims.__proj__Pair__item___1>
(declare-fun Prims.__proj__Pair__item___1 (Term Term Term) Term)
(declare-fun Tm_arrow_214b45775d1504fb2699ff0d156b6857 () Term)
(declare-fun Prims.__proj__Pair__item___1@tok () Term)
; </end encoding val Prims.__proj__Pair__item___1>

; <Start encoding val Prims.__proj__Pair__item___2>
(declare-fun Prims.__proj__Pair__item___2 (Term Term Term) Term)
(declare-fun Tm_arrow_1b97dbe8f5eb289f51cc2556690371e3 () Term)
(declare-fun Prims.__proj__Pair__item___2@tok () Term)
; </end encoding val Prims.__proj__Pair__item___2>

; <Start encoding let l_and>
(declare-fun Prims.l_and (Term Term) Term)
(declare-fun Tm_arrow_289ee2cc5874944bf725b9e3db8c0fd6 () Term)
(declare-fun Prims.l_and@tok () Term)
; </end encoding let l_and>

; <Start encoding type Prims.sum>
; Constructor
(declare-fun Prims.sum (Term Term) Term)
; token
(declare-fun Prims.sum@tok () Term)
; Constructor
(declare-fun Prims.Left (Term Term Term) Term)
; Projector
(declare-fun Prims.Left_p (Term) Term)
; Projector
(declare-fun Prims.Left_q (Term) Term)
; Projector
(declare-fun Prims.Left_v (Term) Term)
; data constructor proxy: Prims.Left
(declare-fun Prims.Left@tok () Term)
; Constructor
(declare-fun Prims.Right (Term Term Term) Term)
; Projector
(declare-fun Prims.Right_p (Term) Term)
; Projector
(declare-fun Prims.Right_q (Term) Term)
; Projector
(declare-fun Prims.Right_v (Term) Term)
; data constructor proxy: Prims.Right
(declare-fun Prims.Right@tok () Term)
(declare-fun Tm_arrow_4ef073c03ed003774fe6ccb4064aeebd () Term)
(declare-fun Tm_arrow_c537ccd7fef2183d55f1a6960ee793b0 () Term)
; <start constructor Prims.sum>
; Discriminator definition
(define-fun is-Prims.sum ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 169)
  (exists ((@x0 Term) (@x1 Term)) (! (= __@x0 (Prims.sum @x0 @x1)) :qid is-Prims.sum))))
; </end constructor Prims.sum>
; <start constructor Prims.Left>
; Discriminator definition
(define-fun is-Prims.Left ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 176)
  (= __@x0 (Prims.Left (Prims.Left_p __@x0) (Prims.Left_q __@x0) (Prims.Left_v __@x0)))))
; </end constructor Prims.Left>
; <start constructor Prims.Right>
; Discriminator definition
(define-fun is-Prims.Right ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 181)
  (= __@x0 (Prims.Right (Prims.Right_p __@x0) (Prims.Right_q __@x0) (Prims.Right_v __@x0)))))
; </end constructor Prims.Right>
; </end encoding type Prims.sum>

; <Start encoding val Prims.uu___is_Left>
(declare-fun Prims.uu___is_Left (Term Term Term) Term)
(declare-fun Tm_arrow_3c254c463840bdea2ca63f23cf7c2f0c () Term)
(declare-fun Prims.uu___is_Left@tok () Term)
; </end encoding val Prims.uu___is_Left>

; <Start encoding val Prims.__proj__Left__item__v>
(declare-fun Tm_refine_6140be01a70b18051829f178aaf0270b (Term Term) Term)
(declare-fun Prims.__proj__Left__item__v (Term Term Term) Term)

(declare-fun Tm_arrow_aaf070885513892396497eef726adce1 () Term)
(declare-fun Prims.__proj__Left__item__v@tok () Term)
; </end encoding val Prims.__proj__Left__item__v>

; <Start encoding val Prims.uu___is_Right>
(declare-fun Prims.uu___is_Right (Term Term Term) Term)

(declare-fun Prims.uu___is_Right@tok () Term)
; </end encoding val Prims.uu___is_Right>

; <Start encoding val Prims.__proj__Right__item__v>
(declare-fun Tm_refine_43ea5cf89e866ce271f97bd6ce102588 (Term Term) Term)
(declare-fun Prims.__proj__Right__item__v (Term Term Term) Term)

(declare-fun Tm_arrow_4ae0e7dd85e55aec7e8190dea6e3997f () Term)
(declare-fun Prims.__proj__Right__item__v@tok () Term)
; </end encoding val Prims.__proj__Right__item__v>

; <Start encoding let l_or>
(declare-fun Prims.l_or (Term Term) Term)

(declare-fun Prims.l_or@tok () Term)
; </end encoding let l_or>

; <Start encoding let l_imp>
(declare-fun Prims.l_imp (Term Term) Term)

(declare-fun Prims.l_imp@tok () Term)
(declare-fun Tm_ghost_arrow_0283b8a2a36bbec52abac4e3d837674a (Term Term) Term)
; </end encoding let l_imp>

; <Start encoding let l_iff>
(declare-fun Prims.l_iff (Term Term) Term)

(declare-fun Prims.l_iff@tok () Term)
; </end encoding let l_iff>

; <Start encoding let l_not>
(declare-fun Prims.l_not (Term) Term)
(declare-fun Tm_arrow_8178e3b6934aa50ea45bb0ccea2d9711 () Term)
(declare-fun Prims.l_not@tok () Term)
; </end encoding let l_not>

; <Skipped let l_ITE/>

; <Skipped val Prims.precedes/>

; <Start encoding val Prims.string>
(declare-fun Prims.string () Term)
; </end encoding val Prims.string>

; <Start encoding val Prims.warn_on_use>
(declare-fun Prims.warn_on_use (Term) Term)
(declare-fun Tm_arrow_2863eb88d7490a9c3cf347c16ca04740 () Term)
(declare-fun Prims.warn_on_use@tok () Term)
; </end encoding val Prims.warn_on_use>

; <Start encoding val Prims.deprecated>
(declare-fun Prims.deprecated (Term) Term)

(declare-fun Prims.deprecated@tok () Term)
; </end encoding val Prims.deprecated>

; <Start encoding val Prims.has_type>
(declare-fun Prims.has_type (Term Term Term) Term)
(declare-fun Tm_arrow_b5d8ed0243b8c7c893f2b329de57c62b () Term)
(declare-fun Prims.has_type@tok () Term)
; </end encoding val Prims.has_type>

; <Start encoding let l_Forall>
(declare-fun Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da (Term) Term)
(declare-fun Prims.l_Forall (Term Term) Term)

(declare-fun Tm_arrow_977ec6901669a051ac66211b8e72666a () Term)
(declare-fun Prims.l_Forall@tok () Term)

(declare-fun Tm_ghost_arrow_3aa447697277bb40c9738c9125c3e80f (Term Term) Term)
; </end encoding let l_Forall>

; <Skipped #push-options "--warn_error -288"/>

; <Start encoding let subtype_of>
(declare-fun Prims.subtype_of (Term Term) Term)
(declare-fun Tm_arrow_28becc0427b69ebf63ea956148504d97 () Term)
(declare-fun Prims.subtype_of@tok () Term)
; </end encoding let subtype_of>

; <Skipped #pop-options/>

; <Start encoding let prop>
(declare-fun Prims.prop () Term)
(declare-fun Tm_refine_73f210ca6e0061ed4a3150f69b8f33bf () Term)
; </end encoding let prop>

; <Start encoding let pure_pre>
(declare-fun Prims.pure_pre () Term)
; </end encoding let pure_pre>

; <Start encoding let pure_post'>
(declare-fun Prims.pure_post_ (Term Term) Term)
(declare-fun Tm_arrow_e4cf09589736facd1137944a1f5a00a6 () Term)
(declare-fun Prims.pure_post_@tok () Term)
(declare-fun Tm_refine_8d65e998a07dd53ec478e27017d9dba5 (Term Term) Term)
(declare-fun Tm_arrow_92458cff82f9ffee1f6e26a1c0c579f3 (Term Term) Term)
; </end encoding let pure_post'>

; <Start encoding let pure_post>
(declare-fun Prims.pure_post (Term) Term)

(declare-fun Prims.pure_post@tok () Term)
; </end encoding let pure_post>

; <Start encoding let pure_wp'>
(declare-fun Prims.pure_wp_ (Term) Term)

(declare-fun Prims.pure_wp_@tok () Term)
(declare-fun Tm_arrow_e5c03abbf8b0946a9aa7ee31bb7999a4 (Term) Term)
; </end encoding let pure_wp'>

; <Start encoding let pure_wp_monotonic0>
(declare-fun Prims.pure_wp_monotonic0 (Term Term) Term)
(declare-fun Tm_arrow_85436e2c1c64a4dd0159a737ef5b212e () Term)
(declare-fun Prims.pure_wp_monotonic0@tok () Term)
; </end encoding let pure_wp_monotonic0>

; <Start encoding let pure_wp_monotonic>
(declare-fun Prims.pure_wp_monotonic (Term Term) Term)

(declare-fun Prims.pure_wp_monotonic@tok () Term)
; </end encoding let pure_wp_monotonic>

; <Start encoding let pure_wp>
(declare-fun Prims.pure_wp (Term) Term)

(declare-fun Prims.pure_wp@tok () Term)
(declare-fun Tm_refine_15e0beb75f7033bad5fae236999feebe (Term) Term)
; </end encoding let pure_wp>

; <Start encoding val Prims.guard_free>
(declare-fun Prims.guard_free (Term) Term)

(declare-fun Prims.guard_free@tok () Term)
; </end encoding val Prims.guard_free>

; <Skipped let pure_return0/>

; <Skipped let pure_bind_wp0/>

; <Skipped let pure_if_then_else0/>

; <Skipped let pure_ite_wp0/>

; <Skipped let pure_stronger/>

; <Skipped let pure_close_wp0/>

; <Skipped let pure_trivial/>

; <Skipped new_effect { Prims.PURE ... }/>

; <Skipped effect Prims.Pure a pre post = Prims.PURE a/>

; <Skipped effect Prims.Admit a = Prims.PURE a/>

; <Skipped let pure_null_wp0/>

; <Skipped effect Prims.Tot a = Prims.PURE a/>

; <Start encoding let pure_assert_wp0>
(declare-fun Prims.pure_assert_wp0 (Term) Term)
(declare-fun Tm_arrow_14bcf5e7fc38d91827ecd9d25d3b3a67 () Term)
(declare-fun Prims.pure_assert_wp0@tok () Term)
; </end encoding let pure_assert_wp0>

; <Start encoding let pure_assume_wp0>
(declare-fun Prims.pure_assume_wp0 (Term) Term)

(declare-fun Prims.pure_assume_wp0@tok () Term)
; </end encoding let pure_assume_wp0>

; <Skipped new_effect { Prims.GHOST ... }/>

; <Skipped let purewp_id/>

; <Skipped sub_effect Prims.PURE ~> Prims.GHOST/>

; <Skipped effect Prims.Ghost a pre post = Prims.GHOST a/>

; <Skipped effect Prims.GTot a = Prims.GHOST a/>

; <Start encoding let op_Equals_Equals_Equals>
(declare-fun Prims.op_Equals_Equals_Equals (Term Term Term Term) Term)
(declare-fun Tm_arrow_7fcb145b23c2ac843afd9b126c4f71a9 () Term)
(declare-fun Prims.op_Equals_Equals_Equals@tok () Term)
; </end encoding let op_Equals_Equals_Equals>

; <Start encoding type Prims.dtuple2>
; Constructor
(declare-fun Prims.dtuple2 (Term Term) Term)
; token
(declare-fun Prims.dtuple2@tok () Term)
; Constructor
(declare-fun Prims.Mkdtuple2 (Term Term Term Term) Term)
; Projector
(declare-fun Prims.Mkdtuple2_a (Term) Term)
; Projector
(declare-fun Prims.Mkdtuple2_b (Term) Term)
; Projector
(declare-fun Prims.Mkdtuple2__1 (Term) Term)
; Projector
(declare-fun Prims.Mkdtuple2__2 (Term) Term)
; data constructor proxy: Prims.Mkdtuple2
(declare-fun Prims.Mkdtuple2@tok () Term)



(declare-fun Tm_arrow_22a50f5c5c9bb74bac4384fb8999be8b () Term)
; <start constructor Prims.dtuple2>
; Discriminator definition
(define-fun is-Prims.dtuple2 ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 258)
  (exists ((@x0 Term) (@x1 Term)) (! (= __@x0 (Prims.dtuple2 @x0 @x1)) :qid is-Prims.dtuple2))))
; </end constructor Prims.dtuple2>
; <start constructor Prims.Mkdtuple2>
; Discriminator definition
(define-fun is-Prims.Mkdtuple2 ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 267)
  (=
   __@x0
   (Prims.Mkdtuple2
    (Prims.Mkdtuple2_a __@x0)
    (Prims.Mkdtuple2_b __@x0)
    (Prims.Mkdtuple2__1 __@x0)
    (Prims.Mkdtuple2__2 __@x0)))))
; </end constructor Prims.Mkdtuple2>
; </end encoding type Prims.dtuple2>

; <Start encoding assume Prims.dtuple2__uu___haseq>

; </end encoding assume Prims.dtuple2__uu___haseq>

; <Start encoding val Prims.uu___is_Mkdtuple2>

(declare-fun Prims.uu___is_Mkdtuple2 (Term Term Term) Term)

(declare-fun Tm_arrow_e6f9f7cb1936ec43b52469e706dcadcc () Term)
(declare-fun Prims.uu___is_Mkdtuple2@tok () Term)
; </end encoding val Prims.uu___is_Mkdtuple2>

; <Skipped let uu___is_Mkdtuple2/>

; <Start encoding val Prims.__proj__Mkdtuple2__item___1>

(declare-fun Prims.__proj__Mkdtuple2__item___1 (Term Term Term) Term)

(declare-fun Tm_arrow_26c013ffba39d4f7eeb4bcc80d2d4e22 () Term)
(declare-fun Prims.__proj__Mkdtuple2__item___1@tok () Term)
; </end encoding val Prims.__proj__Mkdtuple2__item___1>

; <Skipped let __proj__Mkdtuple2__item___1/>

; <Start encoding val Prims.__proj__Mkdtuple2__item___2>

(declare-fun Prims.__proj__Mkdtuple2__item___2 (Term Term Term) Term)

(declare-fun Tm_arrow_870cc7701a0d9a8a2d6fb92427a97d66 () Term)
(declare-fun Prims.__proj__Mkdtuple2__item___2@tok () Term)
; </end encoding val Prims.__proj__Mkdtuple2__item___2>

; <Skipped let __proj__Mkdtuple2__item___2/>

; <Start encoding let l_Exists>

(declare-fun Prims.l_Exists (Term Term) Term)


(declare-fun Prims.l_Exists@tok () Term)


(declare-fun Tm_abs_6ba36691ee58dee85cd144324b083848 (Term Term) Term)
; </end encoding let l_Exists>

; <Start encoding val Prims.int>
(declare-fun Prims.int () Term)
; </end encoding val Prims.int>

; <Start encoding val Prims.op_AmpAmp>
(declare-fun Prims.op_AmpAmp (Term Term) Term)
(declare-fun Prims.op_AmpAmp@tok () Term)
; </end encoding val Prims.op_AmpAmp>

; <Start encoding val Prims.op_BarBar>
(declare-fun Prims.op_BarBar (Term Term) Term)
(declare-fun Prims.op_BarBar@tok () Term)
; </end encoding val Prims.op_BarBar>

; <Start encoding val Prims.op_Negation>
(declare-fun Prims.op_Negation (Term) Term)
(declare-fun Prims.op_Negation@tok () Term)
; </end encoding val Prims.op_Negation>

; <Start encoding val Prims.op_Multiply>
(declare-fun Prims.op_Multiply (Term Term) Term)
(declare-fun Prims.op_Multiply@tok () Term)
; </end encoding val Prims.op_Multiply>

; <Start encoding val Prims.op_Subtraction>
(declare-fun Prims.op_Subtraction (Term Term) Term)
(declare-fun Prims.op_Subtraction@tok () Term)
; </end encoding val Prims.op_Subtraction>

; <Start encoding val Prims.op_Addition>
(declare-fun Prims.op_Addition (Term Term) Term)
(declare-fun Prims.op_Addition@tok () Term)
; </end encoding val Prims.op_Addition>

; <Start encoding val Prims.op_Minus>
(declare-fun Prims.op_Minus (Term) Term)
(declare-fun Prims.op_Minus@tok () Term)
; </end encoding val Prims.op_Minus>

; <Start encoding val Prims.op_LessThanOrEqual>
(declare-fun Prims.op_LessThanOrEqual (Term Term) Term)
(declare-fun Prims.op_LessThanOrEqual@tok () Term)
; </end encoding val Prims.op_LessThanOrEqual>

; <Start encoding val Prims.op_GreaterThan>
(declare-fun Prims.op_GreaterThan (Term Term) Term)
(declare-fun Prims.op_GreaterThan@tok () Term)
; </end encoding val Prims.op_GreaterThan>

; <Start encoding val Prims.op_GreaterThanOrEqual>
(declare-fun Prims.op_GreaterThanOrEqual (Term Term) Term)
(declare-fun Prims.op_GreaterThanOrEqual@tok () Term)
; </end encoding val Prims.op_GreaterThanOrEqual>

; <Start encoding val Prims.op_LessThan>
(declare-fun Prims.op_LessThan (Term Term) Term)
(declare-fun Prims.op_LessThan@tok () Term)
; </end encoding val Prims.op_LessThan>

; <Start encoding val Prims.op_Equality>
(declare-fun Prims.op_Equality (Term Term Term) Term)
(declare-fun Prims.op_Equality@tok () Term)
; </end encoding val Prims.op_Equality>

; <Start encoding val Prims.op_disEquality>
(declare-fun Prims.op_disEquality (Term Term Term) Term)
(declare-fun Prims.op_disEquality@tok () Term)
; </end encoding val Prims.op_disEquality>

; <Start encoding val Prims.exn>
(declare-fun Prims.exn () Term)
; </end encoding val Prims.exn>

; <Start encoding val Prims.strcat>
(declare-fun Prims.strcat (Term Term) Term)
(declare-fun Tm_arrow_b66cecec1d56111347abe61e89557dd1 () Term)
(declare-fun Prims.strcat@tok () Term)
; </end encoding val Prims.strcat>

; <Skipped let op_Hat/>

; <Start encoding type Prims.list>
; Constructor
(declare-fun Prims.list (Term) Term)
; token
(declare-fun Prims.list@tok () Term)
; Constructor
(declare-fun Prims.Nil (Term) Term)
; Projector
(declare-fun Prims.Nil_a (Term) Term)
; data constructor proxy: Prims.Nil
(declare-fun Prims.Nil@tok () Term)
; Constructor
(declare-fun Prims.Cons (Term Term Term) Term)
; Projector
(declare-fun Prims.Cons_a (Term) Term)
; Projector
(declare-fun Prims.Cons_hd (Term) Term)
; Projector
(declare-fun Prims.Cons_tl (Term) Term)
; data constructor proxy: Prims.Cons
(declare-fun Prims.Cons@tok () Term)
(declare-fun Tm_arrow_3864bd5fbb999b4fe4487408df9b3401 () Term)
(declare-fun Tm_arrow_02c072760cbad0f5a4706f6cffab6c94 () Term)
; <start constructor Prims.list>
; Discriminator definition
(define-fun is-Prims.list ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 313)
  (exists ((@x0 Term)) (! (= __@x0 (Prims.list @x0)) :qid is-Prims.list))))
; </end constructor Prims.list>
; <start constructor Prims.Nil>
; Discriminator definition
(define-fun is-Prims.Nil ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0) 320) (= __@x0 (Prims.Nil (Prims.Nil_a __@x0)))))
; </end constructor Prims.Nil>
; <start constructor Prims.Cons>
; Discriminator definition
(define-fun is-Prims.Cons ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 325)
  (= __@x0 (Prims.Cons (Prims.Cons_a __@x0) (Prims.Cons_hd __@x0) (Prims.Cons_tl __@x0)))))
; </end constructor Prims.Cons>
; </end encoding type Prims.list>

; <Start encoding assume Prims.list__uu___haseq>
; </end encoding assume Prims.list__uu___haseq>

; <Start encoding val Prims.uu___is_Nil>
(declare-fun Prims.uu___is_Nil (Term Term) Term)
(declare-fun Tm_arrow_606904b0fa72729a20285beb231f9f2e () Term)
(declare-fun Prims.uu___is_Nil@tok () Term)
; </end encoding val Prims.uu___is_Nil>

; <Skipped let uu___is_Nil/>

; <Start encoding val Prims.uu___is_Cons>
(declare-fun Prims.uu___is_Cons (Term Term) Term)

(declare-fun Prims.uu___is_Cons@tok () Term)
; </end encoding val Prims.uu___is_Cons>

; <Skipped let uu___is_Cons/>

; <Start encoding val Prims.__proj__Cons__item__hd>
(declare-fun Tm_refine_7aac12c24449a22c34d98a0ea8ed4a32 (Term) Term)
(declare-fun Prims.__proj__Cons__item__hd (Term Term) Term)

(declare-fun Tm_arrow_27c3547831737e5a63950f3d18bf3d22 () Term)
(declare-fun Prims.__proj__Cons__item__hd@tok () Term)
; </end encoding val Prims.__proj__Cons__item__hd>

; <Skipped let __proj__Cons__item__hd/>

; <Start encoding val Prims.__proj__Cons__item__tl>

(declare-fun Prims.__proj__Cons__item__tl (Term Term) Term)

(declare-fun Tm_arrow_4e740085106d54d8b48ffe3c6c20ef21 () Term)
(declare-fun Prims.__proj__Cons__item__tl@tok () Term)
; </end encoding val Prims.__proj__Cons__item__tl>

; <Skipped let __proj__Cons__item__tl/>

; <Skipped effect Prims.M a = a/>

; <Start encoding let returnM>
(declare-fun Prims.returnM (Term Term) Term)
(declare-fun Tm_arrow_99724436653747ac6f5a6a00c64ff8bc () Term)
(declare-fun Prims.returnM@tok () Term)
; </end encoding let returnM>

; <Skipped let as_requires/>

; <Skipped let as_ensures/>

; <Start encoding val Prims._assume>
(declare-fun Prims._assume (Term) Term)
(declare-fun Non_total_Tm_arrow_724d0dab46b8b51a1bb19d329f7fc4b2 () Term)
(declare-fun Prims._assume@tok () Term)
; </end encoding val Prims._assume>

; <Start encoding val Prims.admit>
; Uninterpreted function symbol for impure function
(declare-fun Prims.admit (Term Term) Term)
; Uninterpreted name for impure function
(declare-fun Prims.admit@tok () Term)
; </end encoding val Prims.admit>

; <Start encoding val Prims.magic>
(declare-fun Prims.magic (Term Term) Term)
(declare-fun Tm_arrow_f5df98ce82fbcebbbdb844c958bee4fb () Term)
(declare-fun Prims.magic@tok () Term)
; </end encoding val Prims.magic>

; <Start encoding let unsafe_coerce>
(declare-fun Prims.unsafe_coerce (Term Term Term) Term)
(declare-fun Tm_arrow_443ab41008720460b7a09e280558a60f () Term)
(declare-fun Prims.unsafe_coerce@tok () Term)
; </end encoding let unsafe_coerce>

; <Start encoding val Prims.admitP>
(declare-fun Prims.admitP (Term) Term)

(declare-fun Prims.admitP@tok () Term)
; </end encoding val Prims.admitP>

; <Skipped val Prims._assert/>

; <Start encoding let _assert>
(declare-fun Prims._assert (Term) Term)
(declare-fun Non_total_Tm_arrow_bb2d1b4bdb07c87bf5990ad3e5fd8642 () Term)
(declare-fun Prims._assert@tok () Term)
; </end encoding let _assert>

; <Skipped val Prims.cut/>

; <Start encoding let cut>
(declare-fun Prims.cut (Term) Term)

(declare-fun Prims.cut@tok () Term)
; </end encoding let cut>

; <Start encoding let nat>
(declare-fun Prims.nat () Term)
(declare-fun Tm_refine_542f9d4f129664613f2483a6c88bc7c2 () Term)
; </end encoding let nat>

; <Start encoding let pos>
(declare-fun Prims.pos () Term)
(declare-fun Tm_refine_774ba3f728d91ead8ef40be66c9802e5 () Term)
; </end encoding let pos>

; <Start encoding let nonzero>
(declare-fun Prims.nonzero () Term)
(declare-fun Tm_refine_0766302b68bb44ab7aff8c4d8be0b46f () Term)
; </end encoding let nonzero>

; <Start encoding val Prims.op_Modulus>
(declare-fun Prims.op_Modulus (Term Term) Term)
(declare-fun Prims.op_Modulus@tok () Term)
; </end encoding val Prims.op_Modulus>

; <Start encoding val Prims.op_Division>
(declare-fun Prims.op_Division (Term Term) Term)
(declare-fun Prims.op_Division@tok () Term)
; </end encoding val Prims.op_Division>

; <Start encoding let rec pow2>
; Fuel-instrumented function name
(declare-fun Prims.pow2.fuel_instrumented (Fuel Term) Term)
; Token for fuel-instrumented partial applications
(declare-fun Prims.pow2.fuel_instrumented_token () Term)
(declare-fun Prims.pow2 (Term) Term)
(declare-fun Prims.pow2@tok () Term)
(declare-fun Tm_arrow_c331a0e032e021e1eaa359b3983de4f2 () Term)
; </end encoding let rec pow2>

; <Start encoding let min>
(declare-fun Prims.min (Term Term) Term)
(declare-fun Tm_arrow_47fc285d7b44e13bcb7e420cbfc55623 () Term)
(declare-fun Prims.min@tok () Term)
; </end encoding let min>

; <Start encoding let abs>
(declare-fun Prims.abs (Term) Term)
(declare-fun Tm_arrow_35447810753695c4fe25c93af1251992 () Term)
(declare-fun Prims.abs@tok () Term)
; </end encoding let abs>

; <Start encoding val Prims.string_of_bool>
(declare-fun Prims.string_of_bool (Term) Term)
(declare-fun Tm_arrow_e86b54405c2a58719f5e8112efd48c09 () Term)
(declare-fun Prims.string_of_bool@tok () Term)
; </end encoding val Prims.string_of_bool>

; <Start encoding val Prims.string_of_int>
(declare-fun Prims.string_of_int (Term) Term)
(declare-fun Tm_arrow_2bc066ec63734c94a3c008e1e72cae2b () Term)
(declare-fun Prims.string_of_int@tok () Term)
; </end encoding val Prims.string_of_int>

; <Start encoding let __cache_version_number__>
(declare-fun Prims.__cache_version_number__ () Term)
; </end encoding let __cache_version_number__>

; End Externals for module Prims
; Externals for interface FStar.Attributes
; <Start encoding type FStar.Attributes.__internal_ocaml_attributes>
; Constructor
(declare-fun FStar.Attributes.__internal_ocaml_attributes () Term)
; Constructor
(declare-fun FStar.Attributes.PpxDerivingShow () Term)
; data constructor proxy: FStar.Attributes.PpxDerivingShow
(declare-fun FStar.Attributes.PpxDerivingShow@tok () Term)
; Constructor
(declare-fun FStar.Attributes.PpxDerivingShowConstant (Term) Term)
; Projector
(declare-fun FStar.Attributes.PpxDerivingShowConstant__0 (Term) Term)
; data constructor proxy: FStar.Attributes.PpxDerivingShowConstant
(declare-fun FStar.Attributes.PpxDerivingShowConstant@tok () Term)
; Constructor
(declare-fun FStar.Attributes.PpxDerivingYoJson () Term)
; data constructor proxy: FStar.Attributes.PpxDerivingYoJson
(declare-fun FStar.Attributes.PpxDerivingYoJson@tok () Term)
; Constructor
(declare-fun FStar.Attributes.CInline () Term)
; data constructor proxy: FStar.Attributes.CInline
(declare-fun FStar.Attributes.CInline@tok () Term)
; Constructor
(declare-fun FStar.Attributes.Substitute () Term)
; data constructor proxy: FStar.Attributes.Substitute
(declare-fun FStar.Attributes.Substitute@tok () Term)
; Constructor
(declare-fun FStar.Attributes.Gc () Term)
; data constructor proxy: FStar.Attributes.Gc
(declare-fun FStar.Attributes.Gc@tok () Term)
; Constructor
(declare-fun FStar.Attributes.Comment (Term) Term)
; Projector
(declare-fun FStar.Attributes.Comment__0 (Term) Term)
; data constructor proxy: FStar.Attributes.Comment
(declare-fun FStar.Attributes.Comment@tok () Term)
; Constructor
(declare-fun FStar.Attributes.CPrologue (Term) Term)
; Projector
(declare-fun FStar.Attributes.CPrologue__0 (Term) Term)
; data constructor proxy: FStar.Attributes.CPrologue
(declare-fun FStar.Attributes.CPrologue@tok () Term)
; Constructor
(declare-fun FStar.Attributes.CEpilogue (Term) Term)
; Projector
(declare-fun FStar.Attributes.CEpilogue__0 (Term) Term)
; data constructor proxy: FStar.Attributes.CEpilogue
(declare-fun FStar.Attributes.CEpilogue@tok () Term)
; Constructor
(declare-fun FStar.Attributes.CConst (Term) Term)
; Projector
(declare-fun FStar.Attributes.CConst__0 (Term) Term)
; data constructor proxy: FStar.Attributes.CConst
(declare-fun FStar.Attributes.CConst@tok () Term)
; Constructor
(declare-fun FStar.Attributes.CCConv (Term) Term)
; Projector
(declare-fun FStar.Attributes.CCConv__0 (Term) Term)
; data constructor proxy: FStar.Attributes.CCConv
(declare-fun FStar.Attributes.CCConv@tok () Term)
; Constructor
(declare-fun FStar.Attributes.CAbstractStruct () Term)
; data constructor proxy: FStar.Attributes.CAbstractStruct
(declare-fun FStar.Attributes.CAbstractStruct@tok () Term)
; Constructor
(declare-fun FStar.Attributes.CIfDef () Term)
; data constructor proxy: FStar.Attributes.CIfDef
(declare-fun FStar.Attributes.CIfDef@tok () Term)
; Constructor
(declare-fun FStar.Attributes.CMacro () Term)
; data constructor proxy: FStar.Attributes.CMacro
(declare-fun FStar.Attributes.CMacro@tok () Term)
; Constructor
(declare-fun FStar.Attributes.CNoInline () Term)
; data constructor proxy: FStar.Attributes.CNoInline
(declare-fun FStar.Attributes.CNoInline@tok () Term)
(declare-fun Tm_arrow_4df7afdecd30bc8ccabe3b1c6376b54b () Term)





; <start constructor FStar.Attributes.__internal_ocaml_attributes>
; Discriminator definition
(define-fun is-FStar.Attributes.__internal_ocaml_attributes ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0) 101) (= __@x0 FStar.Attributes.__internal_ocaml_attributes)))
; </end constructor FStar.Attributes.__internal_ocaml_attributes>
; <start constructor FStar.Attributes.PpxDerivingShow>
; Discriminator definition
(define-fun is-FStar.Attributes.PpxDerivingShow ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0) 107) (= __@x0 FStar.Attributes.PpxDerivingShow)))
; </end constructor FStar.Attributes.PpxDerivingShow>
; <start constructor FStar.Attributes.PpxDerivingShowConstant>
; Discriminator definition
(define-fun is-FStar.Attributes.PpxDerivingShowConstant ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 109)
  (=
   __@x0
   (FStar.Attributes.PpxDerivingShowConstant (FStar.Attributes.PpxDerivingShowConstant__0 __@x0)))))
; </end constructor FStar.Attributes.PpxDerivingShowConstant>
; <start constructor FStar.Attributes.PpxDerivingYoJson>
; Discriminator definition
(define-fun is-FStar.Attributes.PpxDerivingYoJson ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0) 114) (= __@x0 FStar.Attributes.PpxDerivingYoJson)))
; </end constructor FStar.Attributes.PpxDerivingYoJson>
; <start constructor FStar.Attributes.CInline>
; Discriminator definition
(define-fun is-FStar.Attributes.CInline ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0) 116) (= __@x0 FStar.Attributes.CInline)))
; </end constructor FStar.Attributes.CInline>
; <start constructor FStar.Attributes.Substitute>
; Discriminator definition
(define-fun is-FStar.Attributes.Substitute ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0) 118) (= __@x0 FStar.Attributes.Substitute)))
; </end constructor FStar.Attributes.Substitute>
; <start constructor FStar.Attributes.Gc>
; Discriminator definition
(define-fun is-FStar.Attributes.Gc ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0) 120) (= __@x0 FStar.Attributes.Gc)))
; </end constructor FStar.Attributes.Gc>
; <start constructor FStar.Attributes.Comment>
; Discriminator definition
(define-fun is-FStar.Attributes.Comment ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 122)
  (= __@x0 (FStar.Attributes.Comment (FStar.Attributes.Comment__0 __@x0)))))
; </end constructor FStar.Attributes.Comment>
; <start constructor FStar.Attributes.CPrologue>
; Discriminator definition
(define-fun is-FStar.Attributes.CPrologue ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 127)
  (= __@x0 (FStar.Attributes.CPrologue (FStar.Attributes.CPrologue__0 __@x0)))))
; </end constructor FStar.Attributes.CPrologue>
; <start constructor FStar.Attributes.CEpilogue>
; Discriminator definition
(define-fun is-FStar.Attributes.CEpilogue ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 132)
  (= __@x0 (FStar.Attributes.CEpilogue (FStar.Attributes.CEpilogue__0 __@x0)))))
; </end constructor FStar.Attributes.CEpilogue>
; <start constructor FStar.Attributes.CConst>
; Discriminator definition
(define-fun is-FStar.Attributes.CConst ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 137)
  (= __@x0 (FStar.Attributes.CConst (FStar.Attributes.CConst__0 __@x0)))))
; </end constructor FStar.Attributes.CConst>
; <start constructor FStar.Attributes.CCConv>
; Discriminator definition
(define-fun is-FStar.Attributes.CCConv ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 142)
  (= __@x0 (FStar.Attributes.CCConv (FStar.Attributes.CCConv__0 __@x0)))))
; </end constructor FStar.Attributes.CCConv>
; <start constructor FStar.Attributes.CAbstractStruct>
; Discriminator definition
(define-fun is-FStar.Attributes.CAbstractStruct ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0) 147) (= __@x0 FStar.Attributes.CAbstractStruct)))
; </end constructor FStar.Attributes.CAbstractStruct>
; <start constructor FStar.Attributes.CIfDef>
; Discriminator definition
(define-fun is-FStar.Attributes.CIfDef ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0) 149) (= __@x0 FStar.Attributes.CIfDef)))
; </end constructor FStar.Attributes.CIfDef>
; <start constructor FStar.Attributes.CMacro>
; Discriminator definition
(define-fun is-FStar.Attributes.CMacro ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0) 151) (= __@x0 FStar.Attributes.CMacro)))
; </end constructor FStar.Attributes.CMacro>
; <start constructor FStar.Attributes.CNoInline>
; Discriminator definition
(define-fun is-FStar.Attributes.CNoInline ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0) 153) (= __@x0 FStar.Attributes.CNoInline)))
; </end constructor FStar.Attributes.CNoInline>
; </end encoding type FStar.Attributes.__internal_ocaml_attributes>

; <Start encoding assume FStar.Attributes.__internal_ocaml_attributes__uu___haseq>
; </end encoding assume FStar.Attributes.__internal_ocaml_attributes__uu___haseq>

; <Start encoding val FStar.Attributes.uu___is_PpxDerivingShow>
(declare-fun FStar.Attributes.uu___is_PpxDerivingShow (Term) Term)
(declare-fun Tm_arrow_81301e6aabb96c573cb5df06bd782860 () Term)
(declare-fun FStar.Attributes.uu___is_PpxDerivingShow@tok () Term)
; </end encoding val FStar.Attributes.uu___is_PpxDerivingShow>

; <Skipped let uu___is_PpxDerivingShow/>

; <Start encoding val FStar.Attributes.uu___is_PpxDerivingShowConstant>
(declare-fun FStar.Attributes.uu___is_PpxDerivingShowConstant (Term) Term)

(declare-fun FStar.Attributes.uu___is_PpxDerivingShowConstant@tok () Term)
; </end encoding val FStar.Attributes.uu___is_PpxDerivingShowConstant>

; <Skipped let uu___is_PpxDerivingShowConstant/>

; <Start encoding val FStar.Attributes.__proj__PpxDerivingShowConstant__item___0>
(declare-fun Tm_refine_bc20f546043cbc577e051a381f558945 () Term)
(declare-fun FStar.Attributes.__proj__PpxDerivingShowConstant__item___0 (Term) Term)

(declare-fun Tm_arrow_90334ab3c9f741c38d4dd8f37f8aea7f () Term)
(declare-fun FStar.Attributes.__proj__PpxDerivingShowConstant__item___0@tok () Term)
; </end encoding val FStar.Attributes.__proj__PpxDerivingShowConstant__item___0>

; <Skipped let __proj__PpxDerivingShowConstant__item___0/>

; <Start encoding val FStar.Attributes.uu___is_PpxDerivingYoJson>
(declare-fun FStar.Attributes.uu___is_PpxDerivingYoJson (Term) Term)

(declare-fun FStar.Attributes.uu___is_PpxDerivingYoJson@tok () Term)
; </end encoding val FStar.Attributes.uu___is_PpxDerivingYoJson>

; <Skipped let uu___is_PpxDerivingYoJson/>

; <Start encoding val FStar.Attributes.uu___is_CInline>
(declare-fun FStar.Attributes.uu___is_CInline (Term) Term)

(declare-fun FStar.Attributes.uu___is_CInline@tok () Term)
; </end encoding val FStar.Attributes.uu___is_CInline>

; <Skipped let uu___is_CInline/>

; <Start encoding val FStar.Attributes.uu___is_Substitute>
(declare-fun FStar.Attributes.uu___is_Substitute (Term) Term)

(declare-fun FStar.Attributes.uu___is_Substitute@tok () Term)
; </end encoding val FStar.Attributes.uu___is_Substitute>

; <Skipped let uu___is_Substitute/>

; <Start encoding val FStar.Attributes.uu___is_Gc>
(declare-fun FStar.Attributes.uu___is_Gc (Term) Term)

(declare-fun FStar.Attributes.uu___is_Gc@tok () Term)
; </end encoding val FStar.Attributes.uu___is_Gc>

; <Skipped let uu___is_Gc/>

; <Start encoding val FStar.Attributes.uu___is_Comment>
(declare-fun FStar.Attributes.uu___is_Comment (Term) Term)

(declare-fun FStar.Attributes.uu___is_Comment@tok () Term)
; </end encoding val FStar.Attributes.uu___is_Comment>

; <Skipped let uu___is_Comment/>

; <Start encoding val FStar.Attributes.__proj__Comment__item___0>
(declare-fun Tm_refine_65d8dd8d83843b4091d0eed7b95619fc () Term)
(declare-fun FStar.Attributes.__proj__Comment__item___0 (Term) Term)

(declare-fun Tm_arrow_1c85ef3e94af845bc9633317c687d94b () Term)
(declare-fun FStar.Attributes.__proj__Comment__item___0@tok () Term)
; </end encoding val FStar.Attributes.__proj__Comment__item___0>

; <Skipped let __proj__Comment__item___0/>

; <Start encoding val FStar.Attributes.uu___is_CPrologue>
(declare-fun FStar.Attributes.uu___is_CPrologue (Term) Term)

(declare-fun FStar.Attributes.uu___is_CPrologue@tok () Term)
; </end encoding val FStar.Attributes.uu___is_CPrologue>

; <Skipped let uu___is_CPrologue/>

; <Start encoding val FStar.Attributes.__proj__CPrologue__item___0>
(declare-fun Tm_refine_0175e351cf87242d4c1ffd69c118281d () Term)
(declare-fun FStar.Attributes.__proj__CPrologue__item___0 (Term) Term)

(declare-fun Tm_arrow_11884c7c6f4c81c3c2668702db5f5528 () Term)
(declare-fun FStar.Attributes.__proj__CPrologue__item___0@tok () Term)
; </end encoding val FStar.Attributes.__proj__CPrologue__item___0>

; <Skipped let __proj__CPrologue__item___0/>

; <Start encoding val FStar.Attributes.uu___is_CEpilogue>
(declare-fun FStar.Attributes.uu___is_CEpilogue (Term) Term)

(declare-fun FStar.Attributes.uu___is_CEpilogue@tok () Term)
; </end encoding val FStar.Attributes.uu___is_CEpilogue>

; <Skipped let uu___is_CEpilogue/>

; <Start encoding val FStar.Attributes.__proj__CEpilogue__item___0>
(declare-fun Tm_refine_2ef021290f2c4525f88b861d7725ce44 () Term)
(declare-fun FStar.Attributes.__proj__CEpilogue__item___0 (Term) Term)

(declare-fun Tm_arrow_262e88f0b9ff33dbbfa189b220e3fb6a () Term)
(declare-fun FStar.Attributes.__proj__CEpilogue__item___0@tok () Term)
; </end encoding val FStar.Attributes.__proj__CEpilogue__item___0>

; <Skipped let __proj__CEpilogue__item___0/>

; <Start encoding val FStar.Attributes.uu___is_CConst>
(declare-fun FStar.Attributes.uu___is_CConst (Term) Term)

(declare-fun FStar.Attributes.uu___is_CConst@tok () Term)
; </end encoding val FStar.Attributes.uu___is_CConst>

; <Skipped let uu___is_CConst/>

; <Start encoding val FStar.Attributes.__proj__CConst__item___0>
(declare-fun Tm_refine_170d8c8be9250274534e64f6d4fd41a0 () Term)
(declare-fun FStar.Attributes.__proj__CConst__item___0 (Term) Term)

(declare-fun Tm_arrow_e56ab9a22f1e0f5e4d9b27a10a6d6975 () Term)
(declare-fun FStar.Attributes.__proj__CConst__item___0@tok () Term)
; </end encoding val FStar.Attributes.__proj__CConst__item___0>

; <Skipped let __proj__CConst__item___0/>

; <Start encoding val FStar.Attributes.uu___is_CCConv>
(declare-fun FStar.Attributes.uu___is_CCConv (Term) Term)

(declare-fun FStar.Attributes.uu___is_CCConv@tok () Term)
; </end encoding val FStar.Attributes.uu___is_CCConv>

; <Skipped let uu___is_CCConv/>

; <Start encoding val FStar.Attributes.__proj__CCConv__item___0>
(declare-fun Tm_refine_446d9c4f0bd59e4fd55eae5447f4bd0d () Term)
(declare-fun FStar.Attributes.__proj__CCConv__item___0 (Term) Term)

(declare-fun Tm_arrow_fc29f768abe11db1d2b28f00b86486f8 () Term)
(declare-fun FStar.Attributes.__proj__CCConv__item___0@tok () Term)
; </end encoding val FStar.Attributes.__proj__CCConv__item___0>

; <Skipped let __proj__CCConv__item___0/>

; <Start encoding val FStar.Attributes.uu___is_CAbstractStruct>
(declare-fun FStar.Attributes.uu___is_CAbstractStruct (Term) Term)

(declare-fun FStar.Attributes.uu___is_CAbstractStruct@tok () Term)
; </end encoding val FStar.Attributes.uu___is_CAbstractStruct>

; <Skipped let uu___is_CAbstractStruct/>

; <Start encoding val FStar.Attributes.uu___is_CIfDef>
(declare-fun FStar.Attributes.uu___is_CIfDef (Term) Term)

(declare-fun FStar.Attributes.uu___is_CIfDef@tok () Term)
; </end encoding val FStar.Attributes.uu___is_CIfDef>

; <Skipped let uu___is_CIfDef/>

; <Start encoding val FStar.Attributes.uu___is_CMacro>
(declare-fun FStar.Attributes.uu___is_CMacro (Term) Term)

(declare-fun FStar.Attributes.uu___is_CMacro@tok () Term)
; </end encoding val FStar.Attributes.uu___is_CMacro>

; <Skipped let uu___is_CMacro/>

; <Start encoding val FStar.Attributes.uu___is_CNoInline>
(declare-fun FStar.Attributes.uu___is_CNoInline (Term) Term)

(declare-fun FStar.Attributes.uu___is_CNoInline@tok () Term)
; </end encoding val FStar.Attributes.uu___is_CNoInline>

; <Skipped let uu___is_CNoInline/>

; <Start encoding val FStar.Attributes.inline_let>
(declare-fun FStar.Attributes.inline_let (Dummy_sort) Term)
; </end encoding val FStar.Attributes.inline_let>

; <Start encoding val FStar.Attributes.inline_let_vc>
(declare-fun FStar.Attributes.inline_let_vc (Dummy_sort) Term)
; </end encoding val FStar.Attributes.inline_let_vc>

; <Start encoding val FStar.Attributes.no_inline_let>
(declare-fun FStar.Attributes.no_inline_let (Dummy_sort) Term)
; </end encoding val FStar.Attributes.no_inline_let>

; <Start encoding val FStar.Attributes.rename_let>
(declare-fun FStar.Attributes.rename_let (Term) Term)

(declare-fun FStar.Attributes.rename_let@tok () Term)
; </end encoding val FStar.Attributes.rename_let>

; <Start encoding val FStar.Attributes.plugin>
(declare-fun FStar.Attributes.plugin (Term) Term)
(declare-fun Tm_arrow_f12575a0ee171a8be16a63e3359708f8 () Term)
(declare-fun FStar.Attributes.plugin@tok () Term)
; </end encoding val FStar.Attributes.plugin>

; <Start encoding val FStar.Attributes.tcnorm>
(declare-fun FStar.Attributes.tcnorm (Dummy_sort) Term)
; </end encoding val FStar.Attributes.tcnorm>

; <Start encoding val FStar.Attributes.dm4f_bind_range>
(declare-fun FStar.Attributes.dm4f_bind_range (Dummy_sort) Term)
; </end encoding val FStar.Attributes.dm4f_bind_range>

; <Start encoding val FStar.Attributes.must_erase_for_extraction>
(declare-fun FStar.Attributes.must_erase_for_extraction (Dummy_sort) Term)
; </end encoding val FStar.Attributes.must_erase_for_extraction>

; <Start encoding val FStar.Attributes.expect_failure>
(declare-fun FStar.Attributes.expect_failure (Term) Term)
(declare-fun Tm_arrow_555d62757eeaf90340982fcdf25f6704 () Term)
(declare-fun FStar.Attributes.expect_failure@tok () Term)
; </end encoding val FStar.Attributes.expect_failure>

; <Start encoding val FStar.Attributes.expect_lax_failure>
(declare-fun FStar.Attributes.expect_lax_failure (Term) Term)

(declare-fun FStar.Attributes.expect_lax_failure@tok () Term)
; </end encoding val FStar.Attributes.expect_lax_failure>

; <Start encoding val FStar.Attributes.tcdecltime>
(declare-fun FStar.Attributes.tcdecltime (Dummy_sort) Term)
; </end encoding val FStar.Attributes.tcdecltime>

; <Start encoding val FStar.Attributes.unifier_hint_injective>
(declare-fun FStar.Attributes.unifier_hint_injective (Dummy_sort) Term)
; </end encoding val FStar.Attributes.unifier_hint_injective>

; <Start encoding val FStar.Attributes.strict_on_arguments>
(declare-fun FStar.Attributes.strict_on_arguments (Term) Term)

(declare-fun FStar.Attributes.strict_on_arguments@tok () Term)
; </end encoding val FStar.Attributes.strict_on_arguments>

; <Start encoding val FStar.Attributes.resolve_implicits>
(declare-fun FStar.Attributes.resolve_implicits (Dummy_sort) Term)
; </end encoding val FStar.Attributes.resolve_implicits>

; <Start encoding val FStar.Attributes.override_resolve_implicits_handler>
(declare-fun FStar.Attributes.override_resolve_implicits_handler (Term Term Term) Term)
(declare-fun Tm_arrow_93e6548cfc250f7cc25301579d62a018 () Term)
(declare-fun FStar.Attributes.override_resolve_implicits_handler@tok () Term)
; </end encoding val FStar.Attributes.override_resolve_implicits_handler>

; <Start encoding val FStar.Attributes.handle_smt_goals>
(declare-fun FStar.Attributes.handle_smt_goals (Dummy_sort) Term)
; </end encoding val FStar.Attributes.handle_smt_goals>

; <Start encoding val FStar.Attributes.erasable>
(declare-fun FStar.Attributes.erasable (Dummy_sort) Term)
; </end encoding val FStar.Attributes.erasable>

; <Start encoding val FStar.Attributes.commute_nested_matches>
(declare-fun FStar.Attributes.commute_nested_matches (Dummy_sort) Term)
; </end encoding val FStar.Attributes.commute_nested_matches>

; <Start encoding val FStar.Attributes.noextract_to>
(declare-fun FStar.Attributes.noextract_to (Term) Term)

(declare-fun FStar.Attributes.noextract_to@tok () Term)
; </end encoding val FStar.Attributes.noextract_to>

; <Start encoding val FStar.Attributes.ite_soundness_by>
(declare-fun FStar.Attributes.ite_soundness_by (Term) Term)
(declare-fun Tm_arrow_0c55530a575bf8e94add46ffb548393c () Term)
(declare-fun FStar.Attributes.ite_soundness_by@tok () Term)
; </end encoding val FStar.Attributes.ite_soundness_by>

; <Start encoding val FStar.Attributes.default_effect>
(declare-fun FStar.Attributes.default_effect (Term) Term)

(declare-fun FStar.Attributes.default_effect@tok () Term)
; </end encoding val FStar.Attributes.default_effect>

; <Start encoding val FStar.Attributes.top_level_effect>
(declare-fun FStar.Attributes.top_level_effect (Term) Term)

(declare-fun FStar.Attributes.top_level_effect@tok () Term)
; </end encoding val FStar.Attributes.top_level_effect>

; <Start encoding val FStar.Attributes.effect_param>
(declare-fun FStar.Attributes.effect_param (Dummy_sort) Term)
; </end encoding val FStar.Attributes.effect_param>

; <Start encoding val FStar.Attributes.bind_has_range_args>
(declare-fun FStar.Attributes.bind_has_range_args (Dummy_sort) Term)
; </end encoding val FStar.Attributes.bind_has_range_args>

; <Start encoding val FStar.Attributes.primitive_extraction>
(declare-fun FStar.Attributes.primitive_extraction (Dummy_sort) Term)
; </end encoding val FStar.Attributes.primitive_extraction>

; <Start encoding val FStar.Attributes.extract_as_impure_effect>
(declare-fun FStar.Attributes.extract_as_impure_effect (Dummy_sort) Term)
; </end encoding val FStar.Attributes.extract_as_impure_effect>

; <Start encoding val FStar.Attributes.strictly_positive>
(declare-fun FStar.Attributes.strictly_positive (Dummy_sort) Term)
; </end encoding val FStar.Attributes.strictly_positive>

; <Start encoding val FStar.Attributes.unused>
(declare-fun FStar.Attributes.unused (Dummy_sort) Term)
; </end encoding val FStar.Attributes.unused>

; <Start encoding val FStar.Attributes.no_auto_projectors>
(declare-fun FStar.Attributes.no_auto_projectors (Dummy_sort) Term)
; </end encoding val FStar.Attributes.no_auto_projectors>

; <Start encoding val FStar.Attributes.no_auto_projectors_decls>
(declare-fun FStar.Attributes.no_auto_projectors_decls (Dummy_sort) Term)
; </end encoding val FStar.Attributes.no_auto_projectors_decls>

; <Start encoding val FStar.Attributes.no_subtyping>
(declare-fun FStar.Attributes.no_subtyping (Dummy_sort) Term)
; </end encoding val FStar.Attributes.no_subtyping>

; <Start encoding val FStar.Attributes.admitted>
(declare-fun FStar.Attributes.admitted (Dummy_sort) Term)
; </end encoding val FStar.Attributes.admitted>

; <Start encoding val FStar.Attributes.admit_termination>
(declare-fun FStar.Attributes.admit_termination (Dummy_sort) Term)
; </end encoding val FStar.Attributes.admit_termination>

; <Start encoding val FStar.Attributes.coercion>
(declare-fun FStar.Attributes.coercion (Dummy_sort) Term)
; </end encoding val FStar.Attributes.coercion>

; <Start encoding val FStar.Attributes.desugar_of_variant_record>
(declare-fun FStar.Attributes.desugar_of_variant_record (Term) Term)

(declare-fun FStar.Attributes.desugar_of_variant_record@tok () Term)
; </end encoding val FStar.Attributes.desugar_of_variant_record>

; <Start encoding val FStar.Attributes.defer_to>
(declare-fun FStar.Attributes.defer_to (Term Term) Term)
(declare-fun Tm_arrow_962476a7eea46a6ffc9b658c6d8fbc71 () Term)
(declare-fun FStar.Attributes.defer_to@tok () Term)
; </end encoding val FStar.Attributes.defer_to>

; End Externals for interface FStar.Attributes
; Externals for interface FStar.NormSteps
; <Start encoding val FStar.NormSteps.norm_step>
(declare-fun FStar.NormSteps.norm_step () Term)
; </end encoding val FStar.NormSteps.norm_step>

; <Start encoding val FStar.NormSteps.simplify>
(declare-fun FStar.NormSteps.simplify (Dummy_sort) Term)
; </end encoding val FStar.NormSteps.simplify>

; <Start encoding val FStar.NormSteps.weak>
(declare-fun FStar.NormSteps.weak (Dummy_sort) Term)
; </end encoding val FStar.NormSteps.weak>

; <Start encoding val FStar.NormSteps.hnf>
(declare-fun FStar.NormSteps.hnf (Dummy_sort) Term)
; </end encoding val FStar.NormSteps.hnf>

; <Start encoding val FStar.NormSteps.primops>
(declare-fun FStar.NormSteps.primops (Dummy_sort) Term)
; </end encoding val FStar.NormSteps.primops>

; <Start encoding val FStar.NormSteps.delta>
(declare-fun FStar.NormSteps.delta (Dummy_sort) Term)
; </end encoding val FStar.NormSteps.delta>

; <Start encoding val FStar.NormSteps.norm_debug>
(declare-fun FStar.NormSteps.norm_debug (Dummy_sort) Term)
; </end encoding val FStar.NormSteps.norm_debug>

; <Start encoding val FStar.NormSteps.zeta>
(declare-fun FStar.NormSteps.zeta (Dummy_sort) Term)
; </end encoding val FStar.NormSteps.zeta>

; <Start encoding val FStar.NormSteps.zeta_full>
(declare-fun FStar.NormSteps.zeta_full (Dummy_sort) Term)
; </end encoding val FStar.NormSteps.zeta_full>

; <Start encoding val FStar.NormSteps.iota>
(declare-fun FStar.NormSteps.iota (Dummy_sort) Term)
; </end encoding val FStar.NormSteps.iota>

; <Start encoding val FStar.NormSteps.nbe>
(declare-fun FStar.NormSteps.nbe (Dummy_sort) Term)
; </end encoding val FStar.NormSteps.nbe>

; <Start encoding val FStar.NormSteps.reify_>
(declare-fun FStar.NormSteps.reify_ (Dummy_sort) Term)
; </end encoding val FStar.NormSteps.reify_>

; <Start encoding val FStar.NormSteps.delta_only>
(declare-fun FStar.NormSteps.delta_only (Term) Term)
(declare-fun Tm_arrow_29d7a35999b647dbf2c0b7f8839c0cb6 () Term)
(declare-fun FStar.NormSteps.delta_only@tok () Term)
; </end encoding val FStar.NormSteps.delta_only>

; <Start encoding val FStar.NormSteps.delta_once>
(declare-fun FStar.NormSteps.delta_once (Term) Term)

(declare-fun FStar.NormSteps.delta_once@tok () Term)
; </end encoding val FStar.NormSteps.delta_once>

; <Start encoding val FStar.NormSteps.delta_fully>
(declare-fun FStar.NormSteps.delta_fully (Term) Term)

(declare-fun FStar.NormSteps.delta_fully@tok () Term)
; </end encoding val FStar.NormSteps.delta_fully>

; <Start encoding val FStar.NormSteps.delta_attr>
(declare-fun FStar.NormSteps.delta_attr (Term) Term)

(declare-fun FStar.NormSteps.delta_attr@tok () Term)
; </end encoding val FStar.NormSteps.delta_attr>

; <Start encoding val FStar.NormSteps.delta_qualifier>
(declare-fun FStar.NormSteps.delta_qualifier (Term) Term)

(declare-fun FStar.NormSteps.delta_qualifier@tok () Term)
; </end encoding val FStar.NormSteps.delta_qualifier>

; <Start encoding val FStar.NormSteps.delta_namespace>
(declare-fun FStar.NormSteps.delta_namespace (Term) Term)

(declare-fun FStar.NormSteps.delta_namespace@tok () Term)
; </end encoding val FStar.NormSteps.delta_namespace>

; <Start encoding val FStar.NormSteps.unmeta>
(declare-fun FStar.NormSteps.unmeta (Dummy_sort) Term)
; </end encoding val FStar.NormSteps.unmeta>

; <Start encoding val FStar.NormSteps.unascribe>
(declare-fun FStar.NormSteps.unascribe (Dummy_sort) Term)
; </end encoding val FStar.NormSteps.unascribe>

; End Externals for interface FStar.NormSteps
; Externals for module FStar.Pervasives.Native
; <Start encoding type FStar.Pervasives.Native.option>
; Constructor
(declare-fun FStar.Pervasives.Native.option (Term) Term)
; token
(declare-fun FStar.Pervasives.Native.option@tok () Term)
; Constructor
(declare-fun FStar.Pervasives.Native.None (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.None_a (Term) Term)
; data constructor proxy: FStar.Pervasives.Native.None
(declare-fun FStar.Pervasives.Native.None@tok () Term)
; Constructor
(declare-fun FStar.Pervasives.Native.Some (Term Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Some_a (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Some_v (Term) Term)
; data constructor proxy: FStar.Pervasives.Native.Some
(declare-fun FStar.Pervasives.Native.Some@tok () Term)
(declare-fun Tm_arrow_48b914114ec9f2f1caadf0f6848a9741 () Term)
(declare-fun Tm_arrow_b93a364b5144c2a5f3e9d1ea7b881752 () Term)
; <start constructor FStar.Pervasives.Native.option>
; Discriminator definition
(define-fun is-FStar.Pervasives.Native.option ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 101)
  (exists ((@x0 Term))
   (! (= __@x0 (FStar.Pervasives.Native.option @x0)) :qid is-FStar.Pervasives.Native.option))))
; </end constructor FStar.Pervasives.Native.option>
; <start constructor FStar.Pervasives.Native.None>
; Discriminator definition
(define-fun is-FStar.Pervasives.Native.None ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 108)
  (= __@x0 (FStar.Pervasives.Native.None (FStar.Pervasives.Native.None_a __@x0)))))
; </end constructor FStar.Pervasives.Native.None>
; <start constructor FStar.Pervasives.Native.Some>
; Discriminator definition
(define-fun is-FStar.Pervasives.Native.Some ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 113)
  (=
   __@x0
   (FStar.Pervasives.Native.Some
    (FStar.Pervasives.Native.Some_a __@x0)
    (FStar.Pervasives.Native.Some_v __@x0)))))
; </end constructor FStar.Pervasives.Native.Some>
; </end encoding type FStar.Pervasives.Native.option>

; <Start encoding assume FStar.Pervasives.Native.option__uu___haseq>
; </end encoding assume FStar.Pervasives.Native.option__uu___haseq>

; <Start encoding val FStar.Pervasives.Native.uu___is_None>
(declare-fun FStar.Pervasives.Native.uu___is_None (Term Term) Term)
(declare-fun Tm_arrow_f1a97bcd6ba9b40d22609b756f183afa () Term)
(declare-fun FStar.Pervasives.Native.uu___is_None@tok () Term)
; </end encoding val FStar.Pervasives.Native.uu___is_None>

; <Skipped let uu___is_None/>

; <Start encoding val FStar.Pervasives.Native.uu___is_Some>
(declare-fun FStar.Pervasives.Native.uu___is_Some (Term Term) Term)

(declare-fun FStar.Pervasives.Native.uu___is_Some@tok () Term)
; </end encoding val FStar.Pervasives.Native.uu___is_Some>

; <Skipped let uu___is_Some/>

; <Start encoding val FStar.Pervasives.Native.__proj__Some__item__v>
(declare-fun Tm_refine_4d5241eb6fe198666a8101195bbd4a2a (Term) Term)
(declare-fun FStar.Pervasives.Native.__proj__Some__item__v (Term Term) Term)

(declare-fun Tm_arrow_1b1398c011ff53e4194fc2ec00c7b411 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Some__item__v@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Some__item__v>

; <Skipped let __proj__Some__item__v/>

; <Start encoding type FStar.Pervasives.Native.tuple2>
; Constructor
(declare-fun FStar.Pervasives.Native.tuple2 (Term Term) Term)
; token
(declare-fun FStar.Pervasives.Native.tuple2@tok () Term)
; Constructor
(declare-fun FStar.Pervasives.Native.Mktuple2 (Term Term Term Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple2__a (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple2__b (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple2__1 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple2__2 (Term) Term)
; data constructor proxy: FStar.Pervasives.Native.Mktuple2
(declare-fun FStar.Pervasives.Native.Mktuple2@tok () Term)
(declare-fun Tm_arrow_4054cc0a51327db54c2ed9ba3376a093 () Term)
; <start constructor FStar.Pervasives.Native.tuple2>
; Discriminator definition
(define-fun is-FStar.Pervasives.Native.tuple2 ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 125)
  (exists ((@x0 Term) (@x1 Term))
   (! (= __@x0 (FStar.Pervasives.Native.tuple2 @x0 @x1)) :qid is-FStar.Pervasives.Native.tuple2))))
; </end constructor FStar.Pervasives.Native.tuple2>
; <start constructor FStar.Pervasives.Native.Mktuple2>
; Discriminator definition
(define-fun is-FStar.Pervasives.Native.Mktuple2 ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 132)
  (=
   __@x0
   (FStar.Pervasives.Native.Mktuple2
    (FStar.Pervasives.Native.Mktuple2__a __@x0)
    (FStar.Pervasives.Native.Mktuple2__b __@x0)
    (FStar.Pervasives.Native.Mktuple2__1 __@x0)
    (FStar.Pervasives.Native.Mktuple2__2 __@x0)))))
; </end constructor FStar.Pervasives.Native.Mktuple2>
; </end encoding type FStar.Pervasives.Native.tuple2>

; <Start encoding assume FStar.Pervasives.Native.tuple2__uu___haseq>
; </end encoding assume FStar.Pervasives.Native.tuple2__uu___haseq>

; <Start encoding val FStar.Pervasives.Native.uu___is_Mktuple2>
(declare-fun FStar.Pervasives.Native.uu___is_Mktuple2 (Term Term Term) Term)
(declare-fun Tm_arrow_eff71eeee4474e017e02350f86f54756 () Term)
(declare-fun FStar.Pervasives.Native.uu___is_Mktuple2@tok () Term)
; </end encoding val FStar.Pervasives.Native.uu___is_Mktuple2>

; <Skipped let uu___is_Mktuple2/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple2__item___1>
(declare-fun FStar.Pervasives.Native.__proj__Mktuple2__item___1 (Term Term Term) Term)
(declare-fun Tm_arrow_b8cce376a4a678a51298a0f3945f25ce () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple2__item___1@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple2__item___1>

; <Skipped let __proj__Mktuple2__item___1/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple2__item___2>
(declare-fun FStar.Pervasives.Native.__proj__Mktuple2__item___2 (Term Term Term) Term)
(declare-fun Tm_arrow_d952d001575ecb20c572af535c88dd2d () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple2__item___2@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple2__item___2>

; <Skipped let __proj__Mktuple2__item___2/>

; <Start encoding let fst>
(declare-fun FStar.Pervasives.Native.fst (Term Term Term) Term)

(declare-fun FStar.Pervasives.Native.fst@tok () Term)
; </end encoding let fst>

; <Start encoding let snd>
(declare-fun FStar.Pervasives.Native.snd (Term Term Term) Term)

(declare-fun FStar.Pervasives.Native.snd@tok () Term)
; </end encoding let snd>

; <Start encoding type FStar.Pervasives.Native.tuple3>
; Constructor
(declare-fun FStar.Pervasives.Native.tuple3 (Term Term Term) Term)
; token
(declare-fun FStar.Pervasives.Native.tuple3@tok () Term)
; Constructor
(declare-fun FStar.Pervasives.Native.Mktuple3 (Term Term Term Term Term Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple3__a (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple3__b (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple3__c (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple3__1 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple3__2 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple3__3 (Term) Term)
; data constructor proxy: FStar.Pervasives.Native.Mktuple3
(declare-fun FStar.Pervasives.Native.Mktuple3@tok () Term)
(declare-fun Tm_arrow_1bedda193f13e939931cf5d46ad84216 () Term)
; <start constructor FStar.Pervasives.Native.tuple3>
; Discriminator definition
(define-fun is-FStar.Pervasives.Native.tuple3 ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 146)
  (exists ((@x0 Term) (@x1 Term) (@x2 Term))
   (! (= __@x0 (FStar.Pervasives.Native.tuple3 @x0 @x1 @x2)) :qid is-FStar.Pervasives.Native.tuple3))))
; </end constructor FStar.Pervasives.Native.tuple3>
; <start constructor FStar.Pervasives.Native.Mktuple3>
; Discriminator definition
(define-fun is-FStar.Pervasives.Native.Mktuple3 ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 153)
  (=
   __@x0
   (FStar.Pervasives.Native.Mktuple3
    (FStar.Pervasives.Native.Mktuple3__a __@x0)
    (FStar.Pervasives.Native.Mktuple3__b __@x0)
    (FStar.Pervasives.Native.Mktuple3__c __@x0)
    (FStar.Pervasives.Native.Mktuple3__1 __@x0)
    (FStar.Pervasives.Native.Mktuple3__2 __@x0)
    (FStar.Pervasives.Native.Mktuple3__3 __@x0)))))
; </end constructor FStar.Pervasives.Native.Mktuple3>
; </end encoding type FStar.Pervasives.Native.tuple3>

; <Start encoding assume FStar.Pervasives.Native.tuple3__uu___haseq>
; </end encoding assume FStar.Pervasives.Native.tuple3__uu___haseq>

; <Start encoding val FStar.Pervasives.Native.uu___is_Mktuple3>
(declare-fun FStar.Pervasives.Native.uu___is_Mktuple3 (Term Term Term Term) Term)
(declare-fun Tm_arrow_f03c6dc5b30146aaca49ed4bf6f332a7 () Term)
(declare-fun FStar.Pervasives.Native.uu___is_Mktuple3@tok () Term)
; </end encoding val FStar.Pervasives.Native.uu___is_Mktuple3>

; <Skipped let uu___is_Mktuple3/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple3__item___1>
(declare-fun FStar.Pervasives.Native.__proj__Mktuple3__item___1 (Term Term Term Term) Term)
(declare-fun Tm_arrow_592c45439d32a71e1933eacb9776c9ed () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple3__item___1@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple3__item___1>

; <Skipped let __proj__Mktuple3__item___1/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple3__item___2>
(declare-fun FStar.Pervasives.Native.__proj__Mktuple3__item___2 (Term Term Term Term) Term)
(declare-fun Tm_arrow_9c9b0c5ac9b0fbfc367f406af296ecab () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple3__item___2@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple3__item___2>

; <Skipped let __proj__Mktuple3__item___2/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple3__item___3>
(declare-fun FStar.Pervasives.Native.__proj__Mktuple3__item___3 (Term Term Term Term) Term)
(declare-fun Tm_arrow_08246a62c9aeca08c44c602ad80e95a4 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple3__item___3@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple3__item___3>

; <Skipped let __proj__Mktuple3__item___3/>

; <Start encoding type FStar.Pervasives.Native.tuple4>
; Constructor
(declare-fun FStar.Pervasives.Native.tuple4 (Term Term Term Term) Term)
; token
(declare-fun FStar.Pervasives.Native.tuple4@tok () Term)
; Constructor
(declare-fun FStar.Pervasives.Native.Mktuple4 (Term Term Term Term Term Term Term Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple4__a (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple4__b (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple4__c (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple4__d (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple4__1 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple4__2 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple4__3 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple4__4 (Term) Term)
; data constructor proxy: FStar.Pervasives.Native.Mktuple4
(declare-fun FStar.Pervasives.Native.Mktuple4@tok () Term)
(declare-fun Tm_arrow_cbe72a10167439fe1ecfaf4fec8fd23f () Term)
; <start constructor FStar.Pervasives.Native.tuple4>
; Discriminator definition
(define-fun is-FStar.Pervasives.Native.tuple4 ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 165)
  (exists ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
   (! (= __@x0 (FStar.Pervasives.Native.tuple4 @x0 @x1 @x2 @x3))
    :qid is-FStar.Pervasives.Native.tuple4))))
; </end constructor FStar.Pervasives.Native.tuple4>
; <start constructor FStar.Pervasives.Native.Mktuple4>
; Discriminator definition
(define-fun is-FStar.Pervasives.Native.Mktuple4 ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 172)
  (=
   __@x0
   (FStar.Pervasives.Native.Mktuple4
    (FStar.Pervasives.Native.Mktuple4__a __@x0)
    (FStar.Pervasives.Native.Mktuple4__b __@x0)
    (FStar.Pervasives.Native.Mktuple4__c __@x0)
    (FStar.Pervasives.Native.Mktuple4__d __@x0)
    (FStar.Pervasives.Native.Mktuple4__1 __@x0)
    (FStar.Pervasives.Native.Mktuple4__2 __@x0)
    (FStar.Pervasives.Native.Mktuple4__3 __@x0)
    (FStar.Pervasives.Native.Mktuple4__4 __@x0)))))
; </end constructor FStar.Pervasives.Native.Mktuple4>
; </end encoding type FStar.Pervasives.Native.tuple4>

; <Start encoding assume FStar.Pervasives.Native.tuple4__uu___haseq>
; </end encoding assume FStar.Pervasives.Native.tuple4__uu___haseq>

; <Start encoding val FStar.Pervasives.Native.uu___is_Mktuple4>
(declare-fun FStar.Pervasives.Native.uu___is_Mktuple4 (Term Term Term Term Term) Term)
(declare-fun Tm_arrow_4319694c225efa92ce9fad6e9d81f761 () Term)
(declare-fun FStar.Pervasives.Native.uu___is_Mktuple4@tok () Term)
; </end encoding val FStar.Pervasives.Native.uu___is_Mktuple4>

; <Skipped let uu___is_Mktuple4/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple4__item___1>
(declare-fun FStar.Pervasives.Native.__proj__Mktuple4__item___1 (Term Term Term Term Term) Term)
(declare-fun Tm_arrow_382d1e9129053162252ec57e86d46f82 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple4__item___1@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple4__item___1>

; <Skipped let __proj__Mktuple4__item___1/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple4__item___2>
(declare-fun FStar.Pervasives.Native.__proj__Mktuple4__item___2 (Term Term Term Term Term) Term)
(declare-fun Tm_arrow_fffd25e5325d259efa0675ef649c6864 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple4__item___2@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple4__item___2>

; <Skipped let __proj__Mktuple4__item___2/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple4__item___3>
(declare-fun FStar.Pervasives.Native.__proj__Mktuple4__item___3 (Term Term Term Term Term) Term)
(declare-fun Tm_arrow_57b4005e0833f7b396e349ed7cdd1bb2 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple4__item___3@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple4__item___3>

; <Skipped let __proj__Mktuple4__item___3/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple4__item___4>
(declare-fun FStar.Pervasives.Native.__proj__Mktuple4__item___4 (Term Term Term Term Term) Term)
(declare-fun Tm_arrow_9e6c1a63d63f8735645b9898955a2dca () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple4__item___4@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple4__item___4>

; <Skipped let __proj__Mktuple4__item___4/>

; <Start encoding type FStar.Pervasives.Native.tuple5>
; Constructor
(declare-fun FStar.Pervasives.Native.tuple5 (Term Term Term Term Term) Term)
; token
(declare-fun FStar.Pervasives.Native.tuple5@tok () Term)
; Constructor
(declare-fun
 FStar.Pervasives.Native.Mktuple5
 (Term Term Term Term Term Term Term Term Term Term)
 Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple5__a (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple5__b (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple5__c (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple5__d (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple5__e (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple5__1 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple5__2 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple5__3 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple5__4 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple5__5 (Term) Term)
; data constructor proxy: FStar.Pervasives.Native.Mktuple5
(declare-fun FStar.Pervasives.Native.Mktuple5@tok () Term)
(declare-fun Tm_arrow_dd8a078a1b97a81b5089dc3637cc2887 () Term)
; <start constructor FStar.Pervasives.Native.tuple5>
; Discriminator definition
(define-fun is-FStar.Pervasives.Native.tuple5 ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 186)
  (exists ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
   (! (= __@x0 (FStar.Pervasives.Native.tuple5 @x0 @x1 @x2 @x3 @x4))
    :qid is-FStar.Pervasives.Native.tuple5))))
; </end constructor FStar.Pervasives.Native.tuple5>
; <start constructor FStar.Pervasives.Native.Mktuple5>
; Discriminator definition
(define-fun is-FStar.Pervasives.Native.Mktuple5 ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 193)
  (=
   __@x0
   (FStar.Pervasives.Native.Mktuple5
    (FStar.Pervasives.Native.Mktuple5__a __@x0)
    (FStar.Pervasives.Native.Mktuple5__b __@x0)
    (FStar.Pervasives.Native.Mktuple5__c __@x0)
    (FStar.Pervasives.Native.Mktuple5__d __@x0)
    (FStar.Pervasives.Native.Mktuple5__e __@x0)
    (FStar.Pervasives.Native.Mktuple5__1 __@x0)
    (FStar.Pervasives.Native.Mktuple5__2 __@x0)
    (FStar.Pervasives.Native.Mktuple5__3 __@x0)
    (FStar.Pervasives.Native.Mktuple5__4 __@x0)
    (FStar.Pervasives.Native.Mktuple5__5 __@x0)))))
; </end constructor FStar.Pervasives.Native.Mktuple5>
; </end encoding type FStar.Pervasives.Native.tuple5>

; <Start encoding assume FStar.Pervasives.Native.tuple5__uu___haseq>
; </end encoding assume FStar.Pervasives.Native.tuple5__uu___haseq>

; <Start encoding val FStar.Pervasives.Native.uu___is_Mktuple5>
(declare-fun FStar.Pervasives.Native.uu___is_Mktuple5 (Term Term Term Term Term Term) Term)
(declare-fun Tm_arrow_cfa2e2c8b8b41312889ff659c4faa5f9 () Term)
(declare-fun FStar.Pervasives.Native.uu___is_Mktuple5@tok () Term)
; </end encoding val FStar.Pervasives.Native.uu___is_Mktuple5>

; <Skipped let uu___is_Mktuple5/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple5__item___1>
(declare-fun FStar.Pervasives.Native.__proj__Mktuple5__item___1 (Term Term Term Term Term Term) Term)
(declare-fun Tm_arrow_7519f72fe101267af170e00c6ce694af () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple5__item___1@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple5__item___1>

; <Skipped let __proj__Mktuple5__item___1/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple5__item___2>
(declare-fun FStar.Pervasives.Native.__proj__Mktuple5__item___2 (Term Term Term Term Term Term) Term)
(declare-fun Tm_arrow_3e46329f224aa70981a337f98afbaa87 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple5__item___2@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple5__item___2>

; <Skipped let __proj__Mktuple5__item___2/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple5__item___3>
(declare-fun FStar.Pervasives.Native.__proj__Mktuple5__item___3 (Term Term Term Term Term Term) Term)
(declare-fun Tm_arrow_55e6dc1b736536de45fedf844003f847 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple5__item___3@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple5__item___3>

; <Skipped let __proj__Mktuple5__item___3/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple5__item___4>
(declare-fun FStar.Pervasives.Native.__proj__Mktuple5__item___4 (Term Term Term Term Term Term) Term)
(declare-fun Tm_arrow_3a4e86c6aee1a39b4811bdbc12405398 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple5__item___4@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple5__item___4>

; <Skipped let __proj__Mktuple5__item___4/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple5__item___5>
(declare-fun FStar.Pervasives.Native.__proj__Mktuple5__item___5 (Term Term Term Term Term Term) Term)
(declare-fun Tm_arrow_1a78355922fdaba3f3848932dfc0a089 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple5__item___5@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple5__item___5>

; <Skipped let __proj__Mktuple5__item___5/>

; <Start encoding type FStar.Pervasives.Native.tuple6>
; Constructor
(declare-fun FStar.Pervasives.Native.tuple6 (Term Term Term Term Term Term) Term)
; token
(declare-fun FStar.Pervasives.Native.tuple6@tok () Term)
; Constructor
(declare-fun
 FStar.Pervasives.Native.Mktuple6
 (Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple6__a (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple6__b (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple6__c (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple6__d (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple6__e (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple6__f (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple6__1 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple6__2 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple6__3 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple6__4 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple6__5 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple6__6 (Term) Term)
; data constructor proxy: FStar.Pervasives.Native.Mktuple6
(declare-fun FStar.Pervasives.Native.Mktuple6@tok () Term)
(declare-fun Tm_arrow_f277ffaa7e891207f9c6bff5b88ffd67 () Term)
; <start constructor FStar.Pervasives.Native.tuple6>
; Discriminator definition
(define-fun is-FStar.Pervasives.Native.tuple6 ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 209)
  (exists ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
   (! (= __@x0 (FStar.Pervasives.Native.tuple6 @x0 @x1 @x2 @x3 @x4 @x5))
    :qid is-FStar.Pervasives.Native.tuple6))))
; </end constructor FStar.Pervasives.Native.tuple6>
; <start constructor FStar.Pervasives.Native.Mktuple6>
; Discriminator definition
(define-fun is-FStar.Pervasives.Native.Mktuple6 ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 216)
  (=
   __@x0
   (FStar.Pervasives.Native.Mktuple6
    (FStar.Pervasives.Native.Mktuple6__a __@x0)
    (FStar.Pervasives.Native.Mktuple6__b __@x0)
    (FStar.Pervasives.Native.Mktuple6__c __@x0)
    (FStar.Pervasives.Native.Mktuple6__d __@x0)
    (FStar.Pervasives.Native.Mktuple6__e __@x0)
    (FStar.Pervasives.Native.Mktuple6__f __@x0)
    (FStar.Pervasives.Native.Mktuple6__1 __@x0)
    (FStar.Pervasives.Native.Mktuple6__2 __@x0)
    (FStar.Pervasives.Native.Mktuple6__3 __@x0)
    (FStar.Pervasives.Native.Mktuple6__4 __@x0)
    (FStar.Pervasives.Native.Mktuple6__5 __@x0)
    (FStar.Pervasives.Native.Mktuple6__6 __@x0)))))
; </end constructor FStar.Pervasives.Native.Mktuple6>
; </end encoding type FStar.Pervasives.Native.tuple6>

; <Start encoding assume FStar.Pervasives.Native.tuple6__uu___haseq>
; </end encoding assume FStar.Pervasives.Native.tuple6__uu___haseq>

; <Start encoding val FStar.Pervasives.Native.uu___is_Mktuple6>
(declare-fun FStar.Pervasives.Native.uu___is_Mktuple6 (Term Term Term Term Term Term Term) Term)
(declare-fun Tm_arrow_286587a1b9d299ba75a076f54a6dad5f () Term)
(declare-fun FStar.Pervasives.Native.uu___is_Mktuple6@tok () Term)
; </end encoding val FStar.Pervasives.Native.uu___is_Mktuple6>

; <Skipped let uu___is_Mktuple6/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple6__item___1>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple6__item___1
 (Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_5b1e145eeceab869b8e427e6927dbd63 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple6__item___1@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple6__item___1>

; <Skipped let __proj__Mktuple6__item___1/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple6__item___2>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple6__item___2
 (Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_3207475e225d584881d3e0a297482887 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple6__item___2@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple6__item___2>

; <Skipped let __proj__Mktuple6__item___2/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple6__item___3>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple6__item___3
 (Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_43e491b3b537a523a4f10de18b1915f5 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple6__item___3@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple6__item___3>

; <Skipped let __proj__Mktuple6__item___3/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple6__item___4>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple6__item___4
 (Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_f5747d5b721642d7ecb757b043f20880 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple6__item___4@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple6__item___4>

; <Skipped let __proj__Mktuple6__item___4/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple6__item___5>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple6__item___5
 (Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_d6501381a0206e157ecc43950bb31fea () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple6__item___5@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple6__item___5>

; <Skipped let __proj__Mktuple6__item___5/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple6__item___6>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple6__item___6
 (Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_9c342f41120d0c7aea115b09b58cefb2 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple6__item___6@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple6__item___6>

; <Skipped let __proj__Mktuple6__item___6/>

; <Start encoding type FStar.Pervasives.Native.tuple7>
; Constructor
(declare-fun FStar.Pervasives.Native.tuple7 (Term Term Term Term Term Term Term) Term)
; token
(declare-fun FStar.Pervasives.Native.tuple7@tok () Term)
; Constructor
(declare-fun
 FStar.Pervasives.Native.Mktuple7
 (Term Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple7__a (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple7__b (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple7__c (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple7__d (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple7__e (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple7__f (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple7__g (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple7__1 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple7__2 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple7__3 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple7__4 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple7__5 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple7__6 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple7__7 (Term) Term)
; data constructor proxy: FStar.Pervasives.Native.Mktuple7
(declare-fun FStar.Pervasives.Native.Mktuple7@tok () Term)
(declare-fun Tm_arrow_37ee9ec407a0f7bb69bf1b308f74a230 () Term)
; <start constructor FStar.Pervasives.Native.tuple7>
; Discriminator definition
(define-fun is-FStar.Pervasives.Native.tuple7 ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 234)
  (exists ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
   (! (= __@x0 (FStar.Pervasives.Native.tuple7 @x0 @x1 @x2 @x3 @x4 @x5 @x6))
    :qid is-FStar.Pervasives.Native.tuple7))))
; </end constructor FStar.Pervasives.Native.tuple7>
; <start constructor FStar.Pervasives.Native.Mktuple7>
; Discriminator definition
(define-fun is-FStar.Pervasives.Native.Mktuple7 ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 241)
  (=
   __@x0
   (FStar.Pervasives.Native.Mktuple7
    (FStar.Pervasives.Native.Mktuple7__a __@x0)
    (FStar.Pervasives.Native.Mktuple7__b __@x0)
    (FStar.Pervasives.Native.Mktuple7__c __@x0)
    (FStar.Pervasives.Native.Mktuple7__d __@x0)
    (FStar.Pervasives.Native.Mktuple7__e __@x0)
    (FStar.Pervasives.Native.Mktuple7__f __@x0)
    (FStar.Pervasives.Native.Mktuple7__g __@x0)
    (FStar.Pervasives.Native.Mktuple7__1 __@x0)
    (FStar.Pervasives.Native.Mktuple7__2 __@x0)
    (FStar.Pervasives.Native.Mktuple7__3 __@x0)
    (FStar.Pervasives.Native.Mktuple7__4 __@x0)
    (FStar.Pervasives.Native.Mktuple7__5 __@x0)
    (FStar.Pervasives.Native.Mktuple7__6 __@x0)
    (FStar.Pervasives.Native.Mktuple7__7 __@x0)))))
; </end constructor FStar.Pervasives.Native.Mktuple7>
; </end encoding type FStar.Pervasives.Native.tuple7>

; <Start encoding assume FStar.Pervasives.Native.tuple7__uu___haseq>
; </end encoding assume FStar.Pervasives.Native.tuple7__uu___haseq>

; <Start encoding val FStar.Pervasives.Native.uu___is_Mktuple7>
(declare-fun FStar.Pervasives.Native.uu___is_Mktuple7 (Term Term Term Term Term Term Term Term) Term)
(declare-fun Tm_arrow_612dde2fedb1440c5d790ba7f5015319 () Term)
(declare-fun FStar.Pervasives.Native.uu___is_Mktuple7@tok () Term)
; </end encoding val FStar.Pervasives.Native.uu___is_Mktuple7>

; <Skipped let uu___is_Mktuple7/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple7__item___1>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple7__item___1
 (Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_01c4488a68699f466c59799f5c1173ff () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple7__item___1@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple7__item___1>

; <Skipped let __proj__Mktuple7__item___1/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple7__item___2>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple7__item___2
 (Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_f317591858699585c67fe4ba8664e34c () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple7__item___2@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple7__item___2>

; <Skipped let __proj__Mktuple7__item___2/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple7__item___3>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple7__item___3
 (Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_44afce9d86f095aacc82b3ea2e0e223c () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple7__item___3@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple7__item___3>

; <Skipped let __proj__Mktuple7__item___3/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple7__item___4>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple7__item___4
 (Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_e857539d4cc5be0510cbcfb97cb64b35 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple7__item___4@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple7__item___4>

; <Skipped let __proj__Mktuple7__item___4/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple7__item___5>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple7__item___5
 (Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_a249d3d5ba06026b12d41e289bb88061 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple7__item___5@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple7__item___5>

; <Skipped let __proj__Mktuple7__item___5/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple7__item___6>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple7__item___6
 (Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_bf614c740d11cac9b5f8eb20b24c7d00 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple7__item___6@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple7__item___6>

; <Skipped let __proj__Mktuple7__item___6/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple7__item___7>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple7__item___7
 (Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_e775fbf03b08091e48143165286522f7 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple7__item___7@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple7__item___7>

; <Skipped let __proj__Mktuple7__item___7/>

; <Start encoding type FStar.Pervasives.Native.tuple8>
; Constructor
(declare-fun FStar.Pervasives.Native.tuple8 (Term Term Term Term Term Term Term Term) Term)
; token
(declare-fun FStar.Pervasives.Native.tuple8@tok () Term)
; Constructor
(declare-fun
 FStar.Pervasives.Native.Mktuple8
 (Term Term Term Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple8__a (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple8__b (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple8__c (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple8__d (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple8__e (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple8__f (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple8__g (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple8__h (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple8__1 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple8__2 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple8__3 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple8__4 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple8__5 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple8__6 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple8__7 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple8__8 (Term) Term)
; data constructor proxy: FStar.Pervasives.Native.Mktuple8
(declare-fun FStar.Pervasives.Native.Mktuple8@tok () Term)
(declare-fun Tm_arrow_e922a339a0aa0f375ed7113049811583 () Term)
; <start constructor FStar.Pervasives.Native.tuple8>
; Discriminator definition
(define-fun is-FStar.Pervasives.Native.tuple8 ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 261)
  (exists ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
   (! (= __@x0 (FStar.Pervasives.Native.tuple8 @x0 @x1 @x2 @x3 @x4 @x5 @x6 @x7))
    :qid is-FStar.Pervasives.Native.tuple8))))
; </end constructor FStar.Pervasives.Native.tuple8>
; <start constructor FStar.Pervasives.Native.Mktuple8>
; Discriminator definition
(define-fun is-FStar.Pervasives.Native.Mktuple8 ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 268)
  (=
   __@x0
   (FStar.Pervasives.Native.Mktuple8
    (FStar.Pervasives.Native.Mktuple8__a __@x0)
    (FStar.Pervasives.Native.Mktuple8__b __@x0)
    (FStar.Pervasives.Native.Mktuple8__c __@x0)
    (FStar.Pervasives.Native.Mktuple8__d __@x0)
    (FStar.Pervasives.Native.Mktuple8__e __@x0)
    (FStar.Pervasives.Native.Mktuple8__f __@x0)
    (FStar.Pervasives.Native.Mktuple8__g __@x0)
    (FStar.Pervasives.Native.Mktuple8__h __@x0)
    (FStar.Pervasives.Native.Mktuple8__1 __@x0)
    (FStar.Pervasives.Native.Mktuple8__2 __@x0)
    (FStar.Pervasives.Native.Mktuple8__3 __@x0)
    (FStar.Pervasives.Native.Mktuple8__4 __@x0)
    (FStar.Pervasives.Native.Mktuple8__5 __@x0)
    (FStar.Pervasives.Native.Mktuple8__6 __@x0)
    (FStar.Pervasives.Native.Mktuple8__7 __@x0)
    (FStar.Pervasives.Native.Mktuple8__8 __@x0)))))
; </end constructor FStar.Pervasives.Native.Mktuple8>
; </end encoding type FStar.Pervasives.Native.tuple8>

; <Start encoding assume FStar.Pervasives.Native.tuple8__uu___haseq>
; </end encoding assume FStar.Pervasives.Native.tuple8__uu___haseq>

; <Start encoding val FStar.Pervasives.Native.uu___is_Mktuple8>
(declare-fun
 FStar.Pervasives.Native.uu___is_Mktuple8
 (Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_ee31533e24c78558f4566668a6ec027c () Term)
(declare-fun FStar.Pervasives.Native.uu___is_Mktuple8@tok () Term)
; </end encoding val FStar.Pervasives.Native.uu___is_Mktuple8>

; <Skipped let uu___is_Mktuple8/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple8__item___1>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple8__item___1
 (Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_c971649e117e4941e7317eff508d5ea7 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple8__item___1@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple8__item___1>

; <Skipped let __proj__Mktuple8__item___1/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple8__item___2>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple8__item___2
 (Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_97dd51e3888c1c543d8f6c73d1808548 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple8__item___2@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple8__item___2>

; <Skipped let __proj__Mktuple8__item___2/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple8__item___3>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple8__item___3
 (Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_3931d1873633dc65fed4e022ee3df3ca () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple8__item___3@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple8__item___3>

; <Skipped let __proj__Mktuple8__item___3/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple8__item___4>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple8__item___4
 (Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_5c791e62f9472e4c351c2befb2b7a3d8 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple8__item___4@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple8__item___4>

; <Skipped let __proj__Mktuple8__item___4/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple8__item___5>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple8__item___5
 (Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_7ef7cac898ca0ef25893959e91d8c6ce () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple8__item___5@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple8__item___5>

; <Skipped let __proj__Mktuple8__item___5/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple8__item___6>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple8__item___6
 (Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_b0ae5f58a7fa002e0313b58bf5fc74cb () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple8__item___6@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple8__item___6>

; <Skipped let __proj__Mktuple8__item___6/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple8__item___7>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple8__item___7
 (Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_7fcd94f7549ca8acfadc26bc5b82f590 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple8__item___7@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple8__item___7>

; <Skipped let __proj__Mktuple8__item___7/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple8__item___8>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple8__item___8
 (Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_feaaf61fa62fef18c5ee7c39e9f86573 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple8__item___8@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple8__item___8>

; <Skipped let __proj__Mktuple8__item___8/>

; <Start encoding type FStar.Pervasives.Native.tuple9>
; Constructor
(declare-fun FStar.Pervasives.Native.tuple9 (Term Term Term Term Term Term Term Term Term) Term)
; token
(declare-fun FStar.Pervasives.Native.tuple9@tok () Term)
; Constructor
(declare-fun
 FStar.Pervasives.Native.Mktuple9
 (Term Term Term Term Term Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple9__a (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple9__b (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple9__c (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple9__d (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple9__e (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple9__f (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple9__g (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple9__h (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple9__i (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple9__1 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple9__2 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple9__3 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple9__4 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple9__5 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple9__6 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple9__7 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple9__8 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple9__9 (Term) Term)
; data constructor proxy: FStar.Pervasives.Native.Mktuple9
(declare-fun FStar.Pervasives.Native.Mktuple9@tok () Term)
(declare-fun Tm_arrow_0c6bc368a301d7de6e1939ebea91ee60 () Term)
; <start constructor FStar.Pervasives.Native.tuple9>
; Discriminator definition
(define-fun is-FStar.Pervasives.Native.tuple9 ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 290)
  (exists
    ((@x0 Term)
     (@x1 Term)
     (@x2 Term)
     (@x3 Term)
     (@x4 Term)
     (@x5 Term)
     (@x6 Term)
     (@x7 Term)
     (@x8 Term))
   (! (= __@x0 (FStar.Pervasives.Native.tuple9 @x0 @x1 @x2 @x3 @x4 @x5 @x6 @x7 @x8))
    :qid is-FStar.Pervasives.Native.tuple9))))
; </end constructor FStar.Pervasives.Native.tuple9>
; <start constructor FStar.Pervasives.Native.Mktuple9>
; Discriminator definition
(define-fun is-FStar.Pervasives.Native.Mktuple9 ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 297)
  (=
   __@x0
   (FStar.Pervasives.Native.Mktuple9
    (FStar.Pervasives.Native.Mktuple9__a __@x0)
    (FStar.Pervasives.Native.Mktuple9__b __@x0)
    (FStar.Pervasives.Native.Mktuple9__c __@x0)
    (FStar.Pervasives.Native.Mktuple9__d __@x0)
    (FStar.Pervasives.Native.Mktuple9__e __@x0)
    (FStar.Pervasives.Native.Mktuple9__f __@x0)
    (FStar.Pervasives.Native.Mktuple9__g __@x0)
    (FStar.Pervasives.Native.Mktuple9__h __@x0)
    (FStar.Pervasives.Native.Mktuple9__i __@x0)
    (FStar.Pervasives.Native.Mktuple9__1 __@x0)
    (FStar.Pervasives.Native.Mktuple9__2 __@x0)
    (FStar.Pervasives.Native.Mktuple9__3 __@x0)
    (FStar.Pervasives.Native.Mktuple9__4 __@x0)
    (FStar.Pervasives.Native.Mktuple9__5 __@x0)
    (FStar.Pervasives.Native.Mktuple9__6 __@x0)
    (FStar.Pervasives.Native.Mktuple9__7 __@x0)
    (FStar.Pervasives.Native.Mktuple9__8 __@x0)
    (FStar.Pervasives.Native.Mktuple9__9 __@x0)))))
; </end constructor FStar.Pervasives.Native.Mktuple9>
; </end encoding type FStar.Pervasives.Native.tuple9>

; <Start encoding assume FStar.Pervasives.Native.tuple9__uu___haseq>
; </end encoding assume FStar.Pervasives.Native.tuple9__uu___haseq>

; <Start encoding val FStar.Pervasives.Native.uu___is_Mktuple9>
(declare-fun
 FStar.Pervasives.Native.uu___is_Mktuple9
 (Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_9ac8f39c7b1df1e87db7c9bf5bc37a38 () Term)
(declare-fun FStar.Pervasives.Native.uu___is_Mktuple9@tok () Term)
; </end encoding val FStar.Pervasives.Native.uu___is_Mktuple9>

; <Skipped let uu___is_Mktuple9/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple9__item___1>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple9__item___1
 (Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_270119cc1f13c9afeb25322d78efc328 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple9__item___1@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple9__item___1>

; <Skipped let __proj__Mktuple9__item___1/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple9__item___2>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple9__item___2
 (Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_3c368dee2c86a1af7bd7ea91baab7613 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple9__item___2@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple9__item___2>

; <Skipped let __proj__Mktuple9__item___2/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple9__item___3>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple9__item___3
 (Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_e9c745e2da3dec50930b0a7e01a11cc3 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple9__item___3@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple9__item___3>

; <Skipped let __proj__Mktuple9__item___3/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple9__item___4>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple9__item___4
 (Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_a82ff41c5c66cd37481c83584c94a54d () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple9__item___4@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple9__item___4>

; <Skipped let __proj__Mktuple9__item___4/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple9__item___5>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple9__item___5
 (Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_1b3b4c5e68fdf7277f64bde93e6534de () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple9__item___5@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple9__item___5>

; <Skipped let __proj__Mktuple9__item___5/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple9__item___6>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple9__item___6
 (Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_837f1324f6fa51bb8a0e45ee48e4e058 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple9__item___6@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple9__item___6>

; <Skipped let __proj__Mktuple9__item___6/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple9__item___7>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple9__item___7
 (Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_a7562220963e3431d35de76c3c9c87b9 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple9__item___7@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple9__item___7>

; <Skipped let __proj__Mktuple9__item___7/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple9__item___8>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple9__item___8
 (Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_861b810bc1c20bbd221cecbce824b695 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple9__item___8@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple9__item___8>

; <Skipped let __proj__Mktuple9__item___8/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple9__item___9>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple9__item___9
 (Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_9a54b18d8e08fdf0e20244b3f960c9dc () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple9__item___9@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple9__item___9>

; <Skipped let __proj__Mktuple9__item___9/>

; <Start encoding type FStar.Pervasives.Native.tuple10>
; Constructor
(declare-fun
 FStar.Pervasives.Native.tuple10
 (Term Term Term Term Term Term Term Term Term Term)
 Term)
; token
(declare-fun FStar.Pervasives.Native.tuple10@tok () Term)
; Constructor
(declare-fun
 FStar.Pervasives.Native.Mktuple10
 (Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term)
 Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple10__a (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple10__b (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple10__c (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple10__d (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple10__e (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple10__f (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple10__g (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple10__h (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple10__i (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple10__j (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple10__1 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple10__2 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple10__3 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple10__4 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple10__5 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple10__6 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple10__7 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple10__8 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple10__9 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple10__10 (Term) Term)
; data constructor proxy: FStar.Pervasives.Native.Mktuple10
(declare-fun FStar.Pervasives.Native.Mktuple10@tok () Term)
(declare-fun Tm_arrow_61d31241317018093b2245d256adbcb5 () Term)
; <start constructor FStar.Pervasives.Native.tuple10>
; Discriminator definition
(define-fun is-FStar.Pervasives.Native.tuple10 ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 321)
  (exists
    ((@x0 Term)
     (@x1 Term)
     (@x2 Term)
     (@x3 Term)
     (@x4 Term)
     (@x5 Term)
     (@x6 Term)
     (@x7 Term)
     (@x8 Term)
     (@x9 Term))
   (! (= __@x0 (FStar.Pervasives.Native.tuple10 @x0 @x1 @x2 @x3 @x4 @x5 @x6 @x7 @x8 @x9))
    :qid is-FStar.Pervasives.Native.tuple10))))
; </end constructor FStar.Pervasives.Native.tuple10>
; <start constructor FStar.Pervasives.Native.Mktuple10>
; Discriminator definition
(define-fun is-FStar.Pervasives.Native.Mktuple10 ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 328)
  (=
   __@x0
   (FStar.Pervasives.Native.Mktuple10
    (FStar.Pervasives.Native.Mktuple10__a __@x0)
    (FStar.Pervasives.Native.Mktuple10__b __@x0)
    (FStar.Pervasives.Native.Mktuple10__c __@x0)
    (FStar.Pervasives.Native.Mktuple10__d __@x0)
    (FStar.Pervasives.Native.Mktuple10__e __@x0)
    (FStar.Pervasives.Native.Mktuple10__f __@x0)
    (FStar.Pervasives.Native.Mktuple10__g __@x0)
    (FStar.Pervasives.Native.Mktuple10__h __@x0)
    (FStar.Pervasives.Native.Mktuple10__i __@x0)
    (FStar.Pervasives.Native.Mktuple10__j __@x0)
    (FStar.Pervasives.Native.Mktuple10__1 __@x0)
    (FStar.Pervasives.Native.Mktuple10__2 __@x0)
    (FStar.Pervasives.Native.Mktuple10__3 __@x0)
    (FStar.Pervasives.Native.Mktuple10__4 __@x0)
    (FStar.Pervasives.Native.Mktuple10__5 __@x0)
    (FStar.Pervasives.Native.Mktuple10__6 __@x0)
    (FStar.Pervasives.Native.Mktuple10__7 __@x0)
    (FStar.Pervasives.Native.Mktuple10__8 __@x0)
    (FStar.Pervasives.Native.Mktuple10__9 __@x0)
    (FStar.Pervasives.Native.Mktuple10__10 __@x0)))))
; </end constructor FStar.Pervasives.Native.Mktuple10>
; </end encoding type FStar.Pervasives.Native.tuple10>

; <Start encoding assume FStar.Pervasives.Native.tuple10__uu___haseq>
; </end encoding assume FStar.Pervasives.Native.tuple10__uu___haseq>

; <Start encoding val FStar.Pervasives.Native.uu___is_Mktuple10>
(declare-fun
 FStar.Pervasives.Native.uu___is_Mktuple10
 (Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_f27282a056f525d8710bf32204d252ec () Term)
(declare-fun FStar.Pervasives.Native.uu___is_Mktuple10@tok () Term)
; </end encoding val FStar.Pervasives.Native.uu___is_Mktuple10>

; <Skipped let uu___is_Mktuple10/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple10__item___1>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple10__item___1
 (Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_c581e9177cd071a1b6e057fca49ea75b () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple10__item___1@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple10__item___1>

; <Skipped let __proj__Mktuple10__item___1/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple10__item___2>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple10__item___2
 (Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_ae4b2db87d7c69a8380f4d5ae20f2149 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple10__item___2@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple10__item___2>

; <Skipped let __proj__Mktuple10__item___2/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple10__item___3>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple10__item___3
 (Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_a21274cb112dc6619b2bde244e6a0f9a () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple10__item___3@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple10__item___3>

; <Skipped let __proj__Mktuple10__item___3/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple10__item___4>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple10__item___4
 (Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_9a051d5cacf4367d170d590ba8bb720d () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple10__item___4@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple10__item___4>

; <Skipped let __proj__Mktuple10__item___4/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple10__item___5>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple10__item___5
 (Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_bbd73769b626202d4de52d4d60cd3b75 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple10__item___5@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple10__item___5>

; <Skipped let __proj__Mktuple10__item___5/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple10__item___6>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple10__item___6
 (Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_7ceeded5a3852448c1a5406becbd990e () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple10__item___6@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple10__item___6>

; <Skipped let __proj__Mktuple10__item___6/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple10__item___7>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple10__item___7
 (Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_c68947c71d484ad43cd50646c4e1daf4 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple10__item___7@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple10__item___7>

; <Skipped let __proj__Mktuple10__item___7/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple10__item___8>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple10__item___8
 (Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_e7b9ff90289491020fe84c6ab3bc60c6 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple10__item___8@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple10__item___8>

; <Skipped let __proj__Mktuple10__item___8/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple10__item___9>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple10__item___9
 (Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_6dbb3170f112f78092d1caee0b341678 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple10__item___9@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple10__item___9>

; <Skipped let __proj__Mktuple10__item___9/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple10__item___10>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple10__item___10
 (Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_45598a99c0a7fcc1bf2258b9ad4256cf () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple10__item___10@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple10__item___10>

; <Skipped let __proj__Mktuple10__item___10/>

; <Start encoding type FStar.Pervasives.Native.tuple11>
; Constructor
(declare-fun
 FStar.Pervasives.Native.tuple11
 (Term Term Term Term Term Term Term Term Term Term Term)
 Term)
; token
(declare-fun FStar.Pervasives.Native.tuple11@tok () Term)
; Constructor
(declare-fun
 FStar.Pervasives.Native.Mktuple11
 (Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term)
 Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple11__a (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple11__b (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple11__c (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple11__d (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple11__e (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple11__f (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple11__g (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple11__h (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple11__i (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple11__j (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple11__k (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple11__1 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple11__2 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple11__3 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple11__4 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple11__5 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple11__6 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple11__7 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple11__8 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple11__9 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple11__10 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple11__11 (Term) Term)
; data constructor proxy: FStar.Pervasives.Native.Mktuple11
(declare-fun FStar.Pervasives.Native.Mktuple11@tok () Term)
(declare-fun Tm_arrow_bf9783a1a3bf19ab918f42acff1daa32 () Term)
; <start constructor FStar.Pervasives.Native.tuple11>
; Discriminator definition
(define-fun is-FStar.Pervasives.Native.tuple11 ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 354)
  (exists
    ((@x0 Term)
     (@x1 Term)
     (@x2 Term)
     (@x3 Term)
     (@x4 Term)
     (@x5 Term)
     (@x6 Term)
     (@x7 Term)
     (@x8 Term)
     (@x9 Term)
     (@x10 Term))
   (! (= __@x0 (FStar.Pervasives.Native.tuple11 @x0 @x1 @x2 @x3 @x4 @x5 @x6 @x7 @x8 @x9 @x10))
    :qid is-FStar.Pervasives.Native.tuple11))))
; </end constructor FStar.Pervasives.Native.tuple11>
; <start constructor FStar.Pervasives.Native.Mktuple11>
; Discriminator definition
(define-fun is-FStar.Pervasives.Native.Mktuple11 ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 361)
  (=
   __@x0
   (FStar.Pervasives.Native.Mktuple11
    (FStar.Pervasives.Native.Mktuple11__a __@x0)
    (FStar.Pervasives.Native.Mktuple11__b __@x0)
    (FStar.Pervasives.Native.Mktuple11__c __@x0)
    (FStar.Pervasives.Native.Mktuple11__d __@x0)
    (FStar.Pervasives.Native.Mktuple11__e __@x0)
    (FStar.Pervasives.Native.Mktuple11__f __@x0)
    (FStar.Pervasives.Native.Mktuple11__g __@x0)
    (FStar.Pervasives.Native.Mktuple11__h __@x0)
    (FStar.Pervasives.Native.Mktuple11__i __@x0)
    (FStar.Pervasives.Native.Mktuple11__j __@x0)
    (FStar.Pervasives.Native.Mktuple11__k __@x0)
    (FStar.Pervasives.Native.Mktuple11__1 __@x0)
    (FStar.Pervasives.Native.Mktuple11__2 __@x0)
    (FStar.Pervasives.Native.Mktuple11__3 __@x0)
    (FStar.Pervasives.Native.Mktuple11__4 __@x0)
    (FStar.Pervasives.Native.Mktuple11__5 __@x0)
    (FStar.Pervasives.Native.Mktuple11__6 __@x0)
    (FStar.Pervasives.Native.Mktuple11__7 __@x0)
    (FStar.Pervasives.Native.Mktuple11__8 __@x0)
    (FStar.Pervasives.Native.Mktuple11__9 __@x0)
    (FStar.Pervasives.Native.Mktuple11__10 __@x0)
    (FStar.Pervasives.Native.Mktuple11__11 __@x0)))))
; </end constructor FStar.Pervasives.Native.Mktuple11>
; </end encoding type FStar.Pervasives.Native.tuple11>

; <Start encoding assume FStar.Pervasives.Native.tuple11__uu___haseq>
; </end encoding assume FStar.Pervasives.Native.tuple11__uu___haseq>

; <Start encoding val FStar.Pervasives.Native.uu___is_Mktuple11>
(declare-fun
 FStar.Pervasives.Native.uu___is_Mktuple11
 (Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_005819ee7a23a5c47189bae72b85d85c () Term)
(declare-fun FStar.Pervasives.Native.uu___is_Mktuple11@tok () Term)
; </end encoding val FStar.Pervasives.Native.uu___is_Mktuple11>

; <Skipped let uu___is_Mktuple11/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple11__item___1>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple11__item___1
 (Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_31968e334e9582d95281307f534992a9 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple11__item___1@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple11__item___1>

; <Skipped let __proj__Mktuple11__item___1/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple11__item___2>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple11__item___2
 (Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_6252dd9f4473dc54a3482810e8556404 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple11__item___2@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple11__item___2>

; <Skipped let __proj__Mktuple11__item___2/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple11__item___3>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple11__item___3
 (Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_ec3ce6b7406c091cd7d0961922bb5a02 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple11__item___3@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple11__item___3>

; <Skipped let __proj__Mktuple11__item___3/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple11__item___4>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple11__item___4
 (Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_be7571e73b0e7fc24d03efe0e003c054 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple11__item___4@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple11__item___4>

; <Skipped let __proj__Mktuple11__item___4/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple11__item___5>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple11__item___5
 (Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_97ae7d913e508c46c48c3b51553d4459 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple11__item___5@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple11__item___5>

; <Skipped let __proj__Mktuple11__item___5/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple11__item___6>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple11__item___6
 (Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_1dca311798936510e0ead61e14cf32a6 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple11__item___6@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple11__item___6>

; <Skipped let __proj__Mktuple11__item___6/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple11__item___7>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple11__item___7
 (Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_eec431ea31093a646681ef2ceb2e2986 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple11__item___7@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple11__item___7>

; <Skipped let __proj__Mktuple11__item___7/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple11__item___8>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple11__item___8
 (Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_689b2f06e9fd83f7a84ce80a13d338c6 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple11__item___8@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple11__item___8>

; <Skipped let __proj__Mktuple11__item___8/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple11__item___9>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple11__item___9
 (Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_20210a3d9498f929cb7aa68d9e8b5ebf () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple11__item___9@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple11__item___9>

; <Skipped let __proj__Mktuple11__item___9/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple11__item___10>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple11__item___10
 (Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_96812f2124d88760b2002bbe1502c3c9 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple11__item___10@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple11__item___10>

; <Skipped let __proj__Mktuple11__item___10/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple11__item___11>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple11__item___11
 (Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_abcfa2582f68905d460c5ef4a7642f2d () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple11__item___11@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple11__item___11>

; <Skipped let __proj__Mktuple11__item___11/>

; <Start encoding type FStar.Pervasives.Native.tuple12>
; Constructor
(declare-fun
 FStar.Pervasives.Native.tuple12
 (Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
; token
(declare-fun FStar.Pervasives.Native.tuple12@tok () Term)
; Constructor
(declare-fun
 FStar.Pervasives.Native.Mktuple12
 (Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term)
 Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple12__a (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple12__b (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple12__c (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple12__d (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple12__e (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple12__f (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple12__g (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple12__h (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple12__i (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple12__j (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple12__k (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple12__l (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple12__1 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple12__2 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple12__3 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple12__4 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple12__5 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple12__6 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple12__7 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple12__8 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple12__9 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple12__10 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple12__11 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple12__12 (Term) Term)
; data constructor proxy: FStar.Pervasives.Native.Mktuple12
(declare-fun FStar.Pervasives.Native.Mktuple12@tok () Term)
(declare-fun Tm_arrow_4d5cd995d6f44a2ec39d0f193be0be65 () Term)
; <start constructor FStar.Pervasives.Native.tuple12>
; Discriminator definition
(define-fun is-FStar.Pervasives.Native.tuple12 ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 389)
  (exists
    ((@x0 Term)
     (@x1 Term)
     (@x2 Term)
     (@x3 Term)
     (@x4 Term)
     (@x5 Term)
     (@x6 Term)
     (@x7 Term)
     (@x8 Term)
     (@x9 Term)
     (@x10 Term)
     (@x11 Term))
   (! (= __@x0 (FStar.Pervasives.Native.tuple12 @x0 @x1 @x2 @x3 @x4 @x5 @x6 @x7 @x8 @x9 @x10 @x11))
    :qid is-FStar.Pervasives.Native.tuple12))))
; </end constructor FStar.Pervasives.Native.tuple12>
; <start constructor FStar.Pervasives.Native.Mktuple12>
; Discriminator definition
(define-fun is-FStar.Pervasives.Native.Mktuple12 ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 396)
  (=
   __@x0
   (FStar.Pervasives.Native.Mktuple12
    (FStar.Pervasives.Native.Mktuple12__a __@x0)
    (FStar.Pervasives.Native.Mktuple12__b __@x0)
    (FStar.Pervasives.Native.Mktuple12__c __@x0)
    (FStar.Pervasives.Native.Mktuple12__d __@x0)
    (FStar.Pervasives.Native.Mktuple12__e __@x0)
    (FStar.Pervasives.Native.Mktuple12__f __@x0)
    (FStar.Pervasives.Native.Mktuple12__g __@x0)
    (FStar.Pervasives.Native.Mktuple12__h __@x0)
    (FStar.Pervasives.Native.Mktuple12__i __@x0)
    (FStar.Pervasives.Native.Mktuple12__j __@x0)
    (FStar.Pervasives.Native.Mktuple12__k __@x0)
    (FStar.Pervasives.Native.Mktuple12__l __@x0)
    (FStar.Pervasives.Native.Mktuple12__1 __@x0)
    (FStar.Pervasives.Native.Mktuple12__2 __@x0)
    (FStar.Pervasives.Native.Mktuple12__3 __@x0)
    (FStar.Pervasives.Native.Mktuple12__4 __@x0)
    (FStar.Pervasives.Native.Mktuple12__5 __@x0)
    (FStar.Pervasives.Native.Mktuple12__6 __@x0)
    (FStar.Pervasives.Native.Mktuple12__7 __@x0)
    (FStar.Pervasives.Native.Mktuple12__8 __@x0)
    (FStar.Pervasives.Native.Mktuple12__9 __@x0)
    (FStar.Pervasives.Native.Mktuple12__10 __@x0)
    (FStar.Pervasives.Native.Mktuple12__11 __@x0)
    (FStar.Pervasives.Native.Mktuple12__12 __@x0)))))
; </end constructor FStar.Pervasives.Native.Mktuple12>
; </end encoding type FStar.Pervasives.Native.tuple12>

; <Start encoding assume FStar.Pervasives.Native.tuple12__uu___haseq>
; </end encoding assume FStar.Pervasives.Native.tuple12__uu___haseq>

; <Start encoding val FStar.Pervasives.Native.uu___is_Mktuple12>
(declare-fun
 FStar.Pervasives.Native.uu___is_Mktuple12
 (Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_5c9f47d9090f554c9826d2f65e388f20 () Term)
(declare-fun FStar.Pervasives.Native.uu___is_Mktuple12@tok () Term)
; </end encoding val FStar.Pervasives.Native.uu___is_Mktuple12>

; <Skipped let uu___is_Mktuple12/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple12__item___1>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple12__item___1
 (Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_618941d7cf5ddbaabe15df8579b4a387 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple12__item___1@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple12__item___1>

; <Skipped let __proj__Mktuple12__item___1/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple12__item___2>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple12__item___2
 (Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_84e9e2280e9bcb3233e4f33f86d66ea6 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple12__item___2@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple12__item___2>

; <Skipped let __proj__Mktuple12__item___2/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple12__item___3>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple12__item___3
 (Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_1fa79c5abf9f18607bd2e46a1a6967fa () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple12__item___3@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple12__item___3>

; <Skipped let __proj__Mktuple12__item___3/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple12__item___4>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple12__item___4
 (Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_0f49c582489d782b08195e81221181dc () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple12__item___4@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple12__item___4>

; <Skipped let __proj__Mktuple12__item___4/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple12__item___5>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple12__item___5
 (Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_29b7181ebb44f9e4a45f95c4f8478c6a () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple12__item___5@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple12__item___5>

; <Skipped let __proj__Mktuple12__item___5/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple12__item___6>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple12__item___6
 (Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_3cc2863a7d7f23e3916fa1e43483cb90 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple12__item___6@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple12__item___6>

; <Skipped let __proj__Mktuple12__item___6/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple12__item___7>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple12__item___7
 (Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_c7deea49701ab64a73985bf522e46359 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple12__item___7@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple12__item___7>

; <Skipped let __proj__Mktuple12__item___7/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple12__item___8>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple12__item___8
 (Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_380615e7761919086537a14273a02d22 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple12__item___8@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple12__item___8>

; <Skipped let __proj__Mktuple12__item___8/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple12__item___9>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple12__item___9
 (Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_245250918a4432b31aea8152d056489a () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple12__item___9@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple12__item___9>

; <Skipped let __proj__Mktuple12__item___9/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple12__item___10>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple12__item___10
 (Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_2a967c8402c441e6d8a9336a7568e4de () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple12__item___10@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple12__item___10>

; <Skipped let __proj__Mktuple12__item___10/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple12__item___11>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple12__item___11
 (Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_543c3feac0cd9e04ecb6cfd74ced8964 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple12__item___11@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple12__item___11>

; <Skipped let __proj__Mktuple12__item___11/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple12__item___12>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple12__item___12
 (Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_e91029e2320896c60e94f554727a0c41 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple12__item___12@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple12__item___12>

; <Skipped let __proj__Mktuple12__item___12/>

; <Start encoding type FStar.Pervasives.Native.tuple13>
; Constructor
(declare-fun
 FStar.Pervasives.Native.tuple13
 (Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
; token
(declare-fun FStar.Pervasives.Native.tuple13@tok () Term)
; Constructor
(declare-fun
 FStar.Pervasives.Native.Mktuple13
 (Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term)
 Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple13__a (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple13__b (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple13__c (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple13__d (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple13__e (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple13__f (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple13__g (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple13__h (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple13__i (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple13__j (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple13__k (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple13__l (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple13__m (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple13__1 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple13__2 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple13__3 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple13__4 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple13__5 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple13__6 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple13__7 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple13__8 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple13__9 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple13__10 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple13__11 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple13__12 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple13__13 (Term) Term)
; data constructor proxy: FStar.Pervasives.Native.Mktuple13
(declare-fun FStar.Pervasives.Native.Mktuple13@tok () Term)
(declare-fun Tm_arrow_6462785e86ca440ee74ed32e1053eae3 () Term)
; <start constructor FStar.Pervasives.Native.tuple13>
; Discriminator definition
(define-fun is-FStar.Pervasives.Native.tuple13 ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 426)
  (exists
    ((@x0 Term)
     (@x1 Term)
     (@x2 Term)
     (@x3 Term)
     (@x4 Term)
     (@x5 Term)
     (@x6 Term)
     (@x7 Term)
     (@x8 Term)
     (@x9 Term)
     (@x10 Term)
     (@x11 Term)
     (@x12 Term))
   (! (=
     __@x0
     (FStar.Pervasives.Native.tuple13 @x0 @x1 @x2 @x3 @x4 @x5 @x6 @x7 @x8 @x9 @x10 @x11 @x12))
    :qid is-FStar.Pervasives.Native.tuple13))))
; </end constructor FStar.Pervasives.Native.tuple13>
; <start constructor FStar.Pervasives.Native.Mktuple13>
; Discriminator definition
(define-fun is-FStar.Pervasives.Native.Mktuple13 ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 433)
  (=
   __@x0
   (FStar.Pervasives.Native.Mktuple13
    (FStar.Pervasives.Native.Mktuple13__a __@x0)
    (FStar.Pervasives.Native.Mktuple13__b __@x0)
    (FStar.Pervasives.Native.Mktuple13__c __@x0)
    (FStar.Pervasives.Native.Mktuple13__d __@x0)
    (FStar.Pervasives.Native.Mktuple13__e __@x0)
    (FStar.Pervasives.Native.Mktuple13__f __@x0)
    (FStar.Pervasives.Native.Mktuple13__g __@x0)
    (FStar.Pervasives.Native.Mktuple13__h __@x0)
    (FStar.Pervasives.Native.Mktuple13__i __@x0)
    (FStar.Pervasives.Native.Mktuple13__j __@x0)
    (FStar.Pervasives.Native.Mktuple13__k __@x0)
    (FStar.Pervasives.Native.Mktuple13__l __@x0)
    (FStar.Pervasives.Native.Mktuple13__m __@x0)
    (FStar.Pervasives.Native.Mktuple13__1 __@x0)
    (FStar.Pervasives.Native.Mktuple13__2 __@x0)
    (FStar.Pervasives.Native.Mktuple13__3 __@x0)
    (FStar.Pervasives.Native.Mktuple13__4 __@x0)
    (FStar.Pervasives.Native.Mktuple13__5 __@x0)
    (FStar.Pervasives.Native.Mktuple13__6 __@x0)
    (FStar.Pervasives.Native.Mktuple13__7 __@x0)
    (FStar.Pervasives.Native.Mktuple13__8 __@x0)
    (FStar.Pervasives.Native.Mktuple13__9 __@x0)
    (FStar.Pervasives.Native.Mktuple13__10 __@x0)
    (FStar.Pervasives.Native.Mktuple13__11 __@x0)
    (FStar.Pervasives.Native.Mktuple13__12 __@x0)
    (FStar.Pervasives.Native.Mktuple13__13 __@x0)))))
; </end constructor FStar.Pervasives.Native.Mktuple13>
; </end encoding type FStar.Pervasives.Native.tuple13>

; <Start encoding assume FStar.Pervasives.Native.tuple13__uu___haseq>
; </end encoding assume FStar.Pervasives.Native.tuple13__uu___haseq>

; <Start encoding val FStar.Pervasives.Native.uu___is_Mktuple13>
(declare-fun
 FStar.Pervasives.Native.uu___is_Mktuple13
 (Term Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_68c092e8b387730b412c4dcf592b12d3 () Term)
(declare-fun FStar.Pervasives.Native.uu___is_Mktuple13@tok () Term)
; </end encoding val FStar.Pervasives.Native.uu___is_Mktuple13>

; <Skipped let uu___is_Mktuple13/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple13__item___1>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple13__item___1
 (Term Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_82a3dc3a5dbad615d8d4a31db238e43f () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple13__item___1@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple13__item___1>

; <Skipped let __proj__Mktuple13__item___1/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple13__item___2>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple13__item___2
 (Term Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_1da976aaa65f1c6b8b256dfc45c41306 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple13__item___2@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple13__item___2>

; <Skipped let __proj__Mktuple13__item___2/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple13__item___3>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple13__item___3
 (Term Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_ca5cf529c415deee29e0a34c0c5d1c9f () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple13__item___3@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple13__item___3>

; <Skipped let __proj__Mktuple13__item___3/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple13__item___4>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple13__item___4
 (Term Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_94f6c578541b6cb528ca9e7dd1dacc3b () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple13__item___4@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple13__item___4>

; <Skipped let __proj__Mktuple13__item___4/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple13__item___5>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple13__item___5
 (Term Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_211e172b7220adc186d8a02ff17e8780 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple13__item___5@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple13__item___5>

; <Skipped let __proj__Mktuple13__item___5/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple13__item___6>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple13__item___6
 (Term Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_9276a4f669d8497205e8d59f12da53ba () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple13__item___6@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple13__item___6>

; <Skipped let __proj__Mktuple13__item___6/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple13__item___7>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple13__item___7
 (Term Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_8aa8f381a5ed57cbbae9dcd2405ce80f () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple13__item___7@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple13__item___7>

; <Skipped let __proj__Mktuple13__item___7/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple13__item___8>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple13__item___8
 (Term Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_51814106613688cf259d7cdba9c24d93 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple13__item___8@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple13__item___8>

; <Skipped let __proj__Mktuple13__item___8/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple13__item___9>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple13__item___9
 (Term Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_05fec25e6f03f974bb2933a910642d7e () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple13__item___9@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple13__item___9>

; <Skipped let __proj__Mktuple13__item___9/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple13__item___10>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple13__item___10
 (Term Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_3280ee04611a7985c9d107bb1a8a330a () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple13__item___10@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple13__item___10>

; <Skipped let __proj__Mktuple13__item___10/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple13__item___11>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple13__item___11
 (Term Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_86c868d5d5058e8e5ec1f4d0285c7e90 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple13__item___11@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple13__item___11>

; <Skipped let __proj__Mktuple13__item___11/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple13__item___12>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple13__item___12
 (Term Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_7263c1a3c4475bb4e4b41a1be4bf22da () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple13__item___12@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple13__item___12>

; <Skipped let __proj__Mktuple13__item___12/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple13__item___13>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple13__item___13
 (Term Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_338c65ae58844787891c6f47cf01c068 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple13__item___13@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple13__item___13>

; <Skipped let __proj__Mktuple13__item___13/>

; <Start encoding type FStar.Pervasives.Native.tuple14>
; Constructor
(declare-fun
 FStar.Pervasives.Native.tuple14
 (Term Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
; token
(declare-fun FStar.Pervasives.Native.tuple14@tok () Term)
; Constructor
(declare-fun
 FStar.Pervasives.Native.Mktuple14
 (Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term
  Term)
 Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple14__a (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple14__b (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple14__c (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple14__d (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple14__e (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple14__f (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple14__g (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple14__h (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple14__i (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple14__j (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple14__k (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple14__l (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple14__m (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple14__n (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple14__1 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple14__2 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple14__3 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple14__4 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple14__5 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple14__6 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple14__7 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple14__8 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple14__9 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple14__10 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple14__11 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple14__12 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple14__13 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Native.Mktuple14__14 (Term) Term)
; data constructor proxy: FStar.Pervasives.Native.Mktuple14
(declare-fun FStar.Pervasives.Native.Mktuple14@tok () Term)
(declare-fun Tm_arrow_484e3bf88a886900f7e695d7333615e9 () Term)
; <start constructor FStar.Pervasives.Native.tuple14>
; Discriminator definition
(define-fun is-FStar.Pervasives.Native.tuple14 ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 465)
  (exists
    ((@x0 Term)
     (@x1 Term)
     (@x2 Term)
     (@x3 Term)
     (@x4 Term)
     (@x5 Term)
     (@x6 Term)
     (@x7 Term)
     (@x8 Term)
     (@x9 Term)
     (@x10 Term)
     (@x11 Term)
     (@x12 Term)
     (@x13 Term))
   (! (=
     __@x0
     (FStar.Pervasives.Native.tuple14 @x0 @x1 @x2 @x3 @x4 @x5 @x6 @x7 @x8 @x9 @x10 @x11 @x12 @x13))
    :qid is-FStar.Pervasives.Native.tuple14))))
; </end constructor FStar.Pervasives.Native.tuple14>
; <start constructor FStar.Pervasives.Native.Mktuple14>
; Discriminator definition
(define-fun is-FStar.Pervasives.Native.Mktuple14 ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 472)
  (=
   __@x0
   (FStar.Pervasives.Native.Mktuple14
    (FStar.Pervasives.Native.Mktuple14__a __@x0)
    (FStar.Pervasives.Native.Mktuple14__b __@x0)
    (FStar.Pervasives.Native.Mktuple14__c __@x0)
    (FStar.Pervasives.Native.Mktuple14__d __@x0)
    (FStar.Pervasives.Native.Mktuple14__e __@x0)
    (FStar.Pervasives.Native.Mktuple14__f __@x0)
    (FStar.Pervasives.Native.Mktuple14__g __@x0)
    (FStar.Pervasives.Native.Mktuple14__h __@x0)
    (FStar.Pervasives.Native.Mktuple14__i __@x0)
    (FStar.Pervasives.Native.Mktuple14__j __@x0)
    (FStar.Pervasives.Native.Mktuple14__k __@x0)
    (FStar.Pervasives.Native.Mktuple14__l __@x0)
    (FStar.Pervasives.Native.Mktuple14__m __@x0)
    (FStar.Pervasives.Native.Mktuple14__n __@x0)
    (FStar.Pervasives.Native.Mktuple14__1 __@x0)
    (FStar.Pervasives.Native.Mktuple14__2 __@x0)
    (FStar.Pervasives.Native.Mktuple14__3 __@x0)
    (FStar.Pervasives.Native.Mktuple14__4 __@x0)
    (FStar.Pervasives.Native.Mktuple14__5 __@x0)
    (FStar.Pervasives.Native.Mktuple14__6 __@x0)
    (FStar.Pervasives.Native.Mktuple14__7 __@x0)
    (FStar.Pervasives.Native.Mktuple14__8 __@x0)
    (FStar.Pervasives.Native.Mktuple14__9 __@x0)
    (FStar.Pervasives.Native.Mktuple14__10 __@x0)
    (FStar.Pervasives.Native.Mktuple14__11 __@x0)
    (FStar.Pervasives.Native.Mktuple14__12 __@x0)
    (FStar.Pervasives.Native.Mktuple14__13 __@x0)
    (FStar.Pervasives.Native.Mktuple14__14 __@x0)))))
; </end constructor FStar.Pervasives.Native.Mktuple14>
; </end encoding type FStar.Pervasives.Native.tuple14>

; <Start encoding assume FStar.Pervasives.Native.tuple14__uu___haseq>
; </end encoding assume FStar.Pervasives.Native.tuple14__uu___haseq>

; <Start encoding val FStar.Pervasives.Native.uu___is_Mktuple14>
(declare-fun
 FStar.Pervasives.Native.uu___is_Mktuple14
 (Term Term Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_2de133cfaca100fc23d8bf4b3421db9a () Term)
(declare-fun FStar.Pervasives.Native.uu___is_Mktuple14@tok () Term)
; </end encoding val FStar.Pervasives.Native.uu___is_Mktuple14>

; <Skipped let uu___is_Mktuple14/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple14__item___1>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple14__item___1
 (Term Term Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_2e3216cab266e138debd68d0a503c177 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple14__item___1@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple14__item___1>

; <Skipped let __proj__Mktuple14__item___1/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple14__item___2>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple14__item___2
 (Term Term Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_958b0270e487d0bf5fe9191b9efaa127 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple14__item___2@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple14__item___2>

; <Skipped let __proj__Mktuple14__item___2/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple14__item___3>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple14__item___3
 (Term Term Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_08349f596f8c0acf60d1587bebe8c91b () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple14__item___3@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple14__item___3>

; <Skipped let __proj__Mktuple14__item___3/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple14__item___4>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple14__item___4
 (Term Term Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_2b069168147ba0f67f117ad5b0ac078b () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple14__item___4@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple14__item___4>

; <Skipped let __proj__Mktuple14__item___4/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple14__item___5>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple14__item___5
 (Term Term Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_1e38bb16245a24a197c44a262fee7bf1 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple14__item___5@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple14__item___5>

; <Skipped let __proj__Mktuple14__item___5/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple14__item___6>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple14__item___6
 (Term Term Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_7a148953a3884454d8a1dffddce086bb () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple14__item___6@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple14__item___6>

; <Skipped let __proj__Mktuple14__item___6/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple14__item___7>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple14__item___7
 (Term Term Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_812eeb3fdab56dfea8e419236740acb0 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple14__item___7@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple14__item___7>

; <Skipped let __proj__Mktuple14__item___7/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple14__item___8>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple14__item___8
 (Term Term Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_9dc932ce7cdfd6fa57f6536787fcb65b () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple14__item___8@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple14__item___8>

; <Skipped let __proj__Mktuple14__item___8/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple14__item___9>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple14__item___9
 (Term Term Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_2600722933f06bc55e28bb3fc2ce4a6a () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple14__item___9@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple14__item___9>

; <Skipped let __proj__Mktuple14__item___9/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple14__item___10>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple14__item___10
 (Term Term Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_f51203e57fd66f9e9293b8962c57edfe () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple14__item___10@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple14__item___10>

; <Skipped let __proj__Mktuple14__item___10/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple14__item___11>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple14__item___11
 (Term Term Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_7c34e0c28edc5fc4ad24d0b749c0adb7 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple14__item___11@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple14__item___11>

; <Skipped let __proj__Mktuple14__item___11/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple14__item___12>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple14__item___12
 (Term Term Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_8772cc50ea320af17b3f2371c273679a () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple14__item___12@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple14__item___12>

; <Skipped let __proj__Mktuple14__item___12/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple14__item___13>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple14__item___13
 (Term Term Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_039da0b9a8da1a651a1c570e55456614 () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple14__item___13@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple14__item___13>

; <Skipped let __proj__Mktuple14__item___13/>

; <Start encoding val FStar.Pervasives.Native.__proj__Mktuple14__item___14>
(declare-fun
 FStar.Pervasives.Native.__proj__Mktuple14__item___14
 (Term Term Term Term Term Term Term Term Term Term Term Term Term Term Term)
 Term)
(declare-fun Tm_arrow_579ada2eb036c15c7306dac5b648153e () Term)
(declare-fun FStar.Pervasives.Native.__proj__Mktuple14__item___14@tok () Term)
; </end encoding val FStar.Pervasives.Native.__proj__Mktuple14__item___14>

; <Skipped let __proj__Mktuple14__item___14/>

; End Externals for module FStar.Pervasives.Native
; Externals for interface FStar.Pervasives
; <Start encoding val FStar.Pervasives.remove_unused_type_parameters>
(declare-fun FStar.Pervasives.remove_unused_type_parameters (Term) Term)

(declare-fun FStar.Pervasives.remove_unused_type_parameters@tok () Term)
; </end encoding val FStar.Pervasives.remove_unused_type_parameters>

; <Start encoding let pattern>
(declare-fun FStar.Pervasives.pattern () Term)
; </end encoding let pattern>

; <Start encoding val FStar.Pervasives.smt_pat>
(declare-fun FStar.Pervasives.smt_pat (Term Term) Term)
(declare-fun Tm_arrow_ce7b692455ad1649f97902066cf7c9aa () Term)
(declare-fun FStar.Pervasives.smt_pat@tok () Term)
; </end encoding val FStar.Pervasives.smt_pat>

; <Start encoding val FStar.Pervasives.smt_pat_or>
(declare-fun FStar.Pervasives.smt_pat_or (Term) Term)
(declare-fun Tm_arrow_cbfaca2770c8ef7d6393b664b7ea1a41 () Term)
(declare-fun FStar.Pervasives.smt_pat_or@tok () Term)
; </end encoding val FStar.Pervasives.smt_pat_or>

; <Start encoding let eqtype_u>
(declare-fun FStar.Pervasives.eqtype_u () Term)

; </end encoding let eqtype_u>

; <Skipped effect FStar.Pervasives.Lemma a pre post pats = Prims.Pure a/>

; <Start encoding val FStar.Pervasives.spinoff>
(declare-fun FStar.Pervasives.spinoff (Term) Term)

(declare-fun FStar.Pervasives.spinoff@tok () Term)
; </end encoding val FStar.Pervasives.spinoff>

; <Start encoding val FStar.Pervasives.spinoff_eq>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Pervasives.spinoff_eq (Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Pervasives.spinoff_eq@tok () Term)
; </end encoding val FStar.Pervasives.spinoff_eq>

; <Start encoding val FStar.Pervasives.spinoff_equiv>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Pervasives.spinoff_equiv (Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Pervasives.spinoff_equiv@tok () Term)
; </end encoding val FStar.Pervasives.spinoff_equiv>

; <Start encoding val FStar.Pervasives.assert_spinoff>
(declare-fun FStar.Pervasives.assert_spinoff (Term) Term)

(declare-fun Tm_arrow_071538fd1c72fb82c7bb7b280daddf84 () Term)
(declare-fun FStar.Pervasives.assert_spinoff@tok () Term)

; </end encoding val FStar.Pervasives.assert_spinoff>

; <Start encoding let id>
(declare-fun FStar.Pervasives.id (Term Term) Term)

(declare-fun FStar.Pervasives.id@tok () Term)
; </end encoding let id>

; <Start encoding let trivial_pure_post>
(declare-fun FStar.Pervasives.trivial_pure_post (Term) Term)
(declare-fun Tm_arrow_53823f439377767fbcd3e27ebcdb971b () Term)
(declare-fun FStar.Pervasives.trivial_pure_post@tok () Term)

(declare-fun Tm_abs_5e34897418ce4950a4effcc8c159cf53 (Term) Term)
; </end encoding let trivial_pure_post>

; <Start encoding val FStar.Pervasives.ambient>
(declare-fun FStar.Pervasives.ambient (Term Term) Term)
(declare-fun Tm_arrow_9e007179360e2932d75ab29019e3d7fa () Term)
(declare-fun FStar.Pervasives.ambient@tok () Term)
; </end encoding val FStar.Pervasives.ambient>

; <Start encoding val FStar.Pervasives.intro_ambient>
(declare-fun FStar.Pervasives.intro_ambient (Term Term) Term)
(declare-fun Tm_arrow_6fc6334d56387f3d408122a4bd045e7e () Term)
(declare-fun FStar.Pervasives.intro_ambient@tok () Term)
; </end encoding val FStar.Pervasives.intro_ambient>

; <Start encoding val FStar.Pervasives.normalize_term>
(declare-fun FStar.Pervasives.normalize_term (Term Term) Term)

(declare-fun FStar.Pervasives.normalize_term@tok () Term)
; </end encoding val FStar.Pervasives.normalize_term>

; <Start encoding val FStar.Pervasives.normalize>
(declare-fun FStar.Pervasives.normalize (Term) Term)

(declare-fun FStar.Pervasives.normalize@tok () Term)
; </end encoding val FStar.Pervasives.normalize>

; <Start encoding val FStar.Pervasives.norm>
(declare-fun FStar.Pervasives.norm (Term Term Term) Term)
(declare-fun Tm_arrow_aee71d833dbd97a86f5f9c937995d6d6 () Term)
(declare-fun FStar.Pervasives.norm@tok () Term)
; </end encoding val FStar.Pervasives.norm>

; <Start encoding val FStar.Pervasives.assert_norm>
(declare-fun FStar.Pervasives.assert_norm (Term) Term)

(declare-fun Tm_arrow_ee24fcf624d074d3c637ee61e4a867fb () Term)
(declare-fun FStar.Pervasives.assert_norm@tok () Term)

; </end encoding val FStar.Pervasives.assert_norm>

; <Start encoding val FStar.Pervasives.normalize_term_spec>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Pervasives.normalize_term_spec (Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Pervasives.normalize_term_spec@tok () Term)
; </end encoding val FStar.Pervasives.normalize_term_spec>

; <Start encoding val FStar.Pervasives.normalize_spec>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Pervasives.normalize_spec (Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Pervasives.normalize_spec@tok () Term)
; </end encoding val FStar.Pervasives.normalize_spec>

; <Start encoding val FStar.Pervasives.norm_spec>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Pervasives.norm_spec (Term Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Pervasives.norm_spec@tok () Term)
; </end encoding val FStar.Pervasives.norm_spec>

; <Start encoding let reveal_opaque>
(declare-fun FStar.Pervasives.reveal_opaque (Term Term) Term)
(declare-fun Tm_refine_52210fb5c006e73edd2aa0f64235d467 (Term Term Term) Term)
(declare-fun Tm_arrow_e7c5eabfca000e59482a883faaaa695b (Term Term) Term)
(declare-fun Tm_arrow_5f531e41d6057ccfcfdd7979c0838737 () Term)
(declare-fun FStar.Pervasives.reveal_opaque@tok () Term)


; </end encoding let reveal_opaque>

; <Start encoding let pure_return>
(declare-fun FStar.Pervasives.pure_return (Term Term) Term)
(declare-fun Tm_arrow_0dff8d294aeaf0b1d7e9cad664c9a15f () Term)
(declare-fun FStar.Pervasives.pure_return@tok () Term)

(declare-fun Tm_abs_bc5117f6a06a581c69e04141781c86d0 (Term Term Term) Term)
(declare-fun Tm_arrow_c88a29758356586fc450d481d4b685f3 (Term) Term)
(declare-fun Tm_abs_bdac9a3f32789788b83138a3a4262d0d (Term Term) Term)
; </end encoding let pure_return>

; <Start encoding let pure_bind_wp>
(declare-fun Tm_arrow_c05bc9331677cc1a187ad7677301a601 (Term Term) Term)
(declare-fun FStar.Pervasives.pure_bind_wp (Term Term Term Term) Term)

(declare-fun Tm_arrow_f8eba41a4bcb9aca0e3c11224f695d1e () Term)
(declare-fun FStar.Pervasives.pure_bind_wp@tok () Term)


(declare-fun Tm_abs_d0f415a5361a9d7988d8e425dc193472 (Term Term Term) Term)

(declare-fun Tm_abs_72b65b71b828688dbb0ba657715a194c (Term Term Term Term) Term)
; </end encoding let pure_bind_wp>

; <Start encoding let pure_if_then_else>
(declare-fun FStar.Pervasives.pure_if_then_else (Term Term Term Term) Term)
(declare-fun Tm_arrow_5911c11ab85061b4a8acf6a6ff43aaea () Term)
(declare-fun FStar.Pervasives.pure_if_then_else@tok () Term)

(declare-fun Tm_abs_614d7ab3976dfea6b6428085a93bafcc (Term Term Term Term) Term)
; </end encoding let pure_if_then_else>

; <Start encoding let pure_ite_wp>
(declare-fun FStar.Pervasives.pure_ite_wp (Term Term) Term)
(declare-fun Tm_arrow_983cc9c1e881fffd3b37c61b327d54c8 () Term)
(declare-fun FStar.Pervasives.pure_ite_wp@tok () Term)

(declare-fun Tm_abs_ea1703a99385b474600aa7a3bdb045c5 (Term Term Term) Term)
(declare-fun Tm_arrow_b275e247a67e3e77d7c5997d864d1247 (Term) Term)
(declare-fun Tm_abs_f9993abe3e10fc5902262cf22e5f5e1c (Term Term Term) Term)

(declare-fun Tm_abs_a4d8a67e708eb0f8e41d6eefd90d8b3d (Term Term) Term)
; </end encoding let pure_ite_wp>

; <Start encoding let pure_close_wp>

(declare-fun FStar.Pervasives.pure_close_wp (Term Term Term) Term)

(declare-fun Tm_arrow_6424f17922e38fc8eb3b7ad8d9107d78 () Term)
(declare-fun FStar.Pervasives.pure_close_wp@tok () Term)




(declare-fun Tm_abs_bef01cdc202d648a37f7725a1e8579fa (Term Term Term) Term)
; </end encoding let pure_close_wp>

; <Start encoding let pure_null_wp>
(declare-fun FStar.Pervasives.pure_null_wp (Term) Term)
(declare-fun Tm_arrow_e02f472dad10492b4fdaf21971ae643f () Term)
(declare-fun FStar.Pervasives.pure_null_wp@tok () Term)



(declare-fun Tm_abs_c7a599bd05f6d553477b7b3a5a51d357 (Term) Term)
; </end encoding let pure_null_wp>

; <Start encoding let pure_assert_wp>
(declare-fun FStar.Pervasives.pure_assert_wp (Term) Term)

(declare-fun FStar.Pervasives.pure_assert_wp@tok () Term)
; </end encoding let pure_assert_wp>

; <Start encoding let pure_assume_wp>
(declare-fun FStar.Pervasives.pure_assume_wp (Term) Term)

(declare-fun FStar.Pervasives.pure_assume_wp@tok () Term)
; </end encoding let pure_assume_wp>

; <Skipped new_effect { FStar.Pervasives.DIV ... }/>

; <Skipped sub_effect Prims.PURE ~> FStar.Pervasives.DIV/>

; <Start encoding let div_hoare_to_wp>
(declare-fun FStar.Pervasives.div_hoare_to_wp (Term Term Term) Term)
(declare-fun Tm_arrow_e81e37f60b892c60a4b806bfecd6c240 () Term)
(declare-fun FStar.Pervasives.div_hoare_to_wp@tok () Term)




(declare-fun Tm_abs_69982e78bbdc9cbdfcc98c8c3ec276f1 (Term Term Term Term) Term)


(declare-fun Tm_abs_95829b03554cf2093d2bc29e28500b94 (Term Term Term) Term)
; </end encoding let div_hoare_to_wp>

; <Skipped effect FStar.Pervasives.Div a pre post = FStar.Pervasives.DIV a/>

; <Skipped effect FStar.Pervasives.Dv a = FStar.Pervasives.DIV a/>

; <Skipped effect FStar.Pervasives.EXT a = FStar.Pervasives.Dv a/>

; <Start encoding let st_pre_h>
(declare-fun FStar.Pervasives.st_pre_h (Term) Term)

(declare-fun FStar.Pervasives.st_pre_h@tok () Term)

; </end encoding let st_pre_h>

; <Start encoding let st_post_h'>
(declare-fun FStar.Pervasives.st_post_h_ (Term Term Term) Term)
(declare-fun Tm_arrow_659175ed40df3b798f91ffaee9e689bd () Term)
(declare-fun FStar.Pervasives.st_post_h_@tok () Term)

(declare-fun Tm_arrow_14435f7112db17792f8cd33f8f7ea859 (Term Term Term) Term)
; </end encoding let st_post_h'>

; <Start encoding let st_post_h>
(declare-fun FStar.Pervasives.st_post_h (Term Term) Term)

(declare-fun FStar.Pervasives.st_post_h@tok () Term)
; </end encoding let st_post_h>

; <Start encoding let st_wp_h>
(declare-fun FStar.Pervasives.st_wp_h (Term Term) Term)

(declare-fun FStar.Pervasives.st_wp_h@tok () Term)
(declare-fun Tm_arrow_c80b139653078194d2de90941effdc68 (Term Term) Term)
; </end encoding let st_wp_h>

; <Start encoding let st_return>
(declare-fun FStar.Pervasives.st_return (Term Term Term Term) Term)

(declare-fun Tm_arrow_6bfe4bf6faf1fb53a521d575cefc35ef () Term)
(declare-fun FStar.Pervasives.st_return@tok () Term)

; </end encoding let st_return>

; <Start encoding let st_bind_wp>
(declare-fun Tm_arrow_c6e0af8c2ccbdda79db5c09d07e87e35 (Term Term Term) Term)
(declare-fun FStar.Pervasives.st_bind_wp (Term Term Term Term Term Term Term) Term)

(declare-fun Tm_arrow_0eca50df2f29485bdbf578799f16b4a6 () Term)
(declare-fun FStar.Pervasives.st_bind_wp@tok () Term)

(declare-fun Tm_arrow_eb9b1a038524b37579c152a3f169145e (Term Term) Term)
(declare-fun Tm_abs_0f3b5ee9eaa8de8cacad7d3dcacb4558 (Term Term Term Term) Term)
; </end encoding let st_bind_wp>

; <Start encoding let st_if_then_else>
(declare-fun FStar.Pervasives.st_if_then_else (Term Term Term Term Term Term Term) Term)
(declare-fun Tm_arrow_6e48361e1a1c92df6ec1ff87e622ddad () Term)
(declare-fun FStar.Pervasives.st_if_then_else@tok () Term)
; </end encoding let st_if_then_else>

; <Start encoding let st_ite_wp>
(declare-fun FStar.Pervasives.st_ite_wp (Term Term Term Term Term) Term)
(declare-fun Tm_arrow_eaad896c6afdcb7ade2e80b5a6a930af () Term)
(declare-fun FStar.Pervasives.st_ite_wp@tok () Term)
; </end encoding let st_ite_wp>

; <Start encoding let st_stronger>
(declare-fun FStar.Pervasives.st_stronger (Term Term Term Term) Term)
(declare-fun Tm_arrow_ae4d7f489de84317e0022bf89d45dd95 () Term)
(declare-fun FStar.Pervasives.st_stronger@tok () Term)
; </end encoding let st_stronger>

; <Start encoding let st_close_wp>

(declare-fun FStar.Pervasives.st_close_wp (Term Term Term Term Term Term) Term)

(declare-fun Tm_arrow_de6d3045642382698e9e38d41acfd7cc () Term)
(declare-fun FStar.Pervasives.st_close_wp@tok () Term)

; </end encoding let st_close_wp>

; <Start encoding let st_trivial>
(declare-fun FStar.Pervasives.st_trivial (Term Term Term) Term)
(declare-fun Tm_arrow_f145e04ff3c7033bdfc718f7f5bb1df0 () Term)
(declare-fun FStar.Pervasives.st_trivial@tok () Term)

(declare-fun Tm_abs_89b21c42be5bc00d63e29f63ae20d4e2 (Term Term) Term)
; </end encoding let st_trivial>

; <Skipped new_effect { FStar.Pervasives.STATE_h ... }/>

; <Start encoding type FStar.Pervasives.result>
; Constructor
(declare-fun FStar.Pervasives.result (Term) Term)
; token
(declare-fun FStar.Pervasives.result@tok () Term)
; Constructor
(declare-fun FStar.Pervasives.V (Term Term) Term)
; Projector
(declare-fun FStar.Pervasives.V_a (Term) Term)
; Projector
(declare-fun FStar.Pervasives.V_v (Term) Term)
; data constructor proxy: FStar.Pervasives.V
(declare-fun FStar.Pervasives.V@tok () Term)
; Constructor
(declare-fun FStar.Pervasives.E (Term Term) Term)
; Projector
(declare-fun FStar.Pervasives.E_a (Term) Term)
; Projector
(declare-fun FStar.Pervasives.E_e (Term) Term)
; data constructor proxy: FStar.Pervasives.E
(declare-fun FStar.Pervasives.E@tok () Term)
; Constructor
(declare-fun FStar.Pervasives.Err (Term Term) Term)
; Projector
(declare-fun FStar.Pervasives.Err_a (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Err_msg (Term) Term)
; data constructor proxy: FStar.Pervasives.Err
(declare-fun FStar.Pervasives.Err@tok () Term)
(declare-fun Tm_arrow_30908143640041985b9200e2fb38a259 () Term)
(declare-fun Tm_arrow_f8bb10130fea772e0f786d78a188c381 () Term)
(declare-fun Tm_arrow_93661c87034b0b64c4714dafbe2b02e6 () Term)
; <start constructor FStar.Pervasives.result>
; Discriminator definition
(define-fun is-FStar.Pervasives.result ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 253)
  (exists ((@x0 Term)) (! (= __@x0 (FStar.Pervasives.result @x0)) :qid is-FStar.Pervasives.result))))
; </end constructor FStar.Pervasives.result>
; <start constructor FStar.Pervasives.V>
; Discriminator definition
(define-fun is-FStar.Pervasives.V ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 260)
  (= __@x0 (FStar.Pervasives.V (FStar.Pervasives.V_a __@x0) (FStar.Pervasives.V_v __@x0)))))
; </end constructor FStar.Pervasives.V>
; <start constructor FStar.Pervasives.E>
; Discriminator definition
(define-fun is-FStar.Pervasives.E ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 265)
  (= __@x0 (FStar.Pervasives.E (FStar.Pervasives.E_a __@x0) (FStar.Pervasives.E_e __@x0)))))
; </end constructor FStar.Pervasives.E>
; <start constructor FStar.Pervasives.Err>
; Discriminator definition
(define-fun is-FStar.Pervasives.Err ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 270)
  (= __@x0 (FStar.Pervasives.Err (FStar.Pervasives.Err_a __@x0) (FStar.Pervasives.Err_msg __@x0)))))
; </end constructor FStar.Pervasives.Err>
; </end encoding type FStar.Pervasives.result>

; <Start encoding val FStar.Pervasives.uu___is_V>
(declare-fun FStar.Pervasives.uu___is_V (Term Term) Term)
(declare-fun Tm_arrow_5cd1d0722a6a986faf6f8e557186fe24 () Term)
(declare-fun FStar.Pervasives.uu___is_V@tok () Term)
; </end encoding val FStar.Pervasives.uu___is_V>

; <Skipped let uu___is_V/>

; <Start encoding val FStar.Pervasives.__proj__V__item__v>
(declare-fun Tm_refine_9db520b26a7f39c5a01493a3f375290d (Term) Term)
(declare-fun FStar.Pervasives.__proj__V__item__v (Term Term) Term)

(declare-fun Tm_arrow_1ea119bf213c016916a7095486e28467 () Term)
(declare-fun FStar.Pervasives.__proj__V__item__v@tok () Term)
; </end encoding val FStar.Pervasives.__proj__V__item__v>

; <Skipped let __proj__V__item__v/>

; <Start encoding val FStar.Pervasives.uu___is_E>
(declare-fun FStar.Pervasives.uu___is_E (Term Term) Term)

(declare-fun FStar.Pervasives.uu___is_E@tok () Term)
; </end encoding val FStar.Pervasives.uu___is_E>

; <Skipped let uu___is_E/>

; <Start encoding val FStar.Pervasives.__proj__E__item__e>
(declare-fun Tm_refine_95e1e2ee29104754cc3740f5575fc6e5 (Term) Term)
(declare-fun FStar.Pervasives.__proj__E__item__e (Term Term) Term)

(declare-fun Tm_arrow_19e73c373dbf3f9945c6fcfce8a07661 () Term)
(declare-fun FStar.Pervasives.__proj__E__item__e@tok () Term)
; </end encoding val FStar.Pervasives.__proj__E__item__e>

; <Skipped let __proj__E__item__e/>

; <Start encoding val FStar.Pervasives.uu___is_Err>
(declare-fun FStar.Pervasives.uu___is_Err (Term Term) Term)

(declare-fun FStar.Pervasives.uu___is_Err@tok () Term)
; </end encoding val FStar.Pervasives.uu___is_Err>

; <Skipped let uu___is_Err/>

; <Start encoding val FStar.Pervasives.__proj__Err__item__msg>
(declare-fun Tm_refine_22fb403854eba07427f92e79848f9d9f (Term) Term)
(declare-fun FStar.Pervasives.__proj__Err__item__msg (Term Term) Term)

(declare-fun Tm_arrow_f7e3debb858e412c9497460c5187d5cd () Term)
(declare-fun FStar.Pervasives.__proj__Err__item__msg@tok () Term)
; </end encoding val FStar.Pervasives.__proj__Err__item__msg>

; <Skipped let __proj__Err__item__msg/>

; <Start encoding let ex_pre>
(declare-fun FStar.Pervasives.ex_pre () Term)
; </end encoding let ex_pre>

; <Start encoding let ex_post'>
(declare-fun FStar.Pervasives.ex_post_ (Term Term) Term)

(declare-fun FStar.Pervasives.ex_post_@tok () Term)
(declare-fun Tm_refine_a4dcdeeacbcb04d05a6720f786918fd6 (Term Term) Term)
(declare-fun Tm_arrow_68b66d987e8a7bdf825af8b370553e65 (Term Term) Term)
; </end encoding let ex_post'>

; <Start encoding let ex_post>
(declare-fun FStar.Pervasives.ex_post (Term) Term)

(declare-fun FStar.Pervasives.ex_post@tok () Term)
; </end encoding let ex_post>

; <Start encoding let ex_wp>
(declare-fun FStar.Pervasives.ex_wp (Term) Term)

(declare-fun FStar.Pervasives.ex_wp@tok () Term)
(declare-fun Tm_arrow_58168e52ae0908fefec42cac825ecc69 (Term) Term)
; </end encoding let ex_wp>

; <Start encoding let ex_return>
(declare-fun FStar.Pervasives.ex_return (Term Term Term) Term)
(declare-fun Tm_arrow_375264f6f19b4e37d33ffba9f6b1c7d2 () Term)
(declare-fun FStar.Pervasives.ex_return@tok () Term)
; </end encoding let ex_return>

; <Start encoding let ex_bind_wp>
(declare-fun Tm_arrow_3eb2992a529511f5b0ff2fef4e4594ad (Term Term) Term)
(declare-fun FStar.Pervasives.ex_bind_wp (Term Term Term Term Term) Term)

(declare-fun Tm_arrow_1da2056f1a2fe3dc8db7decf5cbd5885 () Term)
(declare-fun FStar.Pervasives.ex_bind_wp@tok () Term)

(declare-fun Tm_arrow_ca5db633696caf7e0cd44c11654eed8b (Term) Term)
(declare-fun Tm_abs_c1d9037a5cc10cc07ba9b6a7a58728db (Term Term Term Term) Term)
; </end encoding let ex_bind_wp>

; <Start encoding let ex_if_then_else>
(declare-fun FStar.Pervasives.ex_if_then_else (Term Term Term Term Term) Term)
(declare-fun Tm_arrow_08bd7ce530cc6e8b4a3f8dadbd0806b0 () Term)
(declare-fun FStar.Pervasives.ex_if_then_else@tok () Term)
; </end encoding let ex_if_then_else>

; <Start encoding let ex_ite_wp>
(declare-fun FStar.Pervasives.ex_ite_wp (Term Term Term) Term)
(declare-fun Tm_arrow_c2a8c761b16a75376b24262cd8c50369 () Term)
(declare-fun FStar.Pervasives.ex_ite_wp@tok () Term)
; </end encoding let ex_ite_wp>

; <Start encoding let ex_stronger>
(declare-fun FStar.Pervasives.ex_stronger (Term Term Term) Term)
(declare-fun Tm_arrow_1376d97b5d43e7d77d56729e2a3e04af () Term)
(declare-fun FStar.Pervasives.ex_stronger@tok () Term)
; </end encoding let ex_stronger>

; <Start encoding let ex_close_wp>

(declare-fun FStar.Pervasives.ex_close_wp (Term Term Term Term) Term)

(declare-fun Tm_arrow_814af0adff92aa08c5b8b0951bcb1959 () Term)
(declare-fun FStar.Pervasives.ex_close_wp@tok () Term)

; </end encoding let ex_close_wp>

; <Start encoding let ex_trivial>
(declare-fun FStar.Pervasives.ex_trivial (Term Term) Term)
(declare-fun Tm_arrow_ee4a787765920b0cb4357a47a0d3ac5c () Term)
(declare-fun FStar.Pervasives.ex_trivial@tok () Term)

(declare-fun Tm_abs_5cc223716d095f4545f0dcc745acad5d (Term) Term)
; </end encoding let ex_trivial>

; <Skipped new_effect { FStar.Pervasives.EXN ... }/>

; <Skipped effect FStar.Pervasives.Exn a pre post = FStar.Pervasives.EXN a/>

; <Start encoding let lift_div_exn>
(declare-fun FStar.Pervasives.lift_div_exn (Term Term Term) Term)
(declare-fun Tm_arrow_8196682216f286f6fe3a7dffb3de7d02 () Term)
(declare-fun FStar.Pervasives.lift_div_exn@tok () Term)

(declare-fun Tm_abs_c2b605ddd5d1991642baf5762d2b1dc5 (Term Term) Term)
; </end encoding let lift_div_exn>

; <Skipped sub_effect FStar.Pervasives.DIV ~> FStar.Pervasives.EXN/>

; <Skipped effect FStar.Pervasives.Ex a = FStar.Pervasives.Exn a/>

; <Start encoding let all_pre_h>
(declare-fun FStar.Pervasives.all_pre_h (Term) Term)

(declare-fun FStar.Pervasives.all_pre_h@tok () Term)

; </end encoding let all_pre_h>

; <Start encoding let all_post_h'>
(declare-fun FStar.Pervasives.all_post_h_ (Term Term Term) Term)

(declare-fun FStar.Pervasives.all_post_h_@tok () Term)

(declare-fun Tm_arrow_fc269489cb2e24a10c7710a1f7f9d269 (Term Term Term) Term)
; </end encoding let all_post_h'>

; <Start encoding let all_post_h>
(declare-fun FStar.Pervasives.all_post_h (Term Term) Term)

(declare-fun FStar.Pervasives.all_post_h@tok () Term)
; </end encoding let all_post_h>

; <Start encoding let all_wp_h>
(declare-fun FStar.Pervasives.all_wp_h (Term Term) Term)

(declare-fun FStar.Pervasives.all_wp_h@tok () Term)
(declare-fun Tm_arrow_1cd90c71d90a216d9fb0ba0321a1d3b5 (Term Term) Term)
; </end encoding let all_wp_h>

; <Start encoding let all_return>
(declare-fun FStar.Pervasives.all_return (Term Term Term Term) Term)

(declare-fun Tm_arrow_3f61557667800fb54cc62e48a5201f9d () Term)
(declare-fun FStar.Pervasives.all_return@tok () Term)

; </end encoding let all_return>

; <Start encoding let all_bind_wp>
(declare-fun Tm_arrow_b567b509414635f00096b9b1c3e30b57 (Term Term Term) Term)
(declare-fun FStar.Pervasives.all_bind_wp (Term Term Term Term Term Term Term) Term)

(declare-fun Tm_arrow_6ac18e25eb49f55ae0ce9c14679ecc22 () Term)
(declare-fun FStar.Pervasives.all_bind_wp@tok () Term)

(declare-fun Tm_arrow_59cac8a9b1ae3aa9511b8a867f8e934e (Term Term) Term)
(declare-fun Tm_abs_35ddc99cefc0079215f6f6ab3c58856d (Term Term Term Term Term) Term)
; </end encoding let all_bind_wp>

; <Start encoding let all_if_then_else>
(declare-fun FStar.Pervasives.all_if_then_else (Term Term Term Term Term Term Term) Term)
(declare-fun Tm_arrow_491eee2c8dc4eab4d420326a8285d2c4 () Term)
(declare-fun FStar.Pervasives.all_if_then_else@tok () Term)
; </end encoding let all_if_then_else>

; <Start encoding let all_ite_wp>
(declare-fun FStar.Pervasives.all_ite_wp (Term Term Term Term Term) Term)
(declare-fun Tm_arrow_20fdb4e6d0c32f949f55e39a059913a7 () Term)
(declare-fun FStar.Pervasives.all_ite_wp@tok () Term)
; </end encoding let all_ite_wp>

; <Start encoding let all_stronger>
(declare-fun FStar.Pervasives.all_stronger (Term Term Term Term) Term)
(declare-fun Tm_arrow_073b21d0ec8edf2dda32907b45ec5f68 () Term)
(declare-fun FStar.Pervasives.all_stronger@tok () Term)
; </end encoding let all_stronger>

; <Start encoding let all_close_wp>

(declare-fun FStar.Pervasives.all_close_wp (Term Term Term Term Term Term) Term)

(declare-fun Tm_arrow_803d195802308e8beadf04438d3a6508 () Term)
(declare-fun FStar.Pervasives.all_close_wp@tok () Term)

; </end encoding let all_close_wp>

; <Start encoding let all_trivial>
(declare-fun FStar.Pervasives.all_trivial (Term Term Term) Term)
(declare-fun Tm_arrow_957927b0d25001784693eee8b2182308 () Term)
(declare-fun FStar.Pervasives.all_trivial@tok () Term)

(declare-fun Tm_abs_22e463dbd987016e31d6bc67025a7cd9 (Term Term) Term)
; </end encoding let all_trivial>

; <Skipped new_effect { FStar.Pervasives.ALL_h ... }/>

; <Start encoding val FStar.Pervasives.inversion>
(declare-fun FStar.Pervasives.inversion (Term) Term)

(declare-fun FStar.Pervasives.inversion@tok () Term)
; </end encoding val FStar.Pervasives.inversion>

; <Start encoding val FStar.Pervasives.allow_inversion>
(declare-fun FStar.Pervasives.allow_inversion (Term) Term)
(declare-fun Tm_refine_363615bee79fae5066b7c8bd06c286d0 (Term) Term)
(declare-fun Tm_arrow_bcab9cce464ec0f76562bc48c17ba410 () Term)
(declare-fun FStar.Pervasives.allow_inversion@tok () Term)

; </end encoding val FStar.Pervasives.allow_inversion>

; <Start encoding val FStar.Pervasives.invertOption>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Pervasives.invertOption (Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Pervasives.invertOption@tok () Term)
; </end encoding val FStar.Pervasives.invertOption>

; <Start encoding type FStar.Pervasives.either>
; Constructor
(declare-fun FStar.Pervasives.either (Term Term) Term)
; token
(declare-fun FStar.Pervasives.either@tok () Term)
; Constructor
(declare-fun FStar.Pervasives.Inl (Term Term Term) Term)
; Projector
(declare-fun FStar.Pervasives.Inl_a (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Inl_b (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Inl_v (Term) Term)
; data constructor proxy: FStar.Pervasives.Inl
(declare-fun FStar.Pervasives.Inl@tok () Term)
; Constructor
(declare-fun FStar.Pervasives.Inr (Term Term Term) Term)
; Projector
(declare-fun FStar.Pervasives.Inr_a (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Inr_b (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Inr_v (Term) Term)
; data constructor proxy: FStar.Pervasives.Inr
(declare-fun FStar.Pervasives.Inr@tok () Term)
(declare-fun Tm_arrow_065da0adeba0c4ae0da1476ececee84c () Term)
(declare-fun Tm_arrow_c883938642e6d97d79c975d8d94b4aac () Term)
; <start constructor FStar.Pervasives.either>
; Discriminator definition
(define-fun is-FStar.Pervasives.either ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 392)
  (exists ((@x0 Term) (@x1 Term))
   (! (= __@x0 (FStar.Pervasives.either @x0 @x1)) :qid is-FStar.Pervasives.either))))
; </end constructor FStar.Pervasives.either>
; <start constructor FStar.Pervasives.Inl>
; Discriminator definition
(define-fun is-FStar.Pervasives.Inl ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 399)
  (=
   __@x0
   (FStar.Pervasives.Inl
    (FStar.Pervasives.Inl_a __@x0)
    (FStar.Pervasives.Inl_b __@x0)
    (FStar.Pervasives.Inl_v __@x0)))))
; </end constructor FStar.Pervasives.Inl>
; <start constructor FStar.Pervasives.Inr>
; Discriminator definition
(define-fun is-FStar.Pervasives.Inr ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 404)
  (=
   __@x0
   (FStar.Pervasives.Inr
    (FStar.Pervasives.Inr_a __@x0)
    (FStar.Pervasives.Inr_b __@x0)
    (FStar.Pervasives.Inr_v __@x0)))))
; </end constructor FStar.Pervasives.Inr>
; </end encoding type FStar.Pervasives.either>

; <Start encoding assume FStar.Pervasives.either__uu___haseq>
; </end encoding assume FStar.Pervasives.either__uu___haseq>

; <Start encoding val FStar.Pervasives.uu___is_Inl>
(declare-fun FStar.Pervasives.uu___is_Inl (Term Term Term) Term)
(declare-fun Tm_arrow_af0c68f1e39d4d6020c0873b16730c7d () Term)
(declare-fun FStar.Pervasives.uu___is_Inl@tok () Term)
; </end encoding val FStar.Pervasives.uu___is_Inl>

; <Skipped let uu___is_Inl/>

; <Start encoding val FStar.Pervasives.__proj__Inl__item__v>
(declare-fun Tm_refine_85e0cc884f8457202f90cd77f23733ba (Term Term) Term)
(declare-fun FStar.Pervasives.__proj__Inl__item__v (Term Term Term) Term)

(declare-fun Tm_arrow_a80e0750277867ba1a434ad3bba8702d () Term)
(declare-fun FStar.Pervasives.__proj__Inl__item__v@tok () Term)
; </end encoding val FStar.Pervasives.__proj__Inl__item__v>

; <Skipped let __proj__Inl__item__v/>

; <Start encoding val FStar.Pervasives.uu___is_Inr>
(declare-fun FStar.Pervasives.uu___is_Inr (Term Term Term) Term)

(declare-fun FStar.Pervasives.uu___is_Inr@tok () Term)
; </end encoding val FStar.Pervasives.uu___is_Inr>

; <Skipped let uu___is_Inr/>

; <Start encoding val FStar.Pervasives.__proj__Inr__item__v>
(declare-fun Tm_refine_8f1f5f564dae90240db429de2eb41517 (Term Term) Term)
(declare-fun FStar.Pervasives.__proj__Inr__item__v (Term Term Term) Term)

(declare-fun Tm_arrow_df618db6b42762940f198036c8a56200 () Term)
(declare-fun FStar.Pervasives.__proj__Inr__item__v@tok () Term)
; </end encoding val FStar.Pervasives.__proj__Inr__item__v>

; <Skipped let __proj__Inr__item__v/>

; <Start encoding let dfst>

(declare-fun FStar.Pervasives.dfst (Term Term Term) Term)


(declare-fun FStar.Pervasives.dfst@tok () Term)

; </end encoding let dfst>

; <Start encoding let dsnd>

(declare-fun FStar.Pervasives.dsnd (Term Term Term) Term)


(declare-fun FStar.Pervasives.dsnd@tok () Term)

; </end encoding let dsnd>

; <Start encoding type FStar.Pervasives.dtuple3>
; Constructor
(declare-fun FStar.Pervasives.dtuple3 (Term Term Term) Term)
; token
(declare-fun FStar.Pervasives.dtuple3@tok () Term)
; Constructor
(declare-fun FStar.Pervasives.Mkdtuple3 (Term Term Term Term Term Term) Term)
; Projector
(declare-fun FStar.Pervasives.Mkdtuple3_a (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Mkdtuple3_b (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Mkdtuple3_c (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Mkdtuple3__1 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Mkdtuple3__2 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Mkdtuple3__3 (Term) Term)
; data constructor proxy: FStar.Pervasives.Mkdtuple3
(declare-fun FStar.Pervasives.Mkdtuple3@tok () Term)

(declare-fun Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 (Term Term) Term)




(declare-fun Tm_arrow_8423f67df62f9e824c55756f9e26058d () Term)
; <start constructor FStar.Pervasives.dtuple3>
; Discriminator definition
(define-fun is-FStar.Pervasives.dtuple3 ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 440)
  (exists ((@x0 Term) (@x1 Term) (@x2 Term))
   (! (= __@x0 (FStar.Pervasives.dtuple3 @x0 @x1 @x2)) :qid is-FStar.Pervasives.dtuple3))))
; </end constructor FStar.Pervasives.dtuple3>
; <start constructor FStar.Pervasives.Mkdtuple3>
; Discriminator definition
(define-fun is-FStar.Pervasives.Mkdtuple3 ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 451)
  (=
   __@x0
   (FStar.Pervasives.Mkdtuple3
    (FStar.Pervasives.Mkdtuple3_a __@x0)
    (FStar.Pervasives.Mkdtuple3_b __@x0)
    (FStar.Pervasives.Mkdtuple3_c __@x0)
    (FStar.Pervasives.Mkdtuple3__1 __@x0)
    (FStar.Pervasives.Mkdtuple3__2 __@x0)
    (FStar.Pervasives.Mkdtuple3__3 __@x0)))))
; </end constructor FStar.Pervasives.Mkdtuple3>
; </end encoding type FStar.Pervasives.dtuple3>

; <Start encoding assume FStar.Pervasives.dtuple3__uu___haseq>


; </end encoding assume FStar.Pervasives.dtuple3__uu___haseq>

; <Start encoding val FStar.Pervasives.uu___is_Mkdtuple3>


(declare-fun FStar.Pervasives.uu___is_Mkdtuple3 (Term Term Term Term) Term)


(declare-fun Tm_arrow_70452cb82cd0a282ca9a2dbeb54c1b04 () Term)
(declare-fun FStar.Pervasives.uu___is_Mkdtuple3@tok () Term)
; </end encoding val FStar.Pervasives.uu___is_Mkdtuple3>

; <Skipped let uu___is_Mkdtuple3/>

; <Start encoding val FStar.Pervasives.__proj__Mkdtuple3__item___1>


(declare-fun FStar.Pervasives.__proj__Mkdtuple3__item___1 (Term Term Term Term) Term)


(declare-fun Tm_arrow_255f0cfe499b1d2e9836e157bce1dba3 () Term)
(declare-fun FStar.Pervasives.__proj__Mkdtuple3__item___1@tok () Term)
; </end encoding val FStar.Pervasives.__proj__Mkdtuple3__item___1>

; <Skipped let __proj__Mkdtuple3__item___1/>

; <Start encoding val FStar.Pervasives.__proj__Mkdtuple3__item___2>


(declare-fun FStar.Pervasives.__proj__Mkdtuple3__item___2 (Term Term Term Term) Term)


(declare-fun Tm_arrow_ea1ded11f7d194a26e812f407333a011 () Term)
(declare-fun FStar.Pervasives.__proj__Mkdtuple3__item___2@tok () Term)
; </end encoding val FStar.Pervasives.__proj__Mkdtuple3__item___2>

; <Skipped let __proj__Mkdtuple3__item___2/>

; <Start encoding val FStar.Pervasives.__proj__Mkdtuple3__item___3>


(declare-fun FStar.Pervasives.__proj__Mkdtuple3__item___3 (Term Term Term Term) Term)


(declare-fun Tm_arrow_1d7ad5cfa0fff643640e3f74466d283e () Term)
(declare-fun FStar.Pervasives.__proj__Mkdtuple3__item___3@tok () Term)
; </end encoding val FStar.Pervasives.__proj__Mkdtuple3__item___3>

; <Skipped let __proj__Mkdtuple3__item___3/>

; <Start encoding type FStar.Pervasives.dtuple4>
; Constructor
(declare-fun FStar.Pervasives.dtuple4 (Term Term Term Term) Term)
; token
(declare-fun FStar.Pervasives.dtuple4@tok () Term)
; Constructor
(declare-fun FStar.Pervasives.Mkdtuple4 (Term Term Term Term Term Term Term Term) Term)
; Projector
(declare-fun FStar.Pervasives.Mkdtuple4_a (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Mkdtuple4_b (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Mkdtuple4_c (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Mkdtuple4_d (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Mkdtuple4__1 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Mkdtuple4__2 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Mkdtuple4__3 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Mkdtuple4__4 (Term) Term)
; data constructor proxy: FStar.Pervasives.Mkdtuple4
(declare-fun FStar.Pervasives.Mkdtuple4@tok () Term)


(declare-fun Tm_arrow_af8eda99ba3685403be22a88669dcb35 (Term Term Term) Term)






(declare-fun Tm_arrow_cef44a6056754f192c2446237c4c1408 () Term)
; <start constructor FStar.Pervasives.dtuple4>
; Discriminator definition
(define-fun is-FStar.Pervasives.dtuple4 ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 509)
  (exists ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
   (! (= __@x0 (FStar.Pervasives.dtuple4 @x0 @x1 @x2 @x3)) :qid is-FStar.Pervasives.dtuple4))))
; </end constructor FStar.Pervasives.dtuple4>
; <start constructor FStar.Pervasives.Mkdtuple4>
; Discriminator definition
(define-fun is-FStar.Pervasives.Mkdtuple4 ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 522)
  (=
   __@x0
   (FStar.Pervasives.Mkdtuple4
    (FStar.Pervasives.Mkdtuple4_a __@x0)
    (FStar.Pervasives.Mkdtuple4_b __@x0)
    (FStar.Pervasives.Mkdtuple4_c __@x0)
    (FStar.Pervasives.Mkdtuple4_d __@x0)
    (FStar.Pervasives.Mkdtuple4__1 __@x0)
    (FStar.Pervasives.Mkdtuple4__2 __@x0)
    (FStar.Pervasives.Mkdtuple4__3 __@x0)
    (FStar.Pervasives.Mkdtuple4__4 __@x0)))))
; </end constructor FStar.Pervasives.Mkdtuple4>
; </end encoding type FStar.Pervasives.dtuple4>

; <Start encoding assume FStar.Pervasives.dtuple4__uu___haseq>



; </end encoding assume FStar.Pervasives.dtuple4__uu___haseq>

; <Start encoding val FStar.Pervasives.uu___is_Mkdtuple4>



(declare-fun FStar.Pervasives.uu___is_Mkdtuple4 (Term Term Term Term Term) Term)



(declare-fun Tm_arrow_76a226dc2cea2ddd4e4258637fc95e5b () Term)
(declare-fun FStar.Pervasives.uu___is_Mkdtuple4@tok () Term)
; </end encoding val FStar.Pervasives.uu___is_Mkdtuple4>

; <Skipped let uu___is_Mkdtuple4/>

; <Start encoding val FStar.Pervasives.__proj__Mkdtuple4__item___1>



(declare-fun FStar.Pervasives.__proj__Mkdtuple4__item___1 (Term Term Term Term Term) Term)



(declare-fun Tm_arrow_1da4d60ab69f411b912e76cc25e77965 () Term)
(declare-fun FStar.Pervasives.__proj__Mkdtuple4__item___1@tok () Term)
; </end encoding val FStar.Pervasives.__proj__Mkdtuple4__item___1>

; <Skipped let __proj__Mkdtuple4__item___1/>

; <Start encoding val FStar.Pervasives.__proj__Mkdtuple4__item___2>



(declare-fun FStar.Pervasives.__proj__Mkdtuple4__item___2 (Term Term Term Term Term) Term)



(declare-fun Tm_arrow_a86867091548f3d7d3ca1cb8b0458b9f () Term)
(declare-fun FStar.Pervasives.__proj__Mkdtuple4__item___2@tok () Term)
; </end encoding val FStar.Pervasives.__proj__Mkdtuple4__item___2>

; <Skipped let __proj__Mkdtuple4__item___2/>

; <Start encoding val FStar.Pervasives.__proj__Mkdtuple4__item___3>



(declare-fun FStar.Pervasives.__proj__Mkdtuple4__item___3 (Term Term Term Term Term) Term)



(declare-fun Tm_arrow_ee72552fcc293405aa0e854ba26f27ac () Term)
(declare-fun FStar.Pervasives.__proj__Mkdtuple4__item___3@tok () Term)
; </end encoding val FStar.Pervasives.__proj__Mkdtuple4__item___3>

; <Skipped let __proj__Mkdtuple4__item___3/>

; <Start encoding val FStar.Pervasives.__proj__Mkdtuple4__item___4>



(declare-fun FStar.Pervasives.__proj__Mkdtuple4__item___4 (Term Term Term Term Term) Term)



(declare-fun Tm_arrow_6c79def96aa5d5d9eb9555c48dd9ebb6 () Term)
(declare-fun FStar.Pervasives.__proj__Mkdtuple4__item___4@tok () Term)
; </end encoding val FStar.Pervasives.__proj__Mkdtuple4__item___4>

; <Skipped let __proj__Mkdtuple4__item___4/>

; <Start encoding type FStar.Pervasives.dtuple5>
; Constructor
(declare-fun FStar.Pervasives.dtuple5 (Term Term Term Term Term) Term)
; token
(declare-fun FStar.Pervasives.dtuple5@tok () Term)
; Constructor
(declare-fun FStar.Pervasives.Mkdtuple5 (Term Term Term Term Term Term Term Term Term Term) Term)
; Projector
(declare-fun FStar.Pervasives.Mkdtuple5_a (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Mkdtuple5_b (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Mkdtuple5_c (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Mkdtuple5_d (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Mkdtuple5_e (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Mkdtuple5__1 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Mkdtuple5__2 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Mkdtuple5__3 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Mkdtuple5__4 (Term) Term)
; Projector
(declare-fun FStar.Pervasives.Mkdtuple5__5 (Term) Term)
; data constructor proxy: FStar.Pervasives.Mkdtuple5
(declare-fun FStar.Pervasives.Mkdtuple5@tok () Term)



(declare-fun Tm_arrow_e2051b23ee191036cd2c8f08b57577cc (Term Term Term Term) Term)








(declare-fun Tm_arrow_7c47a0b67fa3d6e69e51a1ade2982e74 () Term)
; <start constructor FStar.Pervasives.dtuple5>
; Discriminator definition
(define-fun is-FStar.Pervasives.dtuple5 ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 616)
  (exists ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
   (! (= __@x0 (FStar.Pervasives.dtuple5 @x0 @x1 @x2 @x3 @x4)) :qid is-FStar.Pervasives.dtuple5))))
; </end constructor FStar.Pervasives.dtuple5>
; <start constructor FStar.Pervasives.Mkdtuple5>
; Discriminator definition
(define-fun is-FStar.Pervasives.Mkdtuple5 ((__@x0 Term)) Bool
 (and
  (= (Term_constr_id __@x0) 631)
  (=
   __@x0
   (FStar.Pervasives.Mkdtuple5
    (FStar.Pervasives.Mkdtuple5_a __@x0)
    (FStar.Pervasives.Mkdtuple5_b __@x0)
    (FStar.Pervasives.Mkdtuple5_c __@x0)
    (FStar.Pervasives.Mkdtuple5_d __@x0)
    (FStar.Pervasives.Mkdtuple5_e __@x0)
    (FStar.Pervasives.Mkdtuple5__1 __@x0)
    (FStar.Pervasives.Mkdtuple5__2 __@x0)
    (FStar.Pervasives.Mkdtuple5__3 __@x0)
    (FStar.Pervasives.Mkdtuple5__4 __@x0)
    (FStar.Pervasives.Mkdtuple5__5 __@x0)))))
; </end constructor FStar.Pervasives.Mkdtuple5>
; </end encoding type FStar.Pervasives.dtuple5>

; <Start encoding assume FStar.Pervasives.dtuple5__uu___haseq>




; </end encoding assume FStar.Pervasives.dtuple5__uu___haseq>

; <Start encoding val FStar.Pervasives.uu___is_Mkdtuple5>




(declare-fun FStar.Pervasives.uu___is_Mkdtuple5 (Term Term Term Term Term Term) Term)




(declare-fun Tm_arrow_790317d9d2afaf2417875fd8f65cee9f () Term)
(declare-fun FStar.Pervasives.uu___is_Mkdtuple5@tok () Term)
; </end encoding val FStar.Pervasives.uu___is_Mkdtuple5>

; <Skipped let uu___is_Mkdtuple5/>

; <Start encoding val FStar.Pervasives.__proj__Mkdtuple5__item___1>




(declare-fun FStar.Pervasives.__proj__Mkdtuple5__item___1 (Term Term Term Term Term Term) Term)




(declare-fun Tm_arrow_855676d3a54fc2cdf0dfa3ac2f15fdad () Term)
(declare-fun FStar.Pervasives.__proj__Mkdtuple5__item___1@tok () Term)
; </end encoding val FStar.Pervasives.__proj__Mkdtuple5__item___1>

; <Skipped let __proj__Mkdtuple5__item___1/>

; <Start encoding val FStar.Pervasives.__proj__Mkdtuple5__item___2>




(declare-fun FStar.Pervasives.__proj__Mkdtuple5__item___2 (Term Term Term Term Term Term) Term)




(declare-fun Tm_arrow_3c181aa1af161d84af20412908ff5981 () Term)
(declare-fun FStar.Pervasives.__proj__Mkdtuple5__item___2@tok () Term)
; </end encoding val FStar.Pervasives.__proj__Mkdtuple5__item___2>

; <Skipped let __proj__Mkdtuple5__item___2/>

; <Start encoding val FStar.Pervasives.__proj__Mkdtuple5__item___3>




(declare-fun FStar.Pervasives.__proj__Mkdtuple5__item___3 (Term Term Term Term Term Term) Term)




(declare-fun Tm_arrow_cc152ea4c314cfd6854de94e70041031 () Term)
(declare-fun FStar.Pervasives.__proj__Mkdtuple5__item___3@tok () Term)
; </end encoding val FStar.Pervasives.__proj__Mkdtuple5__item___3>

; <Skipped let __proj__Mkdtuple5__item___3/>

; <Start encoding val FStar.Pervasives.__proj__Mkdtuple5__item___4>




(declare-fun FStar.Pervasives.__proj__Mkdtuple5__item___4 (Term Term Term Term Term Term) Term)




(declare-fun Tm_arrow_6a05465acf4f8d1b8f43fd30077a772a () Term)
(declare-fun FStar.Pervasives.__proj__Mkdtuple5__item___4@tok () Term)
; </end encoding val FStar.Pervasives.__proj__Mkdtuple5__item___4>

; <Skipped let __proj__Mkdtuple5__item___4/>

; <Start encoding val FStar.Pervasives.__proj__Mkdtuple5__item___5>




(declare-fun FStar.Pervasives.__proj__Mkdtuple5__item___5 (Term Term Term Term Term Term) Term)




(declare-fun Tm_arrow_d5d61b48d54646c5c411627b3a20c98f () Term)
(declare-fun FStar.Pervasives.__proj__Mkdtuple5__item___5@tok () Term)
; </end encoding val FStar.Pervasives.__proj__Mkdtuple5__item___5>

; <Skipped let __proj__Mkdtuple5__item___5/>

; <Start encoding let ignore>
(declare-fun FStar.Pervasives.ignore (Term Term) Term)

(declare-fun FStar.Pervasives.ignore@tok () Term)
; </end encoding let ignore>

; <Start encoding val FStar.Pervasives.false_elim>
(declare-fun Tm_refine_f1ecc6ab6882a651504f328937700647 () Term)
(declare-fun FStar.Pervasives.false_elim (Term Term) Term)

(declare-fun Tm_arrow_7636fbfab5cd88ba06f60c10ea8caef2 () Term)
(declare-fun FStar.Pervasives.false_elim@tok () Term)
; </end encoding val FStar.Pervasives.false_elim>

; <Start encoding val FStar.Pervasives.singleton>
(declare-fun FStar.Pervasives.singleton (Term Term) Term)
(declare-fun Tm_refine_2fbd657fe85bcb2423f9c7e5f9b3bcb5 (Term Term) Term)
(declare-fun Tm_arrow_9cdb4ebd85da757e86217b6fb07ef9fc () Term)
(declare-fun FStar.Pervasives.singleton@tok () Term)

; </end encoding val FStar.Pervasives.singleton>

; <Start encoding let eqtype_as_type>
(declare-fun FStar.Pervasives.eqtype_as_type (Term) Term)
(declare-fun Tm_arrow_7e9afc6da5407011473323ad80ff51bf () Term)
(declare-fun FStar.Pervasives.eqtype_as_type@tok () Term)
; </end encoding let eqtype_as_type>

; <Start encoding let coerce_eq>
(declare-fun Tm_refine_0dee8cb03258a67c2f7ec66427696212 (Term Term) Term)
(declare-fun FStar.Pervasives.coerce_eq (Term Term Term Term) Term)

(declare-fun Tm_arrow_f44173fb14fa6046eedce5f32cb8aae8 () Term)
(declare-fun FStar.Pervasives.coerce_eq@tok () Term)

; </end encoding let coerce_eq>

; <Start encoding val FStar.Pervasives.normalize_for_extraction>
(declare-fun FStar.Pervasives.normalize_for_extraction (Term) Term)
(declare-fun Tm_arrow_20fe1cac894a118b448754808ccf04f5 () Term)
(declare-fun FStar.Pervasives.normalize_for_extraction@tok () Term)
; </end encoding val FStar.Pervasives.normalize_for_extraction>

; <Start encoding val FStar.Pervasives.normalize_for_extraction_type>
(declare-fun FStar.Pervasives.normalize_for_extraction_type (Dummy_sort) Term)
; </end encoding val FStar.Pervasives.normalize_for_extraction_type>

; End Externals for interface FStar.Pervasives
; Externals for interface FStar.Prelude
; End Externals for interface FStar.Prelude
; Externals for interface FStar.Sealed
; <Start encoding val FStar.Sealed.sealed>
(declare-fun FStar.Sealed.sealed (Term) Term)

(declare-fun FStar.Sealed.sealed@tok () Term)
; </end encoding val FStar.Sealed.sealed>

; <Start encoding val FStar.Sealed.sealed_singl>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Sealed.sealed_singl (Term Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Sealed.sealed_singl@tok () Term)
; </end encoding val FStar.Sealed.sealed_singl>

; <Start encoding val FStar.Sealed.seal>
(declare-fun FStar.Sealed.seal (Term Term) Term)
(declare-fun Tm_arrow_202c0385508095b22536f7b176783182 () Term)
(declare-fun FStar.Sealed.seal@tok () Term)
; </end encoding val FStar.Sealed.seal>

; <Start encoding val FStar.Sealed.map_seal>
(declare-fun Tm_arrow_6980332764c4493a7b0df5c02f7aefbe (Term Term) Term)
(declare-fun FStar.Sealed.map_seal (Term Term Term Term) Term)

(declare-fun Tm_arrow_8ae919a1b422d31df5f3a30011fa6e98 () Term)
(declare-fun FStar.Sealed.map_seal@tok () Term)
; </end encoding val FStar.Sealed.map_seal>

; <Start encoding val FStar.Sealed.bind_seal>
(declare-fun Tm_arrow_5dc851dfbcbc38067d4415ede8f88e9f (Term Term) Term)
(declare-fun FStar.Sealed.bind_seal (Term Term Term Term) Term)

(declare-fun Tm_arrow_4d90a5e6583ddd9ddbd451cbed0e9d01 () Term)
(declare-fun FStar.Sealed.bind_seal@tok () Term)
; </end encoding val FStar.Sealed.bind_seal>

; End Externals for interface FStar.Sealed
; Externals for interface FStar.Range
; <Start encoding val FStar.Range.__range>
(declare-fun FStar.Range.__range () Term)
; </end encoding val FStar.Range.__range>

; <Start encoding let range>
(declare-fun FStar.Range.range () Term)
; </end encoding let range>

; <Start encoding val FStar.Range.__range_0>
(declare-fun FStar.Range.__range_0 (Dummy_sort) Term)
; </end encoding val FStar.Range.__range_0>

; <Start encoding let range_0>
(declare-fun FStar.Range.range_0 (Dummy_sort) Term)
; </end encoding let range_0>

; <Start encoding val FStar.Range.__mk_range>
(declare-fun FStar.Range.__mk_range (Term Term Term Term Term) Term)
(declare-fun Tm_arrow_692aa0ebe01353db00b5203de7da6785 () Term)
(declare-fun FStar.Range.__mk_range@tok () Term)
; </end encoding val FStar.Range.__mk_range>

; <Start encoding val FStar.Range.mk_range>
(declare-fun FStar.Range.mk_range (Term Term Term Term Term) Term)
(declare-fun Tm_arrow_2d3d853349c0a35c0e0c8d13086384ea () Term)
(declare-fun FStar.Range.mk_range@tok () Term)
; </end encoding val FStar.Range.mk_range>

; <Start encoding val FStar.Range.join_range>
(declare-fun FStar.Range.join_range (Term Term) Term)
(declare-fun Tm_arrow_6eaaa31f2d36a5c7cca7eb998962a7fa () Term)
(declare-fun FStar.Range.join_range@tok () Term)
; </end encoding val FStar.Range.join_range>

; <Start encoding let labeled>
(declare-fun FStar.Range.labeled (Term Term Term) Term)
(declare-fun Tm_arrow_ab5899212fc4c148181589be7fd78af1 () Term)
(declare-fun FStar.Range.labeled@tok () Term)
; </end encoding let labeled>

; <Start encoding val FStar.Range.explode>
(declare-fun FStar.Range.explode (Term) Term)
(declare-fun Tm_arrow_f9315f3207257087f0bf3975f13024e3 () Term)
(declare-fun FStar.Range.explode@tok () Term)
; </end encoding val FStar.Range.explode>

; End Externals for interface FStar.Range
; Externals for module FStar.Preorder
; <Start encoding let relation>
(declare-fun FStar.Preorder.relation (Term) Term)

(declare-fun FStar.Preorder.relation@tok () Term)
(declare-fun Tm_arrow_a19f9d49348d4e0038f0ded87d87802f (Term) Term)
; </end encoding let relation>

; <Start encoding let predicate>
(declare-fun FStar.Preorder.predicate (Term) Term)

(declare-fun FStar.Preorder.predicate@tok () Term)

; </end encoding let predicate>

; <Start encoding let reflexive>
(declare-fun FStar.Preorder.reflexive (Term Term) Term)
(declare-fun Tm_arrow_8e677a33afbeb812aa3779b7bdd0131c () Term)
(declare-fun FStar.Preorder.reflexive@tok () Term)
; </end encoding let reflexive>

; <Start encoding let transitive>
(declare-fun FStar.Preorder.transitive (Term Term) Term)

(declare-fun FStar.Preorder.transitive@tok () Term)
; </end encoding let transitive>

; <Start encoding let preorder_rel>
(declare-fun FStar.Preorder.preorder_rel (Term Term) Term)

(declare-fun FStar.Preorder.preorder_rel@tok () Term)
; </end encoding let preorder_rel>

; <Start encoding let preorder>
(declare-fun FStar.Preorder.preorder (Term) Term)

(declare-fun FStar.Preorder.preorder@tok () Term)
(declare-fun Tm_refine_bd10f09297e0e7dc08314f7d9211801c (Term) Term)
; </end encoding let preorder>

; <Start encoding let stable>

(declare-fun FStar.Preorder.stable (Term Term Term) Term)

(declare-fun Tm_arrow_88036d0811eee3361efd6229bae2556d () Term)
(declare-fun FStar.Preorder.stable@tok () Term)

; </end encoding let stable>

; End Externals for module FStar.Preorder
; Externals for interface FStar.Calc
; <Start encoding val FStar.Calc.calc_chain>
(declare-fun FStar.Calc.calc_chain (Term Term Term Term) Term)
(declare-fun Tm_arrow_10ae2c328e1918eb5ddde4274ac6d32a () Term)
(declare-fun FStar.Calc.calc_chain@tok () Term)
; </end encoding val FStar.Calc.calc_chain>

; <Start encoding let rec calc_chain_related>
(declare-fun FStar.Calc.calc_chain_related (Term Term Term Term) Term)

(declare-fun FStar.Calc.calc_chain_related@tok () Term)
; </end encoding let rec calc_chain_related>

; <Start encoding let calc_chain_compatible>
(declare-fun FStar.Calc.calc_chain_compatible (Term Term Term) Term)
(declare-fun Tm_arrow_5d25af94b872513cc464e94bbc6a8348 () Term)
(declare-fun FStar.Calc.calc_chain_compatible@tok () Term)
; </end encoding let calc_chain_compatible>

; <Start encoding let calc_pack>
(declare-fun FStar.Calc.calc_pack (Term Term Term Term) Term)

(declare-fun FStar.Calc.calc_pack@tok () Term)
; </end encoding let calc_pack>

; <Start encoding val FStar.Calc.calc_init>
(declare-fun FStar.Calc.calc_init (Term Term) Term)
(declare-fun Tm_arrow_f5787f683bb2167ab433229a103fa97e () Term)
(declare-fun FStar.Calc.calc_init@tok () Term)
; </end encoding val FStar.Calc.calc_init>

; <Start encoding val FStar.Calc.calc_step>
(declare-fun Tm_arrow_cfbfcb3d713af6cfef9741902fbd7eae (Term Term Term Term) Term)
(declare-fun Tm_arrow_924fe8a596e8d1052263cdb50ea0b3f9 (Term Term Term) Term)
(declare-fun FStar.Calc.calc_step (Term Term Term Term Term Term Term Term) Term)


(declare-fun Tm_arrow_c19042f2eb54c518b0ae4e8fbbb1b795 () Term)
(declare-fun FStar.Calc.calc_step@tok () Term)
; </end encoding val FStar.Calc.calc_step>

; <Start encoding val FStar.Calc.calc_finish>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Calc.calc_finish (Term Term Term Term Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Calc.calc_finish@tok () Term)
; </end encoding val FStar.Calc.calc_finish>

; <Start encoding val FStar.Calc.calc_push_impl>
(declare-fun Tm_arrow_9d84457d1c8d2a3cb1cecf47a390b833 (Term Term) Term)
(declare-fun FStar.Calc.calc_push_impl (Term Term Term) Term)

(declare-fun Tm_refine_913239c2cf9dc8a14e1f047e0206138d (Term Term) Term)
(declare-fun Tm_arrow_8e288ee6e01162bc0e93f91b1d4ccf81 () Term)
(declare-fun FStar.Calc.calc_push_impl@tok () Term)

; </end encoding val FStar.Calc.calc_push_impl>

; End Externals for interface FStar.Calc
; Externals for module FStar.Mul
; <Start encoding let op_Star>
(declare-fun FStar.Mul.op_Star (Term Term) Term)

(declare-fun FStar.Mul.op_Star@tok () Term)
; </end encoding let op_Star>

; End Externals for module FStar.Mul
; Externals for module FStar.Math.Lib
; <Skipped val FStar.Math.Lib.lemma_div_def/>

; <Start encoding let lemma_div_def>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lib.lemma_div_def (Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lib.lemma_div_def@tok () Term)
; </end encoding let lemma_div_def>

; <Start encoding let mul_lemma>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lib.mul_lemma (Term Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lib.mul_lemma@tok () Term)
; </end encoding let mul_lemma>

; <Start encoding let mul_lemma'>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lib.mul_lemma_ (Term Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lib.mul_lemma_@tok () Term)
; </end encoding let mul_lemma'>

; <Start encoding let mul_div_lemma>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lib.mul_div_lemma (Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lib.mul_div_lemma@tok () Term)
; </end encoding let mul_div_lemma>

; <Skipped val FStar.Math.Lib.slash_decr_axiom/>

; <Start encoding let slash_decr_axiom>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lib.slash_decr_axiom (Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lib.slash_decr_axiom@tok () Term)
; </end encoding let slash_decr_axiom>

; <Start encoding let lemma_mul_minus_distr_l>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lib.lemma_mul_minus_distr_l (Term Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lib.lemma_mul_minus_distr_l@tok () Term)
; </end encoding let lemma_mul_minus_distr_l>

; <Skipped #reset-options "--z3rlimit 30"/>

; <Skipped val FStar.Math.Lib.slash_star_axiom/>

; <Start encoding let slash_star_axiom>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lib.slash_star_axiom (Term Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lib.slash_star_axiom@tok () Term)
; </end encoding let slash_star_axiom>

; <Skipped #reset-options/>

; <Skipped val FStar.Math.Lib.log_2/>

; <Start encoding let rec log_2>
; Fuel-instrumented function name
(declare-fun FStar.Math.Lib.log_2.fuel_instrumented (Fuel Term) Term)
; Token for fuel-instrumented partial applications
(declare-fun FStar.Math.Lib.log_2.fuel_instrumented_token () Term)
(declare-fun FStar.Math.Lib.log_2 (Term) Term)
(declare-fun FStar.Math.Lib.log_2@tok () Term)
(declare-fun Tm_arrow_195a91d0390990c5da9b9b2c7b2e9a5f () Term)
; </end encoding let rec log_2>

; <Skipped val FStar.Math.Lib.powx/>

; <Start encoding let rec powx>
; Fuel-instrumented function name
(declare-fun FStar.Math.Lib.powx.fuel_instrumented (Fuel Term Term) Term)
; Token for fuel-instrumented partial applications
(declare-fun FStar.Math.Lib.powx.fuel_instrumented_token () Term)
(declare-fun FStar.Math.Lib.powx (Term Term) Term)
(declare-fun FStar.Math.Lib.powx@tok () Term)
(declare-fun Tm_arrow_97e79e8898be25d1baac7492eb8157a8 () Term)
; </end encoding let rec powx>

; <Skipped val FStar.Math.Lib.abs/>

; <Start encoding let abs>
(declare-fun FStar.Math.Lib.abs (Term) Term)
(declare-fun Tm_refine_5b706f1316bc4c0722dc2171363a324f (Term) Term)
(declare-fun Tm_arrow_485462bf1365ac4f0407149110b772cd () Term)
(declare-fun FStar.Math.Lib.abs@tok () Term)

; </end encoding let abs>

; <Skipped val FStar.Math.Lib.max/>

; <Start encoding let max>
(declare-fun FStar.Math.Lib.max (Term Term) Term)
(declare-fun Tm_refine_3b1de445e68d5a7cbfc9e637b6d5fe5c (Term Term) Term)
(declare-fun Tm_arrow_6cac7a49c19aab6d14a44dce4ddd50d7 () Term)
(declare-fun FStar.Math.Lib.max@tok () Term)

; </end encoding let max>

; <Skipped val FStar.Math.Lib.min/>

; <Start encoding let min>
(declare-fun FStar.Math.Lib.min (Term Term) Term)
(declare-fun Tm_refine_75a39246caf92bd7ba0c54b533ac97ba (Term Term) Term)
(declare-fun Tm_arrow_f1c63d0f3ff3d4c0a4e173563f61a3ec () Term)
(declare-fun FStar.Math.Lib.min@tok () Term)

; </end encoding let min>

; <Skipped val FStar.Math.Lib.div/>

; <Start encoding let div>
(declare-fun FStar.Math.Lib.div (Term Term) Term)
(declare-fun Tm_refine_2a75ac9e9041407930877285ccf479d9 (Term) Term)
(declare-fun Tm_arrow_bb819be7118d7bfb2cedbf3c6477c362 () Term)
(declare-fun FStar.Math.Lib.div@tok () Term)

; </end encoding let div>

; <Skipped val FStar.Math.Lib.div_non_eucl/>

; <Start encoding let div_non_eucl>
(declare-fun FStar.Math.Lib.div_non_eucl (Term Term) Term)
(declare-fun Tm_refine_0ffeb4b35eb66c9dc7f43d49d6f24837 (Term Term) Term)
(declare-fun Tm_arrow_7c4dc753d10246d9d92341a1295260f4 () Term)
(declare-fun FStar.Math.Lib.div_non_eucl@tok () Term)

; </end encoding let div_non_eucl>

; <Skipped val FStar.Math.Lib.shift_left/>

; <Start encoding let shift_left>
(declare-fun FStar.Math.Lib.shift_left (Term Term) Term)
(declare-fun Tm_refine_180a7ec928fc00449a9ff97fd83eb9f7 (Term Term) Term)
(declare-fun Tm_arrow_ebb8ce92eba15a16c00c7e434e88c84b () Term)
(declare-fun FStar.Math.Lib.shift_left@tok () Term)

; </end encoding let shift_left>

; <Skipped val FStar.Math.Lib.arithmetic_shift_right/>

; <Start encoding let arithmetic_shift_right>
(declare-fun FStar.Math.Lib.arithmetic_shift_right (Term Term) Term)
(declare-fun Tm_refine_1b8188dd620bafffed7e311591823814 (Term Term) Term)
(declare-fun Tm_arrow_0d2ab070c39795db6825f9a2ab12fa9a () Term)
(declare-fun FStar.Math.Lib.arithmetic_shift_right@tok () Term)

; </end encoding let arithmetic_shift_right>

; <Skipped val FStar.Math.Lib.signed_modulo/>

; <Start encoding let signed_modulo>
(declare-fun FStar.Math.Lib.signed_modulo (Term Term) Term)
(declare-fun Tm_refine_7f910f581ef6c422e545ac01d1c8b2f5 (Term Term) Term)
(declare-fun Tm_arrow_735d78cef45a99c351b2596c50444f63 () Term)
(declare-fun FStar.Math.Lib.signed_modulo@tok () Term)

; </end encoding let signed_modulo>

; <Skipped val FStar.Math.Lib.op_Plus_Percent/>

; <Start encoding let op_Plus_Percent>
(declare-fun FStar.Math.Lib.op_Plus_Percent (Term Term) Term)
(declare-fun Tm_refine_d653f98e8ce399d5b7ea191c117fe516 (Term Term) Term)
(declare-fun Tm_arrow_47a9b4ba9fff686aea1b155fa584e4a2 () Term)
(declare-fun FStar.Math.Lib.op_Plus_Percent@tok () Term)

; </end encoding let op_Plus_Percent>

; <Skipped val FStar.Math.Lib.powx_lemma1/>

; <Start encoding let powx_lemma1>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lib.powx_lemma1 (Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lib.powx_lemma1@tok () Term)
; </end encoding let powx_lemma1>

; <Skipped val FStar.Math.Lib.powx_lemma2/>

; <Start encoding let rec powx_lemma2>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lib.powx_lemma2 (Term Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lib.powx_lemma2@tok () Term)
; </end encoding let rec powx_lemma2>

; <Skipped val FStar.Math.Lib.abs_mul_lemma/>

; <Start encoding let abs_mul_lemma>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lib.abs_mul_lemma (Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lib.abs_mul_lemma@tok () Term)
; </end encoding let abs_mul_lemma>

; <Skipped val FStar.Math.Lib.signed_modulo_property/>

; <Start encoding let signed_modulo_property>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lib.signed_modulo_property (Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lib.signed_modulo_property@tok () Term)
; </end encoding let signed_modulo_property>

; <Skipped val FStar.Math.Lib.div_non_eucl_decr_lemma/>

; <Start encoding let div_non_eucl_decr_lemma>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lib.div_non_eucl_decr_lemma (Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lib.div_non_eucl_decr_lemma@tok () Term)
; </end encoding let div_non_eucl_decr_lemma>

; <Skipped val FStar.Math.Lib.div_non_eucl_bigger_denom_lemma/>

; <Start encoding let div_non_eucl_bigger_denom_lemma>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lib.div_non_eucl_bigger_denom_lemma (Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lib.div_non_eucl_bigger_denom_lemma@tok () Term)
; </end encoding let div_non_eucl_bigger_denom_lemma>

; End Externals for module FStar.Math.Lib
(push) ;; push{1
; Internals for FStar.Math.Lemmas
; encoding sigelt #set-options "--fuel 0 --ifuel 0"
; <Skipped #set-options "--fuel 0 --ifuel 0"/>

; function token typing
;;; Fact-ids: Name Prims.__cache_version_number__; Namespace Prims
(assert
 (! (HasType Prims.__cache_version_number__ Prims.int)
  :named function_token_typing_Prims.__cache_version_number__))
; Range_const typing
;;; Fact-ids: Name FStar.Range.range; Namespace FStar.Range
(assert
 (! (HasTypeZ (Range_const 1) FStar.Range.range) :named typing_range_const))
; unit typing
;;; Fact-ids: Name Prims.unit; Namespace Prims
(assert
 (! (HasType Tm_unit Prims.unit) :named unit_typing))
; unit inversion
;;; Fact-ids: Name Prims.unit; Namespace Prims
(assert
 (! (forall ((@u0 Fuel) (@x1 Term))
   (! (implies (HasTypeFuel @u0 @x1 Prims.unit) (= @x1 Tm_unit))
    :pattern ((HasTypeFuel @u0 @x1 Prims.unit))
    :qid unit_inversion))
  :named unit_inversion))
; free var typing
;;; Fact-ids: Name Prims.unit; Namespace Prims
(assert
 (! (HasType Prims.unit Prims.eqtype) :named typing_Prims.unit))
; free var typing
;;; Fact-ids: Name Prims.subtype_of; Namespace Prims
(assert
 (! ;; def=Prims.fst(299,4-299,14); use=Prims.fst(299,4-299,14)
  (forall ((@x0 Term) (@x1 Term))
   (! (implies
     (and (HasType @x0 Tm_type) (HasType @x1 Tm_type))
     (HasType (Prims.subtype_of @x0 @x1) Prims.logical))
    :pattern ((Prims.subtype_of @x0 @x1))
    :qid typing_Prims.subtype_of))
  :named typing_Prims.subtype_of))
; free var typing
;;; Fact-ids: Name Prims.pos; Namespace Prims
(assert
 (! (HasType Prims.pos Tm_type) :named typing_Prims.pos))
; free var typing
;;; Fact-ids: Name Prims.logical; Namespace Prims
(assert
 (! (HasType Prims.logical Tm_type) :named typing_Prims.logical))
; free var typing
;;; Fact-ids: Name Prims.int; Namespace Prims
(assert
 (! (HasType Prims.int Prims.eqtype) :named typing_Prims.int))
; free var typing
;;; Fact-ids: Name Prims.hasEq; Namespace Prims
(assert
 (! ;; def=Prims.fst(77,5-77,10); use=Prims.fst(77,5-77,10)
  (forall ((@x0 Term))
   (! (implies (HasType @x0 Tm_type) (HasType (Prims.hasEq @x0) Tm_type))
    :pattern ((Prims.hasEq @x0))
    :qid typing_Prims.hasEq))
  :named typing_Prims.hasEq))
; free var typing
;;; Fact-ids: Name Prims.eqtype; Namespace Prims
(assert
 (! (HasType Prims.eqtype Tm_type) :named typing_Prims.eqtype))
; refinement kinding
;;; Fact-ids: Name FStar.Pervasives.false_elim; Namespace FStar.Pervasives
(assert
 (! (HasType Tm_refine_f1ecc6ab6882a651504f328937700647 Tm_type)
  :named refinement_kinding_Tm_refine_f1ecc6ab6882a651504f328937700647))
; refinement kinding
;;; Fact-ids: Name Prims.pos; Namespace Prims
(assert
 (! (HasType Tm_refine_774ba3f728d91ead8ef40be66c9802e5 Tm_type)
  :named refinement_kinding_Tm_refine_774ba3f728d91ead8ef40be66c9802e5))
; refinement kinding
;;; Fact-ids: Name Prims.prop; Namespace Prims
(assert
 (! (HasType Tm_refine_73f210ca6e0061ed4a3150f69b8f33bf Tm_type)
  :named refinement_kinding_Tm_refine_73f210ca6e0061ed4a3150f69b8f33bf))
; refinement kinding
;;; Fact-ids: Name Prims.nat; Namespace Prims
(assert
 (! (HasType Tm_refine_542f9d4f129664613f2483a6c88bc7c2 Tm_type)
  :named refinement_kinding_Tm_refine_542f9d4f129664613f2483a6c88bc7c2))
; refinement kinding
;;; Fact-ids: Name Prims.eqtype; Namespace Prims
(assert
 (! (HasType Tm_refine_414d0a9f578ab0048252f8c8f552b99f Tm_type)
  :named refinement_kinding_Tm_refine_414d0a9f578ab0048252f8c8f552b99f))
; refinement kinding
;;; Fact-ids: Name Prims.nonzero; Namespace Prims
(assert
 (! (HasType Tm_refine_0766302b68bb44ab7aff8c4d8be0b46f Tm_type)
  :named refinement_kinding_Tm_refine_0766302b68bb44ab7aff8c4d8be0b46f))
; refinement_interpretation
;;; Fact-ids: Name FStar.Pervasives.false_elim; Namespace FStar.Pervasives
(assert
 (! ;; def=FStar.Pervasives.fsti(623,26-623,42); use=FStar.Pervasives.fsti(623,26-623,42)
  (forall ((@u0 Fuel) (@x1 Term))
   (! (iff (HasTypeFuel @u0 @x1 Tm_refine_f1ecc6ab6882a651504f328937700647) false)
    :pattern ((HasTypeFuel @u0 @x1 Tm_refine_f1ecc6ab6882a651504f328937700647))
    :qid refinement_interpretation_Tm_refine_f1ecc6ab6882a651504f328937700647))
  :named refinement_interpretation_Tm_refine_f1ecc6ab6882a651504f328937700647))
; refinement_interpretation
;;; Fact-ids: Name Prims.pos; Namespace Prims
(assert
 (! ;; def=Prims.fst(685,11-685,24); use=Prims.fst(685,11-685,24)
  (forall ((@u0 Fuel) (@x1 Term))
   (! (iff
     (HasTypeFuel @u0 @x1 Tm_refine_774ba3f728d91ead8ef40be66c9802e5)
     (and
      (HasTypeFuel @u0 @x1 Prims.int)
      ;; def=Prims.fst(685,18-685,23); use=Prims.fst(685,18-685,23)
      (> (BoxInt_proj_0 @x1) (BoxInt_proj_0 (BoxInt 0)))))
    :pattern ((HasTypeFuel @u0 @x1 Tm_refine_774ba3f728d91ead8ef40be66c9802e5))
    :qid refinement_interpretation_Tm_refine_774ba3f728d91ead8ef40be66c9802e5))
  :named refinement_interpretation_Tm_refine_774ba3f728d91ead8ef40be66c9802e5))
; refinement_interpretation
;;; Fact-ids: Name Prims.prop; Namespace Prims
(assert
 (! ;; def=Prims.fst(312,12-312,41); use=Prims.fst(312,12-312,41)
  (forall ((@u0 Fuel) (@x1 Term))
   (! (iff
     (HasTypeFuel @u0 @x1 Tm_refine_73f210ca6e0061ed4a3150f69b8f33bf)
     (and
      (HasTypeFuel @u0 @x1 Tm_type)
      ;; def=Prims.fst(312,21-312,40); use=Prims.fst(312,21-312,40)
      (Valid
       ;; def=Prims.fst(312,21-312,40); use=Prims.fst(312,21-312,40)
       (Prims.subtype_of @x1 Prims.unit))))
    :pattern ((HasTypeFuel @u0 @x1 Tm_refine_73f210ca6e0061ed4a3150f69b8f33bf))
    :qid refinement_interpretation_Tm_refine_73f210ca6e0061ed4a3150f69b8f33bf))
  :named refinement_interpretation_Tm_refine_73f210ca6e0061ed4a3150f69b8f33bf))
; refinement_interpretation
;;; Fact-ids: Name Prims.nat; Namespace Prims
(assert
 (! ;; def=Prims.fst(682,11-682,25); use=Prims.fst(682,11-682,25)
  (forall ((@u0 Fuel) (@x1 Term))
   (! (iff
     (HasTypeFuel @u0 @x1 Tm_refine_542f9d4f129664613f2483a6c88bc7c2)
     (and
      (HasTypeFuel @u0 @x1 Prims.int)
      ;; def=Prims.fst(682,18-682,24); use=Prims.fst(682,18-682,24)
      (>= (BoxInt_proj_0 @x1) (BoxInt_proj_0 (BoxInt 0)))))
    :pattern ((HasTypeFuel @u0 @x1 Tm_refine_542f9d4f129664613f2483a6c88bc7c2))
    :qid refinement_interpretation_Tm_refine_542f9d4f129664613f2483a6c88bc7c2))
  :named refinement_interpretation_Tm_refine_542f9d4f129664613f2483a6c88bc7c2))
; refinement_interpretation
;;; Fact-ids: Name Prims.eqtype; Namespace Prims
(assert
 (! ;; def=Prims.fst(81,14-81,31); use=Prims.fst(81,14-81,31)
  (forall ((@u0 Fuel) (@x1 Term))
   (! (iff
     (HasTypeFuel @u0 @x1 Tm_refine_414d0a9f578ab0048252f8c8f552b99f)
     (and
      (HasTypeFuel @u0 @x1 Tm_type)
      ;; def=Prims.fst(81,23-81,30); use=Prims.fst(81,23-81,30)
      (Valid
       ;; def=Prims.fst(81,23-81,30); use=Prims.fst(81,23-81,30)
       (Prims.hasEq @x1))))
    :pattern ((HasTypeFuel @u0 @x1 Tm_refine_414d0a9f578ab0048252f8c8f552b99f))
    :qid refinement_interpretation_Tm_refine_414d0a9f578ab0048252f8c8f552b99f))
  :named refinement_interpretation_Tm_refine_414d0a9f578ab0048252f8c8f552b99f))
; refinement_interpretation
;;; Fact-ids: Name Prims.nonzero; Namespace Prims
(assert
 (! ;; def=Prims.fst(688,15-688,29); use=Prims.fst(688,15-688,29)
  (forall ((@u0 Fuel) (@x1 Term))
   (! (iff
     (HasTypeFuel @u0 @x1 Tm_refine_0766302b68bb44ab7aff8c4d8be0b46f)
     (and
      (HasTypeFuel @u0 @x1 Prims.int)
      ;; def=Prims.fst(688,22-688,28); use=Prims.fst(688,22-688,28)
      (not (= @x1 (BoxInt 0)))))
    :pattern ((HasTypeFuel @u0 @x1 Tm_refine_0766302b68bb44ab7aff8c4d8be0b46f))
    :qid refinement_interpretation_Tm_refine_0766302b68bb44ab7aff8c4d8be0b46f))
  :named refinement_interpretation_Tm_refine_0766302b68bb44ab7aff8c4d8be0b46f))
;;; Fact-ids: Name Prims.op_Subtraction; Namespace Prims
(assert
 (! ;; def=Prims.fst(554,4-554,18); use=Prims.fst(554,4-554,18)
  (forall ((@x0 Term) (@x1 Term))
   (! (= (Prims.op_Subtraction @x0 @x1) (BoxInt (- (BoxInt_proj_0 @x0) (BoxInt_proj_0 @x1))))
    :pattern ((Prims.op_Subtraction @x0 @x1))
    :qid primitive_Prims.op_Subtraction))
  :named primitive_Prims.op_Subtraction))
;;; Fact-ids: Name Prims.op_Multiply; Namespace Prims
(assert
 (! ;; def=Prims.fst(548,4-548,15); use=Prims.fst(548,4-548,15)
  (forall ((@x0 Term) (@x1 Term))
   (! (= (Prims.op_Multiply @x0 @x1) (BoxInt (* (BoxInt_proj_0 @x0) (BoxInt_proj_0 @x1))))
    :pattern ((Prims.op_Multiply @x0 @x1))
    :qid primitive_Prims.op_Multiply))
  :named primitive_Prims.op_Multiply))
;;; Fact-ids: Name Prims.op_Division; Namespace Prims
(assert
 (! ;; def=Prims.fst(705,4-705,15); use=Prims.fst(705,4-705,15)
  (forall ((@x0 Term) (@x1 Term))
   (! (implies
     (not (= (BoxInt_proj_0 @x1) 0))
     (= (Prims.op_Division @x0 @x1) (BoxInt (div (BoxInt_proj_0 @x0) (BoxInt_proj_0 @x1)))))
    :pattern ((Prims.op_Division @x0 @x1))
    :qid primitive_Prims.op_Division))
  :named primitive_Prims.op_Division))
; int typing
;;; Fact-ids: Name Prims.int; Namespace Prims
(assert
 (! (forall ((@u0 Int)) (! (HasType (BoxInt @u0) Prims.int) :pattern ((BoxInt @u0)) :qid int_typing))
  :named int_typing))
; int inversion
;;; Fact-ids: Name Prims.int; Namespace Prims
(assert
 (! (forall ((@u0 Fuel) (@x1 Term))
   (! (implies (HasTypeFuel @u0 @x1 Prims.int) (is-BoxInt @x1))
    :pattern ((HasTypeFuel @u0 @x1 Prims.int))
    :qid int_inversion))
  :named int_inversion))
; haseq for Tm_refine_f1ecc6ab6882a651504f328937700647
;;; Fact-ids: Name FStar.Pervasives.false_elim; Namespace FStar.Pervasives
(assert
 (! (iff
   (Valid (Prims.hasEq Tm_refine_f1ecc6ab6882a651504f328937700647))
   (Valid (Prims.hasEq Prims.unit)))
  :named haseqTm_refine_f1ecc6ab6882a651504f328937700647))
; haseq for Tm_refine_774ba3f728d91ead8ef40be66c9802e5
;;; Fact-ids: Name Prims.pos; Namespace Prims
(assert
 (! (iff
   (Valid (Prims.hasEq Tm_refine_774ba3f728d91ead8ef40be66c9802e5))
   (Valid (Prims.hasEq Prims.int)))
  :named haseqTm_refine_774ba3f728d91ead8ef40be66c9802e5))
; haseq for Tm_refine_73f210ca6e0061ed4a3150f69b8f33bf
;;; Fact-ids: Name Prims.prop; Namespace Prims
(assert
 (! (iff
   (Valid (Prims.hasEq Tm_refine_73f210ca6e0061ed4a3150f69b8f33bf))
   (Valid (Prims.hasEq Tm_type)))
  :named haseqTm_refine_73f210ca6e0061ed4a3150f69b8f33bf))
; haseq for Tm_refine_542f9d4f129664613f2483a6c88bc7c2
;;; Fact-ids: Name Prims.nat; Namespace Prims
(assert
 (! (iff
   (Valid (Prims.hasEq Tm_refine_542f9d4f129664613f2483a6c88bc7c2))
   (Valid (Prims.hasEq Prims.int)))
  :named haseqTm_refine_542f9d4f129664613f2483a6c88bc7c2))
; haseq for Tm_refine_414d0a9f578ab0048252f8c8f552b99f
;;; Fact-ids: Name Prims.eqtype; Namespace Prims
(assert
 (! (iff
   (Valid (Prims.hasEq Tm_refine_414d0a9f578ab0048252f8c8f552b99f))
   (Valid (Prims.hasEq Tm_type)))
  :named haseqTm_refine_414d0a9f578ab0048252f8c8f552b99f))
; haseq for Tm_refine_0766302b68bb44ab7aff8c4d8be0b46f
;;; Fact-ids: Name Prims.nonzero; Namespace Prims
(assert
 (! (iff
   (Valid (Prims.hasEq Tm_refine_0766302b68bb44ab7aff8c4d8be0b46f))
   (Valid (Prims.hasEq Prims.int)))
  :named haseqTm_refine_0766302b68bb44ab7aff8c4d8be0b46f))
; function token typing
;;; Fact-ids: Name Prims.unit; Namespace Prims
(assert
 (! (HasType Prims.unit Prims.eqtype) :named function_token_typing_Prims.unit))
; function token typing
;;; Fact-ids: Name Prims.pos; Namespace Prims
(assert
 (! (HasType Prims.pos Tm_type) :named function_token_typing_Prims.pos))
; function token typing
;;; Fact-ids: Name Prims.logical; Namespace Prims
(assert
 (! (HasType Prims.logical Tm_type) :named function_token_typing_Prims.logical))
; function token typing
;;; Fact-ids: Name Prims.int; Namespace Prims
(assert
 (! (HasType Prims.int Prims.eqtype) :named function_token_typing_Prims.int))
; function token typing
;;; Fact-ids: Name Prims.eqtype; Namespace Prims
(assert
 (! (HasType Prims.eqtype Tm_type) :named function_token_typing_Prims.eqtype))
; Equation for Prims.subtype_of
;;; Fact-ids: Name Prims.subtype_of; Namespace Prims
(assert
 (! ;; def=Prims.fst(299,4-299,14); use=Prims.fst(299,4-299,14)
  (forall ((@x0 Term) (@x1 Term))
   (! (=
     (Valid (Prims.subtype_of @x0 @x1))
     ;; def=Prims.fst(299,31-299,60); use=Prims.fst(299,31-299,60)
     (forall ((@x2 Term))
      (! (implies (HasType @x2 @x0) (HasType @x2 @x1)) :qid equation_Prims.subtype_of.1)))
    :pattern ((Prims.subtype_of @x0 @x1))
    :qid equation_Prims.subtype_of))
  :named equation_Prims.subtype_of))
; Equation for Prims.pos
;;; Fact-ids: Name Prims.pos; Namespace Prims
(assert
 (! (= Prims.pos Tm_refine_774ba3f728d91ead8ef40be66c9802e5) :named equation_Prims.pos))
; Equation for Prims.logical
;;; Fact-ids: Name Prims.logical; Namespace Prims
(assert
 (! (= Prims.logical Tm_type) :named equation_Prims.logical))
; Equation for Prims.eqtype
;;; Fact-ids: Name Prims.eqtype; Namespace Prims
(assert
 (! (= Prims.eqtype Tm_refine_414d0a9f578ab0048252f8c8f552b99f) :named equation_Prims.eqtype))
; Prop-typing for Prims.subtype_of
;;; Fact-ids: Name Prims.subtype_of; Namespace Prims
(assert
 (! ;; def=Prims.fst(299,4-299,14); use=Prims.fst(299,4-299,14)
  (forall ((@x0 Term) (@x1 Term))
   (! (implies
     (and (HasType @x0 Tm_type) (HasType @x1 Tm_type))
     (Valid (Prims.subtype_of (Prims.subtype_of @x0 @x1) Prims.unit)))
    :pattern ((Prims.subtype_of (Prims.subtype_of @x0 @x1) Prims.unit))
    :qid defn_equation_Prims.subtype_of))
  :named defn_equation_Prims.subtype_of))
; Constructor distinct
;;; Fact-ids: Name Prims.unit; Namespace Prims
(assert
 (! (= 125 (Term_constr_id Prims.unit)) :named constructor_distinct_Prims.unit))
; Constructor distinct
;;; Fact-ids: Name Prims.int; Namespace Prims
(assert
 (! (= 303 (Term_constr_id Prims.int)) :named constructor_distinct_Prims.int))
; pretyping
;;; Fact-ids: Name Prims.unit; Namespace Prims
(assert
 (! ;; def=Prims.fst(104,5-104,9); use=Prims.fst(104,5-104,9)
  (forall ((@x0 Term) (@u1 Fuel))
   (! (implies (HasTypeFuel @u1 @x0 Prims.unit) (= Prims.unit (PreType @x0)))
    :pattern ((HasTypeFuel @u1 @x0 Prims.unit))
    :qid Prims_pretyping_f8666440faa91836cc5a13998af863fc))
  :named Prims_pretyping_f8666440faa91836cc5a13998af863fc))
; pretyping
;;; Fact-ids: Name Prims.int; Namespace Prims
(assert
 (! ;; def=Prims.fst(522,5-522,8); use=Prims.fst(522,5-522,8)
  (forall ((@x0 Term) (@u1 Fuel))
   (! (implies (HasTypeFuel @u1 @x0 Prims.int) (= Prims.int (PreType @x0)))
    :pattern ((HasTypeFuel @u1 @x0 Prims.int))
    :qid Prims_pretyping_ae567c2fb75be05905677af440075565))
  :named Prims_pretyping_ae567c2fb75be05905677af440075565))
(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fsti(21,0-22,47)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
(declare-fun Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9 () Term)
; refinement kinding
;;; Fact-ids: 
(assert
 (! (HasType Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9 Tm_type)
  :named refinement_kinding_Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
; refinement_interpretation
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fsti(21,43-22,47); use=FStar.Math.Lemmas.fsti(21,43-21,48)
  (forall ((@u0 Fuel) (@x1 Term))
   (! (iff
     (HasTypeFuel @u0 @x1 Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9)
     (HasTypeFuel @u0 @x1 Prims.unit))
    :pattern ((HasTypeFuel @u0 @x1 Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
    :qid refinement_interpretation_Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
  :named refinement_interpretation_Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
; haseq for Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9
;;; Fact-ids: 
(assert
 (! (iff
   (Valid (Prims.hasEq Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
   (Valid (Prims.hasEq Prims.unit)))
  :named haseqTm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
; Encoding query formula : forall (a: Prims.int) (b: Prims.pos) (_: Prims.squash Prims.l_True).
;   (*  - Could not prove post-condition
; *)
;   (b > 0 ==> b <> 0) /\ (a - b * (a / b) >= 0 ==> b > 0 ==> b <> 0)
; Context: While encoding a query
; While typechecking the top-level declaration `val FStar.Math.Lemmas.euclidean_div_axiom`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fsti(21,0-22,47)
   (forall ((@x0 Term) (@x1 Term) (@x2 Term))
    (! (implies
      (and
       (HasType @x0 Prims.int)
       (HasType @x1 Prims.pos)
       (HasType @x2 Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
      ;; def=FStar.Math.Lemmas.fsti(21,34-22,23); use=FStar.Math.Lemmas.fsti(22,3-22,41)
      (and
       (implies
        ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fsti(22,16-22,17)
        (> (BoxInt_proj_0 @x1) (BoxInt_proj_0 (BoxInt 0)))
        ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fsti(22,16-22,17)
        (or
         label_1
         ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fsti(22,16-22,17)
         (not (= @x1 (BoxInt 0)))))
       (implies
        (and
         ;; def=FStar.Math.Lemmas.fsti(22,3-22,23); use=FStar.Math.Lemmas.fsti(22,3-22,23)
         (>=
          (BoxInt_proj_0
           (Prims.op_Subtraction @x0 (Prims.op_Multiply @x1 (Prims.op_Division @x0 @x1))))
          (BoxInt_proj_0 (BoxInt 0)))
         ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fsti(22,40-22,41)
         (> (BoxInt_proj_0 @x1) (BoxInt_proj_0 (BoxInt 0))))
        ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fsti(22,40-22,41)
        (or
         label_2
         ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fsti(22,40-22,41)
         (not (= @x1 (BoxInt 0)))))))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.euclidean_div_axiom, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt val FStar.Math.Lemmas.euclidean_div_axiom
; <Skipped val FStar.Math.Lemmas.euclidean_div_axiom/>

; typing for data constructor proxy
;;; Fact-ids: Name Prims.trivial; Namespace Prims; Name Prims.T; Namespace Prims
(assert
 (! (HasType Prims.T@tok Prims.trivial) :named typing_tok_Prims.T@tok))
; free var typing
;;; Fact-ids: Name Prims.squash; Namespace Prims
(assert
 (! ;; def=Prims.fst(125,5-125,11); use=Prims.fst(125,5-125,11)
  (forall ((@x0 Term))
   (! (implies (HasType @x0 Tm_type) (HasType (Prims.squash @x0) Tm_type))
    :pattern ((Prims.squash @x0))
    :qid typing_Prims.squash))
  :named typing_Prims.squash))
; free var typing
;;; Fact-ids: Name Prims.pure_post'; Namespace Prims
(assert
 (! ;; def=Prims.fst(323,4-323,14); use=Prims.fst(323,4-323,14)
  (forall ((@x0 Term) (@x1 Term))
   (! (implies
     (and (HasType @x0 Tm_type) (HasType @x1 Tm_type))
     (HasType (Prims.pure_post_ @x0 @x1) Tm_type))
    :pattern ((Prims.pure_post_ @x0 @x1))
    :qid typing_Prims.pure_post_))
  :named typing_Prims.pure_post_))
; free var typing
;;; Fact-ids: Name Prims.pure_post; Namespace Prims
(assert
 (! ;; def=Prims.fst(324,4-324,13); use=Prims.fst(324,4-324,13)
  (forall ((@x0 Term))
   (! (implies (HasType @x0 Tm_type) (HasType (Prims.pure_post @x0) Tm_type))
    :pattern ((Prims.pure_post @x0))
    :qid typing_Prims.pure_post))
  :named typing_Prims.pure_post))
; free var typing
;;; Fact-ids: Name Prims.l_True; Namespace Prims
(assert
 (! (HasType Prims.l_True Prims.logical) :named typing_Prims.l_True))
; True interpretation
;;; Fact-ids: Name Prims.l_True; Namespace Prims
(assert (! (Valid Prims.l_True) :named true_interp))
; refinement kinding
;;; Fact-ids: Name Prims.pure_post'; Namespace Prims
(assert
 (! ;; def=Prims.fst(323,31-323,40); use=Prims.fst(323,31-323,40)
  (forall ((@x0 Term) (@x1 Term))
   (! (HasType (Tm_refine_8d65e998a07dd53ec478e27017d9dba5 @x0 @x1) Tm_type)
    :pattern ((HasType (Tm_refine_8d65e998a07dd53ec478e27017d9dba5 @x0 @x1) Tm_type))
    :qid refinement_kinding_Tm_refine_8d65e998a07dd53ec478e27017d9dba5))
  :named refinement_kinding_Tm_refine_8d65e998a07dd53ec478e27017d9dba5))
; refinement kinding
;;; Fact-ids: Name Prims.squash; Namespace Prims
(assert
 (! ;; def=Prims.fst(125,32-125,42); use=Prims.fst(125,32-125,42)
  (forall ((@x0 Term))
   (! (HasType (Tm_refine_2de20c066034c13bf76e9c0b94f4806c @x0) Tm_type)
    :pattern ((HasType (Tm_refine_2de20c066034c13bf76e9c0b94f4806c @x0) Tm_type))
    :qid refinement_kinding_Tm_refine_2de20c066034c13bf76e9c0b94f4806c))
  :named refinement_kinding_Tm_refine_2de20c066034c13bf76e9c0b94f4806c))
; refinement_interpretation
;;; Fact-ids: Name Prims.pure_post'; Namespace Prims
(assert
 (! ;; def=Prims.fst(323,31-323,40); use=Prims.fst(323,31-323,40)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
   (! (iff
     (HasTypeFuel @u0 @x1 (Tm_refine_8d65e998a07dd53ec478e27017d9dba5 @x2 @x3))
     (and
      (HasTypeFuel @u0 @x1 @x2)
      ;; def=Prims.fst(323,18-323,21); use=Prims.fst(323,36-323,39)
      (Valid
       ;; def=Prims.fst(323,18-323,21); use=Prims.fst(323,36-323,39)
       @x3)))
    :pattern ((HasTypeFuel @u0 @x1 (Tm_refine_8d65e998a07dd53ec478e27017d9dba5 @x2 @x3)))
    :qid refinement_interpretation_Tm_refine_8d65e998a07dd53ec478e27017d9dba5))
  :named refinement_interpretation_Tm_refine_8d65e998a07dd53ec478e27017d9dba5))
; refinement_interpretation
;;; Fact-ids: Name Prims.squash; Namespace Prims
(assert
 (! ;; def=Prims.fst(125,32-125,42); use=Prims.fst(125,32-125,42)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
   (! (iff
     (HasTypeFuel @u0 @x1 (Tm_refine_2de20c066034c13bf76e9c0b94f4806c @x2))
     (and
      (HasTypeFuel @u0 @x1 Prims.unit)
      ;; def=Prims.fst(125,13-125,14); use=Prims.fst(125,40-125,41)
      (Valid
       ;; def=Prims.fst(125,13-125,14); use=Prims.fst(125,40-125,41)
       @x2)))
    :pattern ((HasTypeFuel @u0 @x1 (Tm_refine_2de20c066034c13bf76e9c0b94f4806c @x2)))
    :qid refinement_interpretation_Tm_refine_2de20c066034c13bf76e9c0b94f4806c))
  :named refinement_interpretation_Tm_refine_2de20c066034c13bf76e9c0b94f4806c))
; kinding_Tm_arrow_92458cff82f9ffee1f6e26a1c0c579f3
;;; Fact-ids: Name Prims.pure_post'; Namespace Prims
(assert
 (! ;; def=Prims.fst(323,31-323,54); use=Prims.fst(323,31-323,54)
  (forall ((@x0 Term) (@x1 Term))
   (! (HasType (Tm_arrow_92458cff82f9ffee1f6e26a1c0c579f3 @x0 @x1) Tm_type)
    :pattern ((HasType (Tm_arrow_92458cff82f9ffee1f6e26a1c0c579f3 @x0 @x1) Tm_type))
    :qid kinding_Tm_arrow_92458cff82f9ffee1f6e26a1c0c579f3))
  :named kinding_Tm_arrow_92458cff82f9ffee1f6e26a1c0c579f3))
;;; Fact-ids: Name Prims.trivial; Namespace Prims; Name Prims.T; Namespace Prims
(assert
 (! (HasType Prims.trivial Tm_type) :named kinding_Prims.trivial@tok))
; haseq for Tm_refine_8d65e998a07dd53ec478e27017d9dba5
;;; Fact-ids: Name Prims.pure_post'; Namespace Prims
(assert
 (! ;; def=Prims.fst(323,31-323,40); use=Prims.fst(323,31-323,40)
  (forall ((@x0 Term) (@x1 Term))
   (! (iff
     (Valid (Prims.hasEq (Tm_refine_8d65e998a07dd53ec478e27017d9dba5 @x0 @x1)))
     (Valid (Prims.hasEq @x0)))
    :pattern ((Valid (Prims.hasEq (Tm_refine_8d65e998a07dd53ec478e27017d9dba5 @x0 @x1))))
    :qid haseqTm_refine_8d65e998a07dd53ec478e27017d9dba5))
  :named haseqTm_refine_8d65e998a07dd53ec478e27017d9dba5))
; haseq for Tm_refine_2de20c066034c13bf76e9c0b94f4806c
;;; Fact-ids: Name Prims.squash; Namespace Prims
(assert
 (! ;; def=Prims.fst(125,32-125,42); use=Prims.fst(125,32-125,42)
  (forall ((@x0 Term))
   (! (iff
     (Valid (Prims.hasEq (Tm_refine_2de20c066034c13bf76e9c0b94f4806c @x0)))
     (Valid (Prims.hasEq Prims.unit)))
    :pattern ((Valid (Prims.hasEq (Tm_refine_2de20c066034c13bf76e9c0b94f4806c @x0))))
    :qid haseqTm_refine_2de20c066034c13bf76e9c0b94f4806c))
  :named haseqTm_refine_2de20c066034c13bf76e9c0b94f4806c))
; function token typing
;;; Fact-ids: Name Prims.l_True; Namespace Prims
(assert
 (! (HasType Prims.l_True Prims.logical) :named function_token_typing_Prims.l_True))
; inversion axiom
;;; Fact-ids: Name Prims.trivial; Namespace Prims; Name Prims.T; Namespace Prims
(assert
 (! ;; def=Prims.fst(99,5-99,12); use=Prims.fst(99,5-99,12)
  (forall ((@u0 Fuel) (@x1 Term))
   (! (implies (HasTypeFuel @u0 @x1 Prims.trivial) (is-Prims.T @x1))
    :pattern ((HasTypeFuel @u0 @x1 Prims.trivial))
    :qid fuel_guarded_inversion_Prims.trivial))
  :named fuel_guarded_inversion_Prims.trivial))
; Equation for Prims.squash
;;; Fact-ids: Name Prims.squash; Namespace Prims
(assert
 (! ;; def=Prims.fst(125,5-125,11); use=Prims.fst(125,5-125,11)
  (forall ((@x0 Term))
   (! (= (Prims.squash @x0) (Tm_refine_2de20c066034c13bf76e9c0b94f4806c @x0))
    :pattern ((Prims.squash @x0))
    :qid equation_Prims.squash))
  :named equation_Prims.squash))
; Equation for Prims.pure_post'
;;; Fact-ids: Name Prims.pure_post'; Namespace Prims
(assert
 (! ;; def=Prims.fst(323,4-323,14); use=Prims.fst(323,4-323,14)
  (forall ((@x0 Term) (@x1 Term))
   (! (= (Prims.pure_post_ @x0 @x1) (Tm_arrow_92458cff82f9ffee1f6e26a1c0c579f3 @x1 @x0))
    :pattern ((Prims.pure_post_ @x0 @x1))
    :qid equation_Prims.pure_post_))
  :named equation_Prims.pure_post_))
; Equation for Prims.pure_post
;;; Fact-ids: Name Prims.pure_post; Namespace Prims
(assert
 (! ;; def=Prims.fst(324,4-324,13); use=Prims.fst(324,4-324,13)
  (forall ((@x0 Term))
   (! (= (Prims.pure_post @x0) (Prims.pure_post_ @x0 Prims.l_True))
    :pattern ((Prims.pure_post @x0))
    :qid equation_Prims.pure_post))
  :named equation_Prims.pure_post))
; Equation for Prims.l_True
;;; Fact-ids: Name Prims.l_True; Namespace Prims
(assert
 (! (= Prims.l_True (Prims.squash Prims.trivial)) :named equation_Prims.l_True))
; equality for proxy
;;; Fact-ids: Name Prims.trivial; Namespace Prims; Name Prims.T; Namespace Prims
(assert
 (! (= Prims.T@tok Prims.T) :named equality_tok_Prims.T@tok))
; data constructor typing intro
;;; Fact-ids: Name Prims.trivial; Namespace Prims; Name Prims.T; Namespace Prims
(assert
 (! ;; def=Prims.fst(99,17-99,18); use=Prims.fst(99,17-99,18)
  (forall ((@u0 Fuel))
   (! (HasTypeFuel @u0 Prims.T Prims.trivial)
    :pattern ((HasTypeFuel @u0 Prims.T Prims.trivial))
    :qid data_typing_intro_Prims.T@tok))
  :named data_typing_intro_Prims.T@tok))
; Constructor distinct
;;; Fact-ids: Name Prims.trivial; Namespace Prims; Name Prims.T; Namespace Prims
(assert
 (! (= 116 (Term_constr_id Prims.trivial)) :named constructor_distinct_Prims.trivial))
; Constructor distinct
;;; Fact-ids: Name Prims.trivial; Namespace Prims; Name Prims.T; Namespace Prims
(assert
 (! (= 122 (Term_constr_id Prims.T)) :named constructor_distinct_Prims.T))
; pretyping
;;; Fact-ids: Name Prims.trivial; Namespace Prims; Name Prims.T; Namespace Prims
(assert
 (! ;; def=Prims.fst(99,5-99,12); use=Prims.fst(99,5-99,12)
  (forall ((@x0 Term) (@u1 Fuel))
   (! (implies (HasTypeFuel @u1 @x0 Prims.trivial) (= Prims.trivial (PreType @x0)))
    :pattern ((HasTypeFuel @u1 @x0 Prims.trivial))
    :qid Prims_pretyping_e8ffb7d227a1bbf69407a8d2ad2c4c83))
  :named Prims_pretyping_e8ffb7d227a1bbf69407a8d2ad2c4c83))
; pre-typing for functions
;;; Fact-ids: Name Prims.pure_post'; Namespace Prims
(assert
 (! ;; def=Prims.fst(323,31-323,54); use=Prims.fst(323,31-323,54)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
   (! (implies
     (HasTypeFuel @u0 @x1 (Tm_arrow_92458cff82f9ffee1f6e26a1c0c579f3 @x2 @x3))
     (is-Tm_arrow (PreType @x1)))
    :pattern ((HasTypeFuel @u0 @x1 (Tm_arrow_92458cff82f9ffee1f6e26a1c0c579f3 @x2 @x3)))
    :qid Prims_pre_typing_Tm_arrow_92458cff82f9ffee1f6e26a1c0c579f3))
  :named Prims_pre_typing_Tm_arrow_92458cff82f9ffee1f6e26a1c0c579f3))
; interpretation_Tm_arrow_92458cff82f9ffee1f6e26a1c0c579f3
;;; Fact-ids: Name Prims.pure_post'; Namespace Prims
(assert
 (! ;; def=Prims.fst(323,31-323,54); use=Prims.fst(323,31-323,54)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term))
   (! (iff
     (HasTypeZ @x0 (Tm_arrow_92458cff82f9ffee1f6e26a1c0c579f3 @x1 @x2))
     (and
      ;; def=Prims.fst(323,31-323,54); use=Prims.fst(323,31-323,54)
      (forall ((@x3 Term))
       (! (implies
         (HasType @x3 (Tm_refine_8d65e998a07dd53ec478e27017d9dba5 @x2 @x1))
         (HasType (ApplyTT @x0 @x3) Tm_type))
        :pattern ((ApplyTT @x0 @x3))
        :qid Prims_interpretation_Tm_arrow_92458cff82f9ffee1f6e26a1c0c579f3.1))
      (IsTotFun @x0)))
    :pattern ((HasTypeZ @x0 (Tm_arrow_92458cff82f9ffee1f6e26a1c0c579f3 @x1 @x2)))
    :qid Prims_interpretation_Tm_arrow_92458cff82f9ffee1f6e26a1c0c579f3))
  :named Prims_interpretation_Tm_arrow_92458cff82f9ffee1f6e26a1c0c579f3))
(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(24,30-24,32)
(declare-fun label_3 () Bool)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (a: Prims.int) (b: Prims.pos).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     (forall (pure_result: Prims.unit). a - b * (a / b) >= 0 /\ a - b * (a / b) < b ==> p pure_result
;     ) ==>
;     (forall (any_result: Prims.unit). p any_result)
; Context: While encoding a query
; While typechecking the top-level declaration `let euclidean_div_axiom`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term))
    (! (implies
      (and (HasType @x0 Prims.int) (HasType @x1 Prims.pos))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x2 Term))
       (! (implies
         (and
          (HasType @x2 (Prims.pure_post Prims.unit))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(24,30-24,32)
          (forall ((@x3 Term))
           (! (implies
             (and
              (or label_1 (HasType @x3 Prims.unit))
              ;; def=FStar.Math.Lemmas.fsti(22,3-22,23); use=FStar.Math.Lemmas.fst(24,30-24,32)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fsti(22,3-22,23); use=FStar.Math.Lemmas.fst(24,30-24,32)
               (>=
                (BoxInt_proj_0
                 (Prims.op_Subtraction @x0 (Prims.op_Multiply @x1 (Prims.op_Division @x0 @x1))))
                (BoxInt_proj_0 (BoxInt 0))))
              ;; def=FStar.Math.Lemmas.fsti(22,27-22,46); use=FStar.Math.Lemmas.fst(24,30-24,32)
              (or
               label_3
               ;; def=FStar.Math.Lemmas.fsti(22,27-22,46); use=FStar.Math.Lemmas.fst(24,30-24,32)
               (<
                (BoxInt_proj_0
                 (Prims.op_Subtraction @x0 (Prims.op_Multiply @x1 (Prims.op_Division @x0 @x1))))
                (BoxInt_proj_0 @x1))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(24,30-24,32)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(24,30-24,32)
              (ApplyTT @x2 @x3)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(24,30-24,32)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(24,30-24,32)
               (ApplyTT @x2 @x3)))
            :qid @query.2)))
         ;; def=Prims.fst(459,66-459,102); use=Prims.fst(462,31-462,44)
         (forall ((@x3 Term))
          (! (implies
            (HasType @x3 Prims.unit)
            ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
            (Valid
             ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
             (ApplyTT @x2 @x3)))
           :qid @query.3)))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_3")
(eval label_3)
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.euclidean_div_axiom, 2)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let euclidean_div_axiom
; <Start encoding let euclidean_div_axiom>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.euclidean_div_axiom (Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.euclidean_div_axiom@tok () Term)
; </end encoding let euclidean_div_axiom>

; encoding sigelt val FStar.Math.Lemmas.lemma_eucl_div_bound
; <Skipped val FStar.Math.Lemmas.lemma_eucl_div_bound/>

;;; Fact-ids: Name Prims.op_Addition; Namespace Prims
(assert
 (! ;; def=Prims.fst(560,4-560,15); use=Prims.fst(560,4-560,15)
  (forall ((@x0 Term) (@x1 Term))
   (! (= (Prims.op_Addition @x0 @x1) (BoxInt (+ (BoxInt_proj_0 @x0) (BoxInt_proj_0 @x1))))
    :pattern ((Prims.op_Addition @x0 @x1))
    :qid primitive_Prims.op_Addition))
  :named primitive_Prims.op_Addition))
(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(26,33-26,35)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (a: Prims.int) (b: Prims.int) (q: Prims.int).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     a < q /\ (forall (pure_result: Prims.unit). a + q * b < q * (b + 1) ==> p pure_result) ==>
;     (forall (any_result: Prims.unit). p any_result)
; Context: While encoding a query
; While typechecking the top-level declaration `let lemma_eucl_div_bound`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term) (@x2 Term))
    (! (implies
      (and (HasType @x0 Prims.int) (HasType @x1 Prims.int) (HasType @x2 Prims.int))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x3 Term))
       (! (implies
         (and
          (HasType @x3 (Prims.pure_post Prims.unit))
          ;; def=FStar.Math.Lemmas.fsti(25,12-25,19); use=FStar.Math.Lemmas.fst(26,33-26,35)
          (< (BoxInt_proj_0 @x0) (BoxInt_proj_0 @x2))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(26,33-26,35)
          (forall ((@x4 Term))
           (! (implies
             (and
              (or label_1 (HasType @x4 Prims.unit))
              ;; def=FStar.Math.Lemmas.fsti(26,12-26,35); use=FStar.Math.Lemmas.fst(26,33-26,35)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fsti(26,12-26,35); use=FStar.Math.Lemmas.fst(26,33-26,35)
               (<
                (BoxInt_proj_0 (Prims.op_Addition @x0 (Prims.op_Multiply @x2 @x1)))
                (BoxInt_proj_0 (Prims.op_Multiply @x2 (Prims.op_Addition @x1 (BoxInt 1)))))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(26,33-26,35)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(26,33-26,35)
              (ApplyTT @x3 @x4)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(26,33-26,35)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(26,33-26,35)
               (ApplyTT @x3 @x4)))
            :qid @query.2)))
         ;; def=Prims.fst(459,66-459,102); use=Prims.fst(462,31-462,44)
         (forall ((@x4 Term))
          (! (implies
            (HasType @x4 Prims.unit)
            ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
            (Valid
             ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
             (ApplyTT @x3 @x4)))
           :qid @query.3)))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.lemma_eucl_div_bound, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let lemma_eucl_div_bound
; <Start encoding let lemma_eucl_div_bound>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.lemma_eucl_div_bound (Term Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.lemma_eucl_div_bound@tok () Term)
; </end encoding let lemma_eucl_div_bound>

; encoding sigelt val FStar.Math.Lemmas.lemma_mult_le_left
; <Skipped val FStar.Math.Lemmas.lemma_mult_le_left/>

; free var typing
;;; Fact-ids: Name Prims.nat; Namespace Prims
(assert
 (! (HasType Prims.nat Tm_type) :named typing_Prims.nat))
; function token typing
;;; Fact-ids: Name Prims.nat; Namespace Prims
(assert
 (! (HasType Prims.nat Tm_type) :named function_token_typing_Prims.nat))
; Equation for Prims.nat
;;; Fact-ids: Name Prims.nat; Namespace Prims
(assert
 (! (= Prims.nat Tm_refine_542f9d4f129664613f2483a6c88bc7c2) :named equation_Prims.nat))
(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(28,31-28,33)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (a: Prims.nat) (b: Prims.int) (c: Prims.int).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     b <= c /\ (forall (pure_result: Prims.unit). a * b <= a * c ==> p pure_result) ==>
;     (forall (any_result: Prims.unit). p any_result)
; Context: While encoding a query
; While typechecking the top-level declaration `let lemma_mult_le_left`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term) (@x2 Term))
    (! (implies
      (and (HasType @x0 Prims.nat) (HasType @x1 Prims.int) (HasType @x2 Prims.int))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x3 Term))
       (! (implies
         (and
          (HasType @x3 (Prims.pure_post Prims.unit))
          ;; def=FStar.Math.Lemmas.fsti(29,12-29,20); use=FStar.Math.Lemmas.fst(28,31-28,33)
          (<= (BoxInt_proj_0 @x1) (BoxInt_proj_0 @x2))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(28,31-28,33)
          (forall ((@x4 Term))
           (! (implies
             (and
              (or label_1 (HasType @x4 Prims.unit))
              ;; def=FStar.Math.Lemmas.fsti(30,12-30,28); use=FStar.Math.Lemmas.fst(28,31-28,33)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fsti(30,12-30,28); use=FStar.Math.Lemmas.fst(28,31-28,33)
               (<=
                (BoxInt_proj_0 (Prims.op_Multiply @x0 @x1))
                (BoxInt_proj_0 (Prims.op_Multiply @x0 @x2)))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(28,31-28,33)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(28,31-28,33)
              (ApplyTT @x3 @x4)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(28,31-28,33)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(28,31-28,33)
               (ApplyTT @x3 @x4)))
            :qid @query.2)))
         ;; def=Prims.fst(459,66-459,102); use=Prims.fst(462,31-462,44)
         (forall ((@x4 Term))
          (! (implies
            (HasType @x4 Prims.unit)
            ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
            (Valid
             ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
             (ApplyTT @x3 @x4)))
           :qid @query.3)))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.lemma_mult_le_left, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let lemma_mult_le_left
; <Start encoding let lemma_mult_le_left>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.lemma_mult_le_left (Term Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.lemma_mult_le_left@tok () Term)
; </end encoding let lemma_mult_le_left>

; encoding sigelt val FStar.Math.Lemmas.lemma_mult_le_right
; <Skipped val FStar.Math.Lemmas.lemma_mult_le_right/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(30,32-30,34)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (a: Prims.nat) (b: Prims.int) (c: Prims.int).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     b <= c /\ (forall (pure_result: Prims.unit). b * a <= c * a ==> p pure_result) ==>
;     (forall (any_result: Prims.unit). p any_result)
; Context: While encoding a query
; While typechecking the top-level declaration `let lemma_mult_le_right`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term) (@x2 Term))
    (! (implies
      (and (HasType @x0 Prims.nat) (HasType @x1 Prims.int) (HasType @x2 Prims.int))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x3 Term))
       (! (implies
         (and
          (HasType @x3 (Prims.pure_post Prims.unit))
          ;; def=FStar.Math.Lemmas.fsti(33,12-33,20); use=FStar.Math.Lemmas.fst(30,32-30,34)
          (<= (BoxInt_proj_0 @x1) (BoxInt_proj_0 @x2))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(30,32-30,34)
          (forall ((@x4 Term))
           (! (implies
             (and
              (or label_1 (HasType @x4 Prims.unit))
              ;; def=FStar.Math.Lemmas.fsti(34,12-34,28); use=FStar.Math.Lemmas.fst(30,32-30,34)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fsti(34,12-34,28); use=FStar.Math.Lemmas.fst(30,32-30,34)
               (<=
                (BoxInt_proj_0 (Prims.op_Multiply @x1 @x0))
                (BoxInt_proj_0 (Prims.op_Multiply @x2 @x0)))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(30,32-30,34)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(30,32-30,34)
              (ApplyTT @x3 @x4)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(30,32-30,34)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(30,32-30,34)
               (ApplyTT @x3 @x4)))
            :qid @query.2)))
         ;; def=Prims.fst(459,66-459,102); use=Prims.fst(462,31-462,44)
         (forall ((@x4 Term))
          (! (implies
            (HasType @x4 Prims.unit)
            ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
            (Valid
             ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
             (ApplyTT @x3 @x4)))
           :qid @query.3)))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.lemma_mult_le_right, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let lemma_mult_le_right
; <Start encoding let lemma_mult_le_right>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.lemma_mult_le_right (Term Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.lemma_mult_le_right@tok () Term)
; </end encoding let lemma_mult_le_right>

; encoding sigelt val FStar.Math.Lemmas.lemma_mult_lt_left
; <Skipped val FStar.Math.Lemmas.lemma_mult_lt_left/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(32,31-32,33)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (a: Prims.pos) (b: Prims.int) (c: Prims.int).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     b < c /\ (forall (pure_result: Prims.unit). a * b < a * c ==> p pure_result) ==>
;     (forall (any_result: Prims.unit). p any_result)
; Context: While encoding a query
; While typechecking the top-level declaration `let lemma_mult_lt_left`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term) (@x2 Term))
    (! (implies
      (and (HasType @x0 Prims.pos) (HasType @x1 Prims.int) (HasType @x2 Prims.int))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x3 Term))
       (! (implies
         (and
          (HasType @x3 (Prims.pure_post Prims.unit))
          ;; def=FStar.Math.Lemmas.fsti(37,12-37,19); use=FStar.Math.Lemmas.fst(32,31-32,33)
          (< (BoxInt_proj_0 @x1) (BoxInt_proj_0 @x2))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(32,31-32,33)
          (forall ((@x4 Term))
           (! (implies
             (and
              (or label_1 (HasType @x4 Prims.unit))
              ;; def=FStar.Math.Lemmas.fsti(38,12-38,27); use=FStar.Math.Lemmas.fst(32,31-32,33)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fsti(38,12-38,27); use=FStar.Math.Lemmas.fst(32,31-32,33)
               (<
                (BoxInt_proj_0 (Prims.op_Multiply @x0 @x1))
                (BoxInt_proj_0 (Prims.op_Multiply @x0 @x2)))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(32,31-32,33)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(32,31-32,33)
              (ApplyTT @x3 @x4)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(32,31-32,33)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(32,31-32,33)
               (ApplyTT @x3 @x4)))
            :qid @query.2)))
         ;; def=Prims.fst(459,66-459,102); use=Prims.fst(462,31-462,44)
         (forall ((@x4 Term))
          (! (implies
            (HasType @x4 Prims.unit)
            ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
            (Valid
             ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
             (ApplyTT @x3 @x4)))
           :qid @query.3)))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.lemma_mult_lt_left, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let lemma_mult_lt_left
; <Start encoding let lemma_mult_lt_left>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.lemma_mult_lt_left (Term Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.lemma_mult_lt_left@tok () Term)
; </end encoding let lemma_mult_lt_left>

; encoding sigelt val FStar.Math.Lemmas.lemma_mult_lt_right
; <Skipped val FStar.Math.Lemmas.lemma_mult_lt_right/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(34,32-34,34)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (a: Prims.pos) (b: Prims.int) (c: Prims.int).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     b < c /\ (forall (pure_result: Prims.unit). b * a < c * a ==> p pure_result) ==>
;     (forall (any_result: Prims.unit). p any_result)
; Context: While encoding a query
; While typechecking the top-level declaration `let lemma_mult_lt_right`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term) (@x2 Term))
    (! (implies
      (and (HasType @x0 Prims.pos) (HasType @x1 Prims.int) (HasType @x2 Prims.int))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x3 Term))
       (! (implies
         (and
          (HasType @x3 (Prims.pure_post Prims.unit))
          ;; def=FStar.Math.Lemmas.fsti(41,12-41,19); use=FStar.Math.Lemmas.fst(34,32-34,34)
          (< (BoxInt_proj_0 @x1) (BoxInt_proj_0 @x2))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(34,32-34,34)
          (forall ((@x4 Term))
           (! (implies
             (and
              (or label_1 (HasType @x4 Prims.unit))
              ;; def=FStar.Math.Lemmas.fsti(42,12-42,27); use=FStar.Math.Lemmas.fst(34,32-34,34)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fsti(42,12-42,27); use=FStar.Math.Lemmas.fst(34,32-34,34)
               (<
                (BoxInt_proj_0 (Prims.op_Multiply @x1 @x0))
                (BoxInt_proj_0 (Prims.op_Multiply @x2 @x0)))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(34,32-34,34)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(34,32-34,34)
              (ApplyTT @x3 @x4)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(34,32-34,34)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(34,32-34,34)
               (ApplyTT @x3 @x4)))
            :qid @query.2)))
         ;; def=Prims.fst(459,66-459,102); use=Prims.fst(462,31-462,44)
         (forall ((@x4 Term))
          (! (implies
            (HasType @x4 Prims.unit)
            ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
            (Valid
             ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
             (ApplyTT @x3 @x4)))
           :qid @query.3)))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.lemma_mult_lt_right, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let lemma_mult_lt_right
; <Start encoding let lemma_mult_lt_right>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.lemma_mult_lt_right (Term Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.lemma_mult_lt_right@tok () Term)
; </end encoding let lemma_mult_lt_right>

; encoding sigelt val FStar.Math.Lemmas.lemma_mult_lt_sqr
; <Skipped val FStar.Math.Lemmas.lemma_mult_lt_sqr/>

; well-founded ordering on nat (alt)
;;; Fact-ids: Name Prims.int; Namespace Prims
(assert
 (! (forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
   (! (implies
     (and
      (HasTypeFuel @u0 @x1 Prims.int)
      (HasTypeFuel @u0 @x2 Prims.int)
      (> (BoxInt_proj_0 @x1) 0)
      (>= (BoxInt_proj_0 @x2) 0)
      (< (BoxInt_proj_0 @x2) (BoxInt_proj_0 @x1)))
     (Valid (Prims.precedes Prims.lex_t Prims.lex_t @x2 @x1)))
    :pattern
     ((HasTypeFuel @u0 @x1 Prims.int)
      (HasTypeFuel @u0 @x2 Prims.int)
      (Valid (Prims.precedes Prims.lex_t Prims.lex_t @x2 @x1)))
    :qid well-founded-ordering-on-nat))
  :named well-founded-ordering-on-nat))
; free var typing
;;; Fact-ids: Name Prims.bool; Namespace Prims
(assert
 (! (HasType Prims.bool Prims.eqtype) :named typing_Prims.bool))
; free var typing
;;; Fact-ids: Name FStar.Preorder.relation; Namespace FStar.Preorder
(assert
 (! ;; def=FStar.Preorder.fst(20,5-20,13); use=FStar.Preorder.fst(20,5-20,13)
  (forall ((@x0 Term))
   (! (implies (HasType @x0 Tm_type) (HasType (FStar.Preorder.relation @x0) Tm_type))
    :pattern ((FStar.Preorder.relation @x0))
    :qid typing_FStar.Preorder.relation))
  :named typing_FStar.Preorder.relation))
; free var typing
;;; Fact-ids: Name FStar.Calc.calc_pack; Namespace FStar.Calc
(assert
 (! ;; def=FStar.Calc.fsti(51,5-51,14); use=FStar.Calc.fsti(51,5-51,14)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
   (! (implies
     (and
      (HasType @x0 Tm_type)
      (HasType @x1 (Prims.list (FStar.Preorder.relation @x0)))
      (HasType @x2 @x0)
      (HasType @x3 @x0))
     (HasType (FStar.Calc.calc_pack @x0 @x1 @x2 @x3) Tm_type))
    :pattern ((FStar.Calc.calc_pack @x0 @x1 @x2 @x3))
    :qid typing_FStar.Calc.calc_pack))
  :named typing_FStar.Calc.calc_pack))
; free var typing
;;; Fact-ids: Name FStar.Calc.calc_chain; Namespace FStar.Calc
(assert
 (! ;; def=FStar.Calc.fsti(32,4-32,14); use=FStar.Calc.fsti(32,4-32,14)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
   (! (implies
     (and
      (HasType @x0 Tm_type)
      (HasType @x1 (Prims.list (FStar.Preorder.relation @x0)))
      (HasType @x2 @x0)
      (HasType @x3 @x0))
     (HasType (FStar.Calc.calc_chain @x0 @x1 @x2 @x3) Tm_type))
    :pattern ((FStar.Calc.calc_chain @x0 @x1 @x2 @x3))
    :qid typing_FStar.Calc.calc_chain))
  :named typing_FStar.Calc.calc_chain))
; name-token correspondence
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert
 (! ;; def=Prims.fst(616,5-616,9); use=Prims.fst(616,5-616,9)
  (forall ((@x0 Term))
   (! (= (ApplyTT Prims.list@tok @x0) (Prims.list @x0))
    :pattern ((ApplyTT Prims.list@tok @x0))
    :pattern ((Prims.list @x0))
    :qid token_correspondence_Prims.list@tok))
  :named token_correspondence_Prims.list@tok))
; subterm ordering
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert
 (! ;; def=Prims.fst(618,4-618,8); use=Prims.fst(618,4-618,8)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
   (! (implies
     (HasTypeFuel (SFuel @u0) (Prims.Cons @x1 @x2 @x3) (Prims.list @x4))
     (and
      (Valid (Prims.precedes Prims.lex_t Prims.lex_t @x2 (Prims.Cons @x1 @x2 @x3)))
      (Valid (Prims.precedes Prims.lex_t Prims.lex_t @x3 (Prims.Cons @x1 @x2 @x3)))))
    :pattern ((HasTypeFuel (SFuel @u0) (Prims.Cons @x1 @x2 @x3) (Prims.list @x4)))
    :qid subterm_ordering_Prims.Cons))
  :named subterm_ordering_Prims.Cons))
; Projection inverse
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert
 (! ;; def=Prims.fst(617,4-617,7); use=Prims.fst(617,4-617,7)
  (forall ((@x0 Term))
   (! (= (Prims.Nil_a (Prims.Nil @x0)) @x0)
    :pattern ((Prims.Nil @x0))
    :qid projection_inverse_Prims.Nil_a))
  :named projection_inverse_Prims.Nil_a))
; Projection inverse
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert
 (! ;; def=Prims.fst(618,4-618,8); use=Prims.fst(618,4-618,8)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term))
   (! (= (Prims.Cons_tl (Prims.Cons @x0 @x1 @x2)) @x2)
    :pattern ((Prims.Cons @x0 @x1 @x2))
    :qid projection_inverse_Prims.Cons_tl))
  :named projection_inverse_Prims.Cons_tl))
; Projection inverse
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert
 (! ;; def=Prims.fst(618,4-618,8); use=Prims.fst(618,4-618,8)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term))
   (! (= (Prims.Cons_hd (Prims.Cons @x0 @x1 @x2)) @x1)
    :pattern ((Prims.Cons @x0 @x1 @x2))
    :qid projection_inverse_Prims.Cons_hd))
  :named projection_inverse_Prims.Cons_hd))
; Projection inverse
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert
 (! ;; def=Prims.fst(618,4-618,8); use=Prims.fst(618,4-618,8)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term))
   (! (= (Prims.Cons_a (Prims.Cons @x0 @x1 @x2)) @x0)
    :pattern ((Prims.Cons @x0 @x1 @x2))
    :qid projection_inverse_Prims.Cons_a))
  :named projection_inverse_Prims.Cons_a))
;;; Fact-ids: Name Prims.op_LessThanOrEqual; Namespace Prims
(assert
 (! ;; def=Prims.fst(572,4-572,22); use=Prims.fst(572,4-572,22)
  (forall ((@x0 Term) (@x1 Term))
   (! (= (Prims.op_LessThanOrEqual @x0 @x1) (BoxBool (<= (BoxInt_proj_0 @x0) (BoxInt_proj_0 @x1))))
    :pattern ((Prims.op_LessThanOrEqual @x0 @x1))
    :qid primitive_Prims.op_LessThanOrEqual))
  :named primitive_Prims.op_LessThanOrEqual))
;;; Fact-ids: Name Prims.op_LessThan; Namespace Prims
(assert
 (! ;; def=Prims.fst(590,4-590,15); use=Prims.fst(590,4-590,15)
  (forall ((@x0 Term) (@x1 Term))
   (! (= (Prims.op_LessThan @x0 @x1) (BoxBool (< (BoxInt_proj_0 @x0) (BoxInt_proj_0 @x1))))
    :pattern ((Prims.op_LessThan @x0 @x1))
    :qid primitive_Prims.op_LessThan))
  :named primitive_Prims.op_LessThan))
; kinding
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert
 (! (is-Tm_arrow (PreType Prims.list@tok)) :named pre_kinding_Prims.list@tok))
; kinding_Tm_arrow_a19f9d49348d4e0038f0ded87d87802f
;;; Fact-ids: Name FStar.Preorder.relation; Namespace FStar.Preorder
(assert
 (! ;; def=FStar.Preorder.fst(20,15-20,40); use=FStar.Preorder.fst(20,25-20,40)
  (forall ((@x0 Term))
   (! (HasType (Tm_arrow_a19f9d49348d4e0038f0ded87d87802f @x0) Tm_type)
    :pattern ((HasType (Tm_arrow_a19f9d49348d4e0038f0ded87d87802f @x0) Tm_type))
    :qid kinding_Tm_arrow_a19f9d49348d4e0038f0ded87d87802f))
  :named kinding_Tm_arrow_a19f9d49348d4e0038f0ded87d87802f))
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert
 (! (and
   (IsTotFun Prims.list@tok)
   ;; def=Prims.fst(616,5-616,9); use=Prims.fst(616,5-616,9)
   (forall ((@x0 Term))
    (! (implies (HasType @x0 Tm_type) (HasType (Prims.list @x0) Tm_type))
     :pattern ((Prims.list @x0))
     :qid kinding_Prims.list@tok)))
  :named kinding_Prims.list@tok))
; function token typing
;;; Fact-ids: Name Prims.bool; Namespace Prims
(assert
 (! (HasType Prims.bool Prims.eqtype) :named function_token_typing_Prims.bool))
; inversion axiom
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert
 (! ;; def=Prims.fst(616,5-616,9); use=Prims.fst(616,5-616,9)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
   (! (implies
     (HasTypeFuel (SFuel @u0) @x1 (Prims.list @x2))
     (or
      (and (is-Prims.Nil @x1) (= @x2 (Prims.Nil_a @x1)))
      (and (is-Prims.Cons @x1) (= @x2 (Prims.Cons_a @x1)))))
    :pattern ((HasTypeFuel (SFuel @u0) @x1 (Prims.list @x2)))
    :qid fuel_guarded_inversion_Prims.list))
  :named fuel_guarded_inversion_Prims.list))
; fresh token
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert
 (! (= 314 (Term_constr_id Prims.list@tok)) :named fresh_token_Prims.list@tok))
; Equation for FStar.Preorder.relation
;;; Fact-ids: Name FStar.Preorder.relation; Namespace FStar.Preorder
(assert
 (! ;; def=FStar.Preorder.fst(20,5-20,13); use=FStar.Preorder.fst(20,5-20,13)
  (forall ((@x0 Term))
   (! (= (FStar.Preorder.relation @x0) (Tm_arrow_a19f9d49348d4e0038f0ded87d87802f @x0))
    :pattern ((FStar.Preorder.relation @x0))
    :qid equation_FStar.Preorder.relation))
  :named equation_FStar.Preorder.relation))
; Equation for FStar.Calc.calc_pack
;;; Fact-ids: Name FStar.Calc.calc_pack; Namespace FStar.Calc
(assert
 (! ;; def=FStar.Calc.fsti(51,5-51,14); use=FStar.Calc.fsti(51,5-51,14)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
   (! (=
     (FStar.Calc.calc_pack @x0 @x1 @x2 @x3)
     (Prims.squash (FStar.Calc.calc_chain @x0 @x1 @x2 @x3)))
    :pattern ((FStar.Calc.calc_pack @x0 @x1 @x2 @x3))
    :qid equation_FStar.Calc.calc_pack))
  :named equation_FStar.Calc.calc_pack))
; data constructor typing intro
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert
 (! ;; def=Prims.fst(617,4-617,7); use=Prims.fst(617,4-617,7)
  (forall ((@u0 Fuel) (@x1 Term))
   (! (implies (HasTypeFuel @u0 @x1 Tm_type) (HasTypeFuel @u0 (Prims.Nil @x1) (Prims.list @x1)))
    :pattern ((HasTypeFuel @u0 (Prims.Nil @x1) (Prims.list @x1)))
    :qid data_typing_intro_Prims.Nil@tok))
  :named data_typing_intro_Prims.Nil@tok))
; data constructor typing intro
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert
 (! ;; def=Prims.fst(618,4-618,8); use=Prims.fst(618,4-618,8)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
   (! (implies
     (and
      (HasTypeFuel @u0 @x1 Tm_type)
      (HasTypeFuel @u0 @x2 @x1)
      (HasTypeFuel @u0 @x3 (Prims.list @x1)))
     (HasTypeFuel @u0 (Prims.Cons @x1 @x2 @x3) (Prims.list @x1)))
    :pattern ((HasTypeFuel @u0 (Prims.Cons @x1 @x2 @x3) (Prims.list @x1)))
    :qid data_typing_intro_Prims.Cons@tok))
  :named data_typing_intro_Prims.Cons@tok))
; data constructor typing elim
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert
 (! ;; def=Prims.fst(617,4-617,7); use=Prims.fst(617,4-617,7)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
   (! (implies
     (HasTypeFuel (SFuel @u0) (Prims.Nil @x1) (Prims.list @x2))
     (HasTypeFuel @u0 @x2 Tm_type))
    :pattern ((HasTypeFuel (SFuel @u0) (Prims.Nil @x1) (Prims.list @x2)))
    :qid data_elim_Prims.Nil))
  :named data_elim_Prims.Nil))
; data constructor typing elim
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert
 (! ;; def=Prims.fst(618,4-618,8); use=Prims.fst(618,4-618,8)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
   (! (implies
     (HasTypeFuel (SFuel @u0) (Prims.Cons @x1 @x2 @x3) (Prims.list @x4))
     (and
      (HasTypeFuel @u0 @x4 Tm_type)
      (HasTypeFuel @u0 @x2 @x4)
      (HasTypeFuel @u0 @x3 (Prims.list @x4))))
    :pattern ((HasTypeFuel (SFuel @u0) (Prims.Cons @x1 @x2 @x3) (Prims.list @x4)))
    :qid data_elim_Prims.Cons))
  :named data_elim_Prims.Cons))
; Constructor distinct
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert
 (! ;; def=Prims.fst(616,5-616,9); use=Prims.fst(616,5-616,9)
  (forall ((@x0 Term))
   (! (= 313 (Term_constr_id (Prims.list @x0)))
    :pattern ((Prims.list @x0))
    :qid constructor_distinct_Prims.list))
  :named constructor_distinct_Prims.list))
; Constructor distinct
;;; Fact-ids: Name Prims.bool; Namespace Prims
(assert
 (! (= 107 (Term_constr_id Prims.bool)) :named constructor_distinct_Prims.bool))
; Constructor distinct
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert
 (! ;; def=Prims.fst(617,4-617,7); use=Prims.fst(617,4-617,7)
  (forall ((@x0 Term))
   (! (= 320 (Term_constr_id (Prims.Nil @x0)))
    :pattern ((Prims.Nil @x0))
    :qid constructor_distinct_Prims.Nil))
  :named constructor_distinct_Prims.Nil))
; Constructor distinct
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert
 (! ;; def=Prims.fst(618,4-618,8); use=Prims.fst(618,4-618,8)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term))
   (! (= 325 (Term_constr_id (Prims.Cons @x0 @x1 @x2)))
    :pattern ((Prims.Cons @x0 @x1 @x2))
    :qid constructor_distinct_Prims.Cons))
  :named constructor_distinct_Prims.Cons))
; bool typing
;;; Fact-ids: Name Prims.bool; Namespace Prims
(assert
 (! (forall ((@u0 Bool))
   (! (HasType (BoxBool @u0) Prims.bool) :pattern ((BoxBool @u0)) :qid bool_typing))
  :named bool_typing))
; bool inversion
;;; Fact-ids: Name Prims.bool; Namespace Prims
(assert
 (! (forall ((@u0 Fuel) (@x1 Term))
   (! (implies (HasTypeFuel @u0 @x1 Prims.bool) (is-BoxBool @x1))
    :pattern ((HasTypeFuel @u0 @x1 Prims.bool))
    :qid bool_inversion))
  :named bool_inversion))
; b2t typing
;;; Fact-ids: Name Prims.b2t; Namespace Prims
(assert
 (! ;; def=Prims.fst(188,5-188,8); use=Prims.fst(188,5-188,8)
  (forall ((@x0 Term))
   (! (implies (HasType @x0 Prims.bool) (HasType (Prims.b2t @x0) Tm_type))
    :pattern ((Prims.b2t @x0))
    :qid b2t_typing))
  :named b2t_typing))
; b2t def
;;; Fact-ids: Name Prims.b2t; Namespace Prims
(assert
 (! ;; def=Prims.fst(188,5-188,8); use=Prims.fst(188,5-188,8)
  (forall ((@x0 Term))
   (! (= (Valid (Prims.b2t @x0)) (BoxBool_proj_0 @x0)) :pattern ((Prims.b2t @x0)) :qid b2t_def))
  :named b2t_def))
; Assumption: Prims.list__uu___haseq
;;; Fact-ids: Name Prims.list__uu___haseq; Namespace Prims
(assert
 (! (forall ((@x0 Term))
   (! (implies
     (and (HasType @x0 Tm_type) (Valid (Prims.hasEq @x0)))
     (Valid (Prims.hasEq (Prims.list @x0))))
    :pattern ((Prims.hasEq (Prims.list @x0)))
    :qid assumption_Prims.list__uu___haseq))
  :named assumption_Prims.list__uu___haseq))
; pretyping
;;; Fact-ids: Name Prims.bool; Namespace Prims
(assert
 (! ;; def=Prims.fst(88,5-88,9); use=Prims.fst(88,5-88,9)
  (forall ((@x0 Term) (@u1 Fuel))
   (! (implies (HasTypeFuel @u1 @x0 Prims.bool) (= Prims.bool (PreType @x0)))
    :pattern ((HasTypeFuel @u1 @x0 Prims.bool))
    :qid Prims_pretyping_f537159ed795b314b4e58c260361ae86))
  :named Prims_pretyping_f537159ed795b314b4e58c260361ae86))
; pretyping
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert
 (! ;; def=Prims.fst(616,5-616,9); use=Prims.fst(616,5-616,9)
  (forall ((@x0 Term) (@u1 Fuel) (@x2 Term))
   (! (implies (HasTypeFuel @u1 @x0 (Prims.list @x2)) (= (Prims.list @x2) (PreType @x0)))
    :pattern ((HasTypeFuel @u1 @x0 (Prims.list @x2)))
    :qid Prims_pretyping_3862c4e8ff39bfc3871b6a47e7ff5b2e))
  :named Prims_pretyping_3862c4e8ff39bfc3871b6a47e7ff5b2e))
; pre-typing for functions
;;; Fact-ids: Name FStar.Preorder.relation; Namespace FStar.Preorder
(assert
 (! ;; def=FStar.Preorder.fst(20,15-20,40); use=FStar.Preorder.fst(20,25-20,40)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
   (! (implies
     (HasTypeFuel @u0 @x1 (Tm_arrow_a19f9d49348d4e0038f0ded87d87802f @x2))
     (is-Tm_arrow (PreType @x1)))
    :pattern ((HasTypeFuel @u0 @x1 (Tm_arrow_a19f9d49348d4e0038f0ded87d87802f @x2)))
    :qid FStar.Preorder_pre_typing_Tm_arrow_a19f9d49348d4e0038f0ded87d87802f))
  :named FStar.Preorder_pre_typing_Tm_arrow_a19f9d49348d4e0038f0ded87d87802f))
; interpretation_Tm_arrow_a19f9d49348d4e0038f0ded87d87802f
;;; Fact-ids: Name FStar.Preorder.relation; Namespace FStar.Preorder
(assert
 (! ;; def=FStar.Preorder.fst(20,15-20,40); use=FStar.Preorder.fst(20,25-20,40)
  (forall ((@x0 Term) (@x1 Term))
   (! (iff
     (HasTypeZ @x0 (Tm_arrow_a19f9d49348d4e0038f0ded87d87802f @x1))
     (and
      ;; def=FStar.Preorder.fst(20,15-20,40); use=FStar.Preorder.fst(20,25-20,40)
      (forall ((@x2 Term) (@x3 Term))
       (! (implies
         (and (HasType @x2 @x1) (HasType @x3 @x1))
         (HasType (ApplyTT (ApplyTT @x0 @x2) @x3) Tm_type))
        :pattern ((ApplyTT (ApplyTT @x0 @x2) @x3))
        :qid FStar.Preorder_interpretation_Tm_arrow_a19f9d49348d4e0038f0ded87d87802f.1))
      (IsTotFun @x0)
      ;; def=FStar.Preorder.fst(20,15-20,40); use=FStar.Preorder.fst(20,25-20,40)
      (forall ((@x2 Term))
       (! (implies (HasType @x2 @x1) (IsTotFun (ApplyTT @x0 @x2)))
        :pattern ((ApplyTT @x0 @x2))
        :qid FStar.Preorder_interpretation_Tm_arrow_a19f9d49348d4e0038f0ded87d87802f.2))))
    :pattern ((HasTypeZ @x0 (Tm_arrow_a19f9d49348d4e0038f0ded87d87802f @x1)))
    :qid FStar.Preorder_interpretation_Tm_arrow_a19f9d49348d4e0038f0ded87d87802f))
  :named FStar.Preorder_interpretation_Tm_arrow_a19f9d49348d4e0038f0ded87d87802f))
(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(38,2-46,3)
(declare-fun label_7 () Bool)
(declare-fun label_6 () Bool)
(declare-fun label_5 () Bool)
(declare-fun label_4 () Bool)
(declare-fun label_3 () Bool)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
(declare-fun Tm_refine_7a4c9c81abfe8561837c8de08a5d08be (Term Term) Term)
; refinement kinding
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fst(36,38-36,61); use=FStar.Math.Lemmas.fst(36,38-36,61)
  (forall ((@x0 Term) (@x1 Term))
   (! (HasType (Tm_refine_7a4c9c81abfe8561837c8de08a5d08be @x0 @x1) Tm_type)
    :pattern ((HasType (Tm_refine_7a4c9c81abfe8561837c8de08a5d08be @x0 @x1) Tm_type))
    :qid refinement_kinding_Tm_refine_7a4c9c81abfe8561837c8de08a5d08be))
  :named refinement_kinding_Tm_refine_7a4c9c81abfe8561837c8de08a5d08be))
; refinement_interpretation
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fst(36,38-36,61); use=FStar.Math.Lemmas.fst(36,38-36,61)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
   (! (iff
     (HasTypeFuel @u0 @x1 (Tm_refine_7a4c9c81abfe8561837c8de08a5d08be @x2 @x3))
     (and
      (HasTypeFuel @u0 @x1 Prims.nat)
      (BoxBool_proj_0 (Prims.op_LessThan @x2 @x1))
      (BoxBool_proj_0 (Prims.op_LessThan @x3 @x1))))
    :pattern ((HasTypeFuel @u0 @x1 (Tm_refine_7a4c9c81abfe8561837c8de08a5d08be @x2 @x3)))
    :qid refinement_interpretation_Tm_refine_7a4c9c81abfe8561837c8de08a5d08be))
  :named refinement_interpretation_Tm_refine_7a4c9c81abfe8561837c8de08a5d08be))
; haseq for Tm_refine_7a4c9c81abfe8561837c8de08a5d08be
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fst(36,38-36,61); use=FStar.Math.Lemmas.fst(36,38-36,61)
  (forall ((@x0 Term) (@x1 Term))
   (! (iff
     (Valid (Prims.hasEq (Tm_refine_7a4c9c81abfe8561837c8de08a5d08be @x0 @x1)))
     (Valid (Prims.hasEq Prims.nat)))
    :pattern ((Valid (Prims.hasEq (Tm_refine_7a4c9c81abfe8561837c8de08a5d08be @x0 @x1))))
    :qid haseqTm_refine_7a4c9c81abfe8561837c8de08a5d08be))
  :named haseqTm_refine_7a4c9c81abfe8561837c8de08a5d08be))
; x9: Prims.int -> y10: Prims.int -> Type
(declare-fun Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0 () Term)
; kinding_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0
;;; Fact-ids: 
(assert
 (! (HasType Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0 Tm_type)
  :named kinding_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0))
; pre-typing for functions
;;; Fact-ids: 
(assert
 (! ;; def=Prims.fst(572,24-572,27); use=FStar.Math.Lemmas.fst(38,2-46,3)
  (forall ((@u0 Fuel) (@x1 Term))
   (! (implies
     (HasTypeFuel @u0 @x1 Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0)
     (is-Tm_arrow (PreType @x1)))
    :pattern ((HasTypeFuel @u0 @x1 Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0))
    :qid FStar.Math.Lemmas_pre_typing_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0))
  :named FStar.Math.Lemmas_pre_typing_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0))
; interpretation_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0
;;; Fact-ids: 
(assert
 (! ;; def=Prims.fst(572,24-572,27); use=FStar.Math.Lemmas.fst(38,2-46,3)
  (forall ((@x0 Term))
   (! (iff
     (HasTypeZ @x0 Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0)
     (and
      ;; def=Prims.fst(572,24-572,27); use=FStar.Math.Lemmas.fst(38,2-46,3)
      (forall ((@x1 Term) (@x2 Term))
       (! (implies
         (and (HasType @x1 Prims.int) (HasType @x2 Prims.int))
         (HasType (ApplyTT (ApplyTT @x0 @x1) @x2) Tm_type))
        :pattern ((ApplyTT (ApplyTT @x0 @x1) @x2))
        :qid FStar.Math.Lemmas_interpretation_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0.1))
      (IsTotFun @x0)
      ;; def=Prims.fst(572,24-572,27); use=FStar.Math.Lemmas.fst(38,2-46,3)
      (forall ((@x1 Term))
       (! (implies (HasType @x1 Prims.int) (IsTotFun (ApplyTT @x0 @x1)))
        :pattern ((ApplyTT @x0 @x1))
        :qid FStar.Math.Lemmas_interpretation_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0.2))))
    :pattern ((HasTypeZ @x0 Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0))
    :qid FStar.Math.Lemmas_interpretation_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0))
  :named FStar.Math.Lemmas_interpretation_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0))
(declare-fun Tm_abs_2f00fec10beff9f1dd6f7abc4148f6a5 () Term)
; typing_Tm_abs_2f00fec10beff9f1dd6f7abc4148f6a5
;;; Fact-ids: 
(assert
 (! (HasType Tm_abs_2f00fec10beff9f1dd6f7abc4148f6a5 Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0)
  :named typing_Tm_abs_2f00fec10beff9f1dd6f7abc4148f6a5))
; interpretation_Tm_abs_2f00fec10beff9f1dd6f7abc4148f6a5
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fst(40,2-40,4); use=FStar.Math.Lemmas.fst(38,2-46,3)
  (forall ((@x0 Term) (@x1 Term))
   (! (=
     (ApplyTT (ApplyTT Tm_abs_2f00fec10beff9f1dd6f7abc4148f6a5 @x0) @x1)
     (Prims.b2t (Prims.op_LessThanOrEqual @x0 @x1)))
    :pattern ((ApplyTT (ApplyTT Tm_abs_2f00fec10beff9f1dd6f7abc4148f6a5 @x0) @x1))
    :qid interpretation_Tm_abs_2f00fec10beff9f1dd6f7abc4148f6a5))
  :named interpretation_Tm_abs_2f00fec10beff9f1dd6f7abc4148f6a5))
; _: Prims.unit -> FStar.Calc.calc_pack [fun x9 y10 -> x9 <= y10 <: Type] (n * m) (n * (k - 1))
(declare-fun Tm_arrow_8739629591a6bdf300d945535394201b (Term Term Term) Term)
; kinding_Tm_arrow_8739629591a6bdf300d945535394201b
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(38,2-46,3)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term))
   (! (HasType (Tm_arrow_8739629591a6bdf300d945535394201b @x0 @x1 @x2) Tm_type)
    :pattern ((HasType (Tm_arrow_8739629591a6bdf300d945535394201b @x0 @x1 @x2) Tm_type))
    :qid kinding_Tm_arrow_8739629591a6bdf300d945535394201b))
  :named kinding_Tm_arrow_8739629591a6bdf300d945535394201b))
; pre-typing for functions
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(38,2-46,3)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
   (! (implies
     (HasTypeFuel @u0 @x1 (Tm_arrow_8739629591a6bdf300d945535394201b @x2 @x3 @x4))
     (is-Tm_arrow (PreType @x1)))
    :pattern ((HasTypeFuel @u0 @x1 (Tm_arrow_8739629591a6bdf300d945535394201b @x2 @x3 @x4)))
    :qid FStar.Math.Lemmas_pre_typing_Tm_arrow_8739629591a6bdf300d945535394201b))
  :named FStar.Math.Lemmas_pre_typing_Tm_arrow_8739629591a6bdf300d945535394201b))
; interpretation_Tm_arrow_8739629591a6bdf300d945535394201b
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(38,2-46,3)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
   (! (iff
     (HasTypeZ @x0 (Tm_arrow_8739629591a6bdf300d945535394201b @x1 @x2 @x3))
     (and
      ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(38,2-46,3)
      (forall ((@x4 Term))
       (! (implies
         (HasType @x4 Prims.unit)
         (HasType
          (ApplyTT @x0 @x4)
          (FStar.Calc.calc_pack
           Prims.int
           (Prims.Cons
            (FStar.Preorder.relation Prims.int)
            Tm_abs_2f00fec10beff9f1dd6f7abc4148f6a5
            (Prims.Nil (FStar.Preorder.relation Prims.int)))
           (Prims.op_Multiply @x3 @x2)
           (Prims.op_Multiply @x3 (Prims.op_Subtraction @x1 (BoxInt 1))))))
        :pattern ((ApplyTT @x0 @x4))
        :qid FStar.Math.Lemmas_interpretation_Tm_arrow_8739629591a6bdf300d945535394201b.1))
      (IsTotFun @x0)))
    :pattern ((HasTypeZ @x0 (Tm_arrow_8739629591a6bdf300d945535394201b @x1 @x2 @x3)))
    :qid FStar.Math.Lemmas_interpretation_Tm_arrow_8739629591a6bdf300d945535394201b))
  :named FStar.Math.Lemmas_interpretation_Tm_arrow_8739629591a6bdf300d945535394201b))




; _: Prims.unit   -> FStar.Calc.calc_pack [(fun x11 y12 -> x11 <= y12 <: Type); fun x9 y10 -> x9 <= y10 <: Type]       (n * m)       ((k - 1) * (k - 1))
(declare-fun Tm_arrow_0beb88931ae1e438083286d63ed6cf3e (Term Term Term) Term)
; kinding_Tm_arrow_0beb88931ae1e438083286d63ed6cf3e
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(38,2-46,3)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term))
   (! (HasType (Tm_arrow_0beb88931ae1e438083286d63ed6cf3e @x0 @x1 @x2) Tm_type)
    :pattern ((HasType (Tm_arrow_0beb88931ae1e438083286d63ed6cf3e @x0 @x1 @x2) Tm_type))
    :qid kinding_Tm_arrow_0beb88931ae1e438083286d63ed6cf3e))
  :named kinding_Tm_arrow_0beb88931ae1e438083286d63ed6cf3e))
; pre-typing for functions
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(38,2-46,3)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
   (! (implies
     (HasTypeFuel @u0 @x1 (Tm_arrow_0beb88931ae1e438083286d63ed6cf3e @x2 @x3 @x4))
     (is-Tm_arrow (PreType @x1)))
    :pattern ((HasTypeFuel @u0 @x1 (Tm_arrow_0beb88931ae1e438083286d63ed6cf3e @x2 @x3 @x4)))
    :qid FStar.Math.Lemmas_pre_typing_Tm_arrow_0beb88931ae1e438083286d63ed6cf3e))
  :named FStar.Math.Lemmas_pre_typing_Tm_arrow_0beb88931ae1e438083286d63ed6cf3e))
; interpretation_Tm_arrow_0beb88931ae1e438083286d63ed6cf3e
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(38,2-46,3)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
   (! (iff
     (HasTypeZ @x0 (Tm_arrow_0beb88931ae1e438083286d63ed6cf3e @x1 @x2 @x3))
     (and
      ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(38,2-46,3)
      (forall ((@x4 Term))
       (! (implies
         (HasType @x4 Prims.unit)
         (HasType
          (ApplyTT @x0 @x4)
          (FStar.Calc.calc_pack
           Prims.int
           (Prims.Cons
            (FStar.Preorder.relation Prims.int)
            Tm_abs_2f00fec10beff9f1dd6f7abc4148f6a5
            (Prims.Cons
             (FStar.Preorder.relation Prims.int)
             Tm_abs_2f00fec10beff9f1dd6f7abc4148f6a5
             (Prims.Nil (FStar.Preorder.relation Prims.int))))
           (Prims.op_Multiply @x3 @x2)
           (Prims.op_Multiply
            (Prims.op_Subtraction @x1 (BoxInt 1))
            (Prims.op_Subtraction @x1 (BoxInt 1))))))
        :pattern ((ApplyTT @x0 @x4))
        :qid FStar.Math.Lemmas_interpretation_Tm_arrow_0beb88931ae1e438083286d63ed6cf3e.1))
      (IsTotFun @x0)))
    :pattern ((HasTypeZ @x0 (Tm_arrow_0beb88931ae1e438083286d63ed6cf3e @x1 @x2 @x3)))
    :qid FStar.Math.Lemmas_interpretation_Tm_arrow_0beb88931ae1e438083286d63ed6cf3e))
  :named FStar.Math.Lemmas_interpretation_Tm_arrow_0beb88931ae1e438083286d63ed6cf3e))






; _: Prims.unit   -> FStar.Calc.calc_pack [         (fun x13 y14 -> x13 <= y14 <: Type);         (fun x11 y12 -> x11 <= y12 <: Type);         fun x9 y10 -> x9 <= y10 <: Type       ]       (n * m)       (k * k - 1)
(declare-fun Tm_arrow_a2fffbd920ef0992caeab586c0a4ae7b (Term Term Term) Term)
; kinding_Tm_arrow_a2fffbd920ef0992caeab586c0a4ae7b
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(81,6-81,36); use=FStar.Math.Lemmas.fst(38,2-46,3)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term))
   (! (HasType (Tm_arrow_a2fffbd920ef0992caeab586c0a4ae7b @x0 @x1 @x2) Tm_type)
    :pattern ((HasType (Tm_arrow_a2fffbd920ef0992caeab586c0a4ae7b @x0 @x1 @x2) Tm_type))
    :qid kinding_Tm_arrow_a2fffbd920ef0992caeab586c0a4ae7b))
  :named kinding_Tm_arrow_a2fffbd920ef0992caeab586c0a4ae7b))
; pre-typing for functions
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(81,6-81,36); use=FStar.Math.Lemmas.fst(38,2-46,3)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
   (! (implies
     (HasTypeFuel @u0 @x1 (Tm_arrow_a2fffbd920ef0992caeab586c0a4ae7b @x2 @x3 @x4))
     (is-Tm_arrow (PreType @x1)))
    :pattern ((HasTypeFuel @u0 @x1 (Tm_arrow_a2fffbd920ef0992caeab586c0a4ae7b @x2 @x3 @x4)))
    :qid FStar.Math.Lemmas_pre_typing_Tm_arrow_a2fffbd920ef0992caeab586c0a4ae7b))
  :named FStar.Math.Lemmas_pre_typing_Tm_arrow_a2fffbd920ef0992caeab586c0a4ae7b))
; interpretation_Tm_arrow_a2fffbd920ef0992caeab586c0a4ae7b
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(81,6-81,36); use=FStar.Math.Lemmas.fst(38,2-46,3)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
   (! (iff
     (HasTypeZ @x0 (Tm_arrow_a2fffbd920ef0992caeab586c0a4ae7b @x1 @x2 @x3))
     (and
      ;; def=FStar.Calc.fsti(81,6-81,36); use=FStar.Math.Lemmas.fst(38,2-46,3)
      (forall ((@x4 Term))
       (! (implies
         (HasType @x4 Prims.unit)
         (HasType
          (ApplyTT @x0 @x4)
          (FStar.Calc.calc_pack
           Prims.int
           (Prims.Cons
            (FStar.Preorder.relation Prims.int)
            Tm_abs_2f00fec10beff9f1dd6f7abc4148f6a5
            (Prims.Cons
             (FStar.Preorder.relation Prims.int)
             Tm_abs_2f00fec10beff9f1dd6f7abc4148f6a5
             (Prims.Cons
              (FStar.Preorder.relation Prims.int)
              Tm_abs_2f00fec10beff9f1dd6f7abc4148f6a5
              (Prims.Nil (FStar.Preorder.relation Prims.int)))))
           (Prims.op_Multiply @x3 @x2)
           (Prims.op_Subtraction (Prims.op_Multiply @x1 @x1) (BoxInt 1)))))
        :pattern ((ApplyTT @x0 @x4))
        :qid FStar.Math.Lemmas_interpretation_Tm_arrow_a2fffbd920ef0992caeab586c0a4ae7b.1))
      (IsTotFun @x0)))
    :pattern ((HasTypeZ @x0 (Tm_arrow_a2fffbd920ef0992caeab586c0a4ae7b @x1 @x2 @x3)))
    :qid FStar.Math.Lemmas_interpretation_Tm_arrow_a2fffbd920ef0992caeab586c0a4ae7b))
  :named FStar.Math.Lemmas_interpretation_Tm_arrow_a2fffbd920ef0992caeab586c0a4ae7b))
; Encoding query formula : forall (n: Prims.nat) (m: Prims.nat) (k: Prims.nat{n < k && m < k}).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     (forall (pure_result: Prims.unit). n * m < k * k ==> p pure_result) ==>
;     (forall (_: Prims.unit).
;         (*  - Could not prove post-condition
; *)
;         (forall (_: Prims.unit).
;             (*  - Could not prove post-condition
; *)
;             (forall (_: Prims.unit).
;                 (*  - Could not prove post-condition
; *)
;                 forall (_: Prims.unit). (*  - Could not prove post-condition
; *) m <= k - 1) /\
;             (forall (any_result:
;                 (_: Prims.unit
;                     -> FStar.Calc.calc_pack [fun x9 y10 -> x9 <= y10 <: Type0] (n * m) (n * (k - 1))
;                 ))
;                 (_: Prims.unit).
;                 (*  - Could not prove post-condition
; *)
;                 k - 1 >= 0 /\ (forall (return_val: Prims.nat). return_val == k - 1 ==> n <= k - 1))) /\
;         (forall (any_result:
;             (_: Prims.unit
;                 -> FStar.Calc.calc_pack [
;                       (fun x11 y12 -> x11 <= y12 <: Type0);
;                       fun x9 y10 -> x9 <= y10 <: Type0
;                     ]
;                     (n * m)
;                     ((k - 1) * (k - 1))))
;             (_: Prims.unit).
;             (*  - Could not prove post-condition
; *) (k - 1) * (k - 1) <= k * k - 1)) /\
;     (forall (any_result:
;         (_: Prims.unit
;             -> FStar.Calc.calc_pack [
;                   (fun x13 y14 -> x13 <= y14 <: Type0);
;                   (fun x11 y12 -> x11 <= y12 <: Type0);
;                   fun x9 y10 -> x9 <= y10 <: Type0
;                 ]
;                 (n * m)
;                 (k * k - 1))).
;         FStar.Range.labeled (FStar.Sealed.seal FStar.Calc.fsti(86,37-86,50))
;           "Could not prove that this calc-chain is compatible"
;           (forall (x: Prims.int) (y: Prims.int).
;               (exists (w: Prims.int).
;                   (exists (w: Prims.int). (exists (w: Prims.int). x == w /\ w <= w) /\ w <= w) /\
;                   w <= y) ==>
;               x <= y) /\ (forall (pure_result: Prims.unit). n * m <= k * k - 1 ==> p pure_result))
; Context: While encoding a query
; While typechecking the top-level declaration `let lemma_mult_lt_sqr`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term) (@x2 Term))
    (! (implies
      (and
       (HasType @x0 Prims.nat)
       (HasType @x1 Prims.nat)
       (HasType @x2 (Tm_refine_7a4c9c81abfe8561837c8de08a5d08be @x0 @x1)))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x3 Term))
       (! (implies
         (and
          (HasType @x3 (Prims.pure_post Prims.unit))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(38,2-46,3)
          (forall ((@x4 Term))
           (! (implies
             (and
              (or label_1 (HasType @x4 Prims.unit))
              ;; def=FStar.Math.Lemmas.fst(37,10-37,25); use=FStar.Math.Lemmas.fst(38,2-46,3)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fst(37,10-37,25); use=FStar.Math.Lemmas.fst(38,2-46,3)
               (<
                (BoxInt_proj_0 (Prims.op_Multiply @x0 @x1))
                (BoxInt_proj_0 (Prims.op_Multiply @x2 @x2)))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(38,2-46,3)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(38,2-46,3)
              (ApplyTT @x3 @x4)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(38,2-46,3)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(38,2-46,3)
               (ApplyTT @x3 @x4)))
            :qid @query.2)))
         ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(38,2-46,3)
         (and
          ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(38,2-46,3)
          (forall ((@x4 Term))
           (! (implies
             (HasType @x4 Prims.unit)
             ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(38,2-46,3)
             (and
              ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(38,2-46,3)
              (forall ((@x5 Term))
               (! (implies
                 (HasType @x5 Prims.unit)
                 ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(38,2-46,3)
                 (and
                  ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(38,2-46,3)
                  (forall ((@x6 Term))
                   (! (implies
                     (HasType @x6 Prims.unit)
                     ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(38,2-46,3)
                     (forall ((@x7 Term))
                      (! (implies
                        (HasType @x7 Prims.unit)
                        ;; def=FStar.Math.Lemmas.fsti(29,12-29,20); use=FStar.Math.Lemmas.fst(40,7-40,25)
                        (or
                         label_3
                         ;; def=FStar.Math.Lemmas.fsti(29,12-29,20); use=FStar.Math.Lemmas.fst(40,7-40,25)
                         (<=
                          (BoxInt_proj_0 @x1)
                          (BoxInt_proj_0 (Prims.op_Subtraction @x2 (BoxInt 1))))))
                       :qid @query.6)))
                    :qid @query.5))
                  ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(38,2-46,3)
                  (forall ((@x6 Term))
                   (! (implies
                     (HasType @x6 (Tm_arrow_8739629591a6bdf300d945535394201b @x2 @x1 @x0))
                     ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(38,2-46,3)
                     (forall ((@x7 Term))
                      (! (implies
                        (HasType @x7 Prims.unit)
                        ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(42,7-42,44)
                        (and
                         ;; def=Prims.fst(682,18-682,24); use=FStar.Math.Lemmas.fst(42,27-42,34)
                         (or
                          label_4
                          ;; def=Prims.fst(682,18-682,24); use=FStar.Math.Lemmas.fst(42,27-42,34)
                          (>=
                           (BoxInt_proj_0 (Prims.op_Subtraction @x2 (BoxInt 1)))
                           (BoxInt_proj_0 (BoxInt 0))))
                         ;; def=Prims.fst(364,2-364,58); use=FStar.Math.Lemmas.fst(42,7-42,44)
                         (forall ((@x8 Term))
                          (! (implies
                            (and
                             (HasType @x8 Prims.nat)
                             ;; def=Prims.fst(364,26-364,41); use=FStar.Math.Lemmas.fst(42,7-42,44)
                             (= @x8 (Prims.op_Subtraction @x2 (BoxInt 1))))
                            ;; def=FStar.Math.Lemmas.fsti(33,12-33,20); use=FStar.Math.Lemmas.fst(42,7-42,26)
                            (or
                             label_5
                             ;; def=FStar.Math.Lemmas.fsti(33,12-33,20); use=FStar.Math.Lemmas.fst(42,7-42,26)
                             (<=
                              (BoxInt_proj_0 @x0)
                              (BoxInt_proj_0 (Prims.op_Subtraction @x2 (BoxInt 1))))))
                           :qid @query.9))))
                       :qid @query.8)))
                    :qid @query.7))))
                :qid @query.4))
              ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(38,2-46,3)
              (forall ((@x5 Term))
               (! (implies
                 (HasType @x5 (Tm_arrow_0beb88931ae1e438083286d63ed6cf3e @x2 @x1 @x0))
                 ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(38,2-46,3)
                 (forall ((@x6 Term))
                  (! (implies
                    (HasType @x6 Prims.unit)
                    ;; def=FStar.Math.Lemmas.fst(44,2-44,4); use=FStar.Math.Lemmas.fst(44,5-44,7)
                    (or
                     label_6
                     ;; def=FStar.Math.Lemmas.fst(44,2-44,4); use=FStar.Math.Lemmas.fst(44,5-44,7)
                     (<=
                      (BoxInt_proj_0
                       (Prims.op_Multiply
                        (Prims.op_Subtraction @x2 (BoxInt 1))
                        (Prims.op_Subtraction @x2 (BoxInt 1))))
                      (BoxInt_proj_0 (Prims.op_Subtraction (Prims.op_Multiply @x2 @x2) (BoxInt 1))))))
                   :qid @query.11)))
                :qid @query.10))))
            :qid @query.3))
          ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(38,2-46,3)
          (forall ((@x4 Term))
           (! (implies
             (HasType @x4 (Tm_arrow_a2fffbd920ef0992caeab586c0a4ae7b @x2 @x1 @x0))
             ;; def=Prims.fst(449,29-449,97); use=FStar.Math.Lemmas.fst(38,2-46,3)
             (and
              ;; def=FStar.Calc.fsti(47,4-47,55); use=FStar.Calc.fsti(47,4-47,55)
              (forall ((@x5 Term) (@x6 Term))
               (! (implies
                 (and
                  (HasType @x5 Prims.int)
                  (HasType @x6 Prims.int)
                  ;; def=FStar.Calc.fsti(42,16-42,65); use=FStar.Calc.fsti(42,16-42,65)
                  (exists ((@x7 Term))
                   (! (and
                     (HasType @x7 Prims.int)
                     ;; def=FStar.Calc.fsti(42,16-42,65); use=FStar.Calc.fsti(42,16-42,65)
                     (exists ((@x8 Term))
                      (! (and
                        (HasType @x8 Prims.int)
                        ;; def=FStar.Calc.fsti(42,16-42,65); use=FStar.Calc.fsti(42,16-42,65)
                        (exists ((@x9 Term))
                         (! (and
                           (HasType @x9 Prims.int)
                           ;; def=FStar.Calc.fsti(40,12-40,18); use=FStar.Calc.fsti(40,12-40,18)
                           (= @x5 @x9)
                           ;; def=FStar.Math.Lemmas.fst(40,2-40,4); use=FStar.Math.Lemmas.fst(38,2-46,3)
                           (<= (BoxInt_proj_0 @x9) (BoxInt_proj_0 @x8)))
                          :qid @query.16))
                        ;; def=FStar.Math.Lemmas.fst(42,2-42,4); use=FStar.Math.Lemmas.fst(38,2-46,3)
                        (<= (BoxInt_proj_0 @x8) (BoxInt_proj_0 @x7)))
                       :qid @query.15))
                     ;; def=FStar.Math.Lemmas.fst(44,2-44,4); use=FStar.Math.Lemmas.fst(38,2-46,3)
                     (<= (BoxInt_proj_0 @x7) (BoxInt_proj_0 @x6)))
                    :qid @query.14)))
                 ;; def=FStar.Math.Lemmas.fst(38,7-38,11); use=FStar.Math.Lemmas.fst(38,2-46,3)
                 (or
                  label_7
                  ;; def=FStar.Math.Lemmas.fst(38,7-38,11); use=FStar.Math.Lemmas.fst(38,2-46,3)
                  (<= (BoxInt_proj_0 @x5) (BoxInt_proj_0 @x6))))
                :qid @query.13))
              ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(38,2-46,3)
              (forall ((@x5 Term))
               (! (implies
                 (and
                  (HasType @x5 Prims.unit)
                  ;; def=FStar.Math.Lemmas.fst(38,7-38,11); use=FStar.Math.Lemmas.fst(38,2-46,3)
                  (<=
                   (BoxInt_proj_0 (Prims.op_Multiply @x0 @x1))
                   (BoxInt_proj_0 (Prims.op_Subtraction (Prims.op_Multiply @x2 @x2) (BoxInt 1)))))
                 ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(38,2-46,3)
                 (Valid
                  ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(38,2-46,3)
                  (ApplyTT @x3 @x5)))
                :qid @query.17))))
            :qid @query.12))))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_7")
(eval label_7)
(echo "label_6")
(eval label_6)
(echo "label_5")
(eval label_5)
(echo "label_4")
(eval label_4)
(echo "label_3")
(eval label_3)
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.lemma_mult_lt_sqr, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let lemma_mult_lt_sqr
; <Start encoding let lemma_mult_lt_sqr>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.lemma_mult_lt_sqr (Term Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.lemma_mult_lt_sqr@tok () Term)
; </end encoding let lemma_mult_lt_sqr>

; encoding sigelt val FStar.Math.Lemmas.swap_mul
; <Skipped val FStar.Math.Lemmas.swap_mul/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(49,19-49,21)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (a: Prims.int) (b: Prims.int).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     (forall (pure_result: Prims.unit). a * b = b * a ==> p pure_result) ==>
;     (forall (any_result: Prims.unit). p any_result)
; Context: While encoding a query
; While typechecking the top-level declaration `let swap_mul`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term))
    (! (implies
      (and (HasType @x0 Prims.int) (HasType @x1 Prims.int))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x2 Term))
       (! (implies
         (and
          (HasType @x2 (Prims.pure_post Prims.unit))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(49,19-49,21)
          (forall ((@x3 Term))
           (! (implies
             (and
              (or label_1 (HasType @x3 Prims.unit))
              ;; def=FStar.Math.Lemmas.fsti(48,38-48,53); use=FStar.Math.Lemmas.fst(49,19-49,21)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fsti(48,38-48,53); use=FStar.Math.Lemmas.fst(49,19-49,21)
               (= (Prims.op_Multiply @x0 @x1) (Prims.op_Multiply @x1 @x0))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(49,19-49,21)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(49,19-49,21)
              (ApplyTT @x2 @x3)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(49,19-49,21)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(49,19-49,21)
               (ApplyTT @x2 @x3)))
            :qid @query.2)))
         ;; def=Prims.fst(459,66-459,102); use=Prims.fst(462,31-462,44)
         (forall ((@x3 Term))
          (! (implies
            (HasType @x3 Prims.unit)
            ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
            (Valid
             ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
             (ApplyTT @x2 @x3)))
           :qid @query.3)))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.swap_mul, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let swap_mul
; <Start encoding let swap_mul>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.swap_mul (Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.swap_mul@tok () Term)
; </end encoding let swap_mul>

; encoding sigelt val FStar.Math.Lemmas.lemma_cancel_mul
; <Skipped val FStar.Math.Lemmas.lemma_cancel_mul/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(51,29-51,31)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (a: Prims.int) (b: Prims.int) (n: Prims.pos).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     a * n = b * n /\ (forall (pure_result: Prims.unit). a = b ==> p pure_result) ==>
;     (forall (any_result: Prims.unit). p any_result)
; Context: While encoding a query
; While typechecking the top-level declaration `let lemma_cancel_mul`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term) (@x2 Term))
    (! (implies
      (and (HasType @x0 Prims.int) (HasType @x1 Prims.int) (HasType @x2 Prims.pos))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x3 Term))
       (! (implies
         (and
          (HasType @x3 (Prims.pure_post Prims.unit))
          ;; def=FStar.Math.Lemmas.fsti(50,61-50,76); use=FStar.Math.Lemmas.fst(51,29-51,31)
          (= (Prims.op_Multiply @x0 @x2) (Prims.op_Multiply @x1 @x2))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(51,29-51,31)
          (forall ((@x4 Term))
           (! (implies
             (and
              (or label_1 (HasType @x4 Prims.unit))
              ;; def=FStar.Math.Lemmas.fsti(50,87-50,94); use=FStar.Math.Lemmas.fst(51,29-51,31)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fsti(50,87-50,94); use=FStar.Math.Lemmas.fst(51,29-51,31)
               (= @x0 @x1)))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(51,29-51,31)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(51,29-51,31)
              (ApplyTT @x3 @x4)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(51,29-51,31)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(51,29-51,31)
               (ApplyTT @x3 @x4)))
            :qid @query.2)))
         ;; def=Prims.fst(459,66-459,102); use=Prims.fst(462,31-462,44)
         (forall ((@x4 Term))
          (! (implies
            (HasType @x4 Prims.unit)
            ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
            (Valid
             ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
             (ApplyTT @x3 @x4)))
           :qid @query.3)))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.lemma_cancel_mul, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let lemma_cancel_mul
; <Start encoding let lemma_cancel_mul>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.lemma_cancel_mul (Term Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.lemma_cancel_mul@tok () Term)
; </end encoding let lemma_cancel_mul>

; encoding sigelt val FStar.Math.Lemmas.distributivity_add_left
; <Skipped val FStar.Math.Lemmas.distributivity_add_left/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(54,36-54,38)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (a: Prims.int) (b: Prims.int) (c: Prims.int).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     (forall (pure_result: Prims.unit). (a + b) * c = a * c + b * c ==> p pure_result) ==>
;     (forall (any_result: Prims.unit). p any_result)
; Context: While encoding a query
; While typechecking the top-level declaration `let distributivity_add_left`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term) (@x2 Term))
    (! (implies
      (and (HasType @x0 Prims.int) (HasType @x1 Prims.int) (HasType @x2 Prims.int))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x3 Term))
       (! (implies
         (and
          (HasType @x3 (Prims.pure_post Prims.unit))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(54,36-54,38)
          (forall ((@x4 Term))
           (! (implies
             (and
              (or label_1 (HasType @x4 Prims.unit))
              ;; def=FStar.Math.Lemmas.fsti(54,2-54,31); use=FStar.Math.Lemmas.fst(54,36-54,38)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fsti(54,2-54,31); use=FStar.Math.Lemmas.fst(54,36-54,38)
               (=
                (Prims.op_Multiply (Prims.op_Addition @x0 @x1) @x2)
                (Prims.op_Addition (Prims.op_Multiply @x0 @x2) (Prims.op_Multiply @x1 @x2)))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(54,36-54,38)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(54,36-54,38)
              (ApplyTT @x3 @x4)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(54,36-54,38)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(54,36-54,38)
               (ApplyTT @x3 @x4)))
            :qid @query.2)))
         ;; def=Prims.fst(459,66-459,102); use=Prims.fst(462,31-462,44)
         (forall ((@x4 Term))
          (! (implies
            (HasType @x4 Prims.unit)
            ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
            (Valid
             ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
             (ApplyTT @x3 @x4)))
           :qid @query.3)))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.distributivity_add_left, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let distributivity_add_left
; <Start encoding let distributivity_add_left>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.distributivity_add_left (Term Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.distributivity_add_left@tok () Term)
; </end encoding let distributivity_add_left>

; encoding sigelt val FStar.Math.Lemmas.distributivity_add_right
; <Skipped val FStar.Math.Lemmas.distributivity_add_right/>

; free var typing
;;; Fact-ids: Name Prims.eq2; Namespace Prims
(assert
 (! ;; def=Prims.fst(183,5-183,8); use=Prims.fst(183,5-183,8)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term))
   (! (implies
     (and (HasType @x0 Tm_type) (HasType @x1 @x0) (HasType @x2 @x0))
     (HasType (Prims.eq2 @x0 @x1 @x2) Prims.logical))
    :pattern ((Prims.eq2 @x0 @x1 @x2))
    :qid typing_Prims.eq2))
  :named typing_Prims.eq2))
; name-token correspondence
;;; Fact-ids: Name Prims.equals; Namespace Prims; Name Prims.Refl; Namespace Prims
(assert
 (! ;; def=Prims.fst(173,5-173,11); use=Prims.fst(173,5-173,11)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term))
   (! (= (ApplyTT (ApplyTT (ApplyTT Prims.equals@tok @x0) @x1) @x2) (Prims.equals @x0 @x1 @x2))
    :pattern ((ApplyTT (ApplyTT (ApplyTT Prims.equals@tok @x0) @x1) @x2))
    :pattern ((Prims.equals @x0 @x1 @x2))
    :qid token_correspondence_Prims.equals@tok))
  :named token_correspondence_Prims.equals@tok))
; kinding
;;; Fact-ids: Name Prims.equals; Namespace Prims; Name Prims.Refl; Namespace Prims
(assert
 (! (is-Tm_arrow (PreType Prims.equals@tok)) :named pre_kinding_Prims.equals@tok))
;;; Fact-ids: Name Prims.equals; Namespace Prims; Name Prims.Refl; Namespace Prims
(assert
 (! (and
   (IsTotFun Prims.equals@tok)
   ;; def=Prims.fst(173,5-173,11); use=Prims.fst(173,5-173,11)
   (forall ((@x0 Term))
    (! (IsTotFun (ApplyTT Prims.equals@tok @x0))
     :pattern ((ApplyTT Prims.equals@tok @x0))
     :qid kinding_Prims.equals@tok))
   ;; def=Prims.fst(173,5-173,11); use=Prims.fst(173,5-173,11)
   (forall ((@x0 Term) (@x1 Term))
    (! (IsTotFun (ApplyTT (ApplyTT Prims.equals@tok @x0) @x1))
     :pattern ((ApplyTT (ApplyTT Prims.equals@tok @x0) @x1))
     :qid kinding_Prims.equals@tok.1))
   ;; def=Prims.fst(173,5-173,11); use=Prims.fst(173,5-173,11)
   (forall ((@x0 Term) (@x1 Term) (@x2 Term))
    (! (implies
      (and (HasType @x0 Tm_type) (HasType @x1 @x0) (HasType @x2 @x0))
      (HasType (Prims.equals @x0 @x1 @x2) Tm_type))
     :pattern ((Prims.equals @x0 @x1 @x2))
     :qid kinding_Prims.equals@tok.2)))
  :named kinding_Prims.equals@tok))
; inversion axiom
;;; Fact-ids: Name Prims.equals; Namespace Prims; Name Prims.Refl; Namespace Prims
(assert
 (! ;; def=Prims.fst(173,5-173,11); use=Prims.fst(173,5-173,11)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
   (! (implies (HasTypeFuel @u0 @x1 (Prims.equals @x2 @x3 @x4)) (is-Prims.Refl @x1))
    :pattern ((HasTypeFuel @u0 @x1 (Prims.equals @x2 @x3 @x4)))
    :qid fuel_guarded_inversion_Prims.equals))
  :named fuel_guarded_inversion_Prims.equals))
; fresh token
;;; Fact-ids: Name Prims.equals; Namespace Prims; Name Prims.Refl; Namespace Prims
(assert
 (! (= 135 (Term_constr_id Prims.equals@tok)) :named fresh_token_Prims.equals@tok))
; Equation for Prims.eq2
;;; Fact-ids: Name Prims.eq2; Namespace Prims
(assert
 (! ;; def=Prims.fst(183,5-183,8); use=Prims.fst(183,5-183,8)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term))
   (! (= (Prims.eq2 @x0 @x1 @x2) (Prims.squash (Prims.equals @x0 @x1 @x2)))
    :pattern ((Prims.eq2 @x0 @x1 @x2))
    :qid equation_Prims.eq2))
  :named equation_Prims.eq2))
; Eq2 interpretation
;;; Fact-ids: Name Prims.eq2; Namespace Prims
(assert
 (! (forall ((@x0 Term) (@x1 Term) (@x2 Term))
   (! (iff (= @x1 @x2) (Valid (Prims.eq2 @x0 @x1 @x2)))
    :pattern ((Prims.eq2 @x0 @x1 @x2))
    :qid eq2-interp))
  :named eq2-interp))
; data constructor typing intro
;;; Fact-ids: Name Prims.equals; Namespace Prims; Name Prims.Refl; Namespace Prims
(assert
 (! ;; def=Prims.fst(173,46-173,50); use=Prims.fst(173,46-173,50)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
   (! (implies
     (and (HasTypeFuel @u0 @x1 Tm_type) (HasTypeFuel @u0 @x2 @x1) (= @x2 @x3))
     (HasTypeFuel @u0 (Prims.Refl @x1 @x2) (Prims.equals @x1 @x2 @x3)))
    :pattern ((HasTypeFuel @u0 (Prims.Refl @x1 @x2) (Prims.equals @x1 @x2 @x3)))
    :qid data_typing_intro_Prims.Refl@tok))
  :named data_typing_intro_Prims.Refl@tok))
; data constructor typing elim
;;; Fact-ids: Name Prims.equals; Namespace Prims; Name Prims.Refl; Namespace Prims
(assert
 (! ;; def=Prims.fst(173,46-173,50); use=Prims.fst(173,46-173,50)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
   (! (implies
     (HasTypeFuel (SFuel @u0) (Prims.Refl @x1 @x2) (Prims.equals @x3 @x4 @x5))
     (and (= @x4 @x5) (HasTypeFuel @u0 @x3 Tm_type) (HasTypeFuel @u0 @x4 @x3)))
    :pattern ((HasTypeFuel (SFuel @u0) (Prims.Refl @x1 @x2) (Prims.equals @x3 @x4 @x5)))
    :qid data_elim_Prims.Refl))
  :named data_elim_Prims.Refl))
; Constructor distinct
;;; Fact-ids: Name Prims.equals; Namespace Prims; Name Prims.Refl; Namespace Prims
(assert
 (! ;; def=Prims.fst(173,5-173,11); use=Prims.fst(173,5-173,11)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term))
   (! (= 134 (Term_constr_id (Prims.equals @x0 @x1 @x2)))
    :pattern ((Prims.equals @x0 @x1 @x2))
    :qid constructor_distinct_Prims.equals))
  :named constructor_distinct_Prims.equals))
; Constructor distinct
;;; Fact-ids: Name Prims.equals; Namespace Prims; Name Prims.Refl; Namespace Prims
(assert
 (! ;; def=Prims.fst(173,46-173,50); use=Prims.fst(173,46-173,50)
  (forall ((@x0 Term) (@x1 Term))
   (! (= 141 (Term_constr_id (Prims.Refl @x0 @x1)))
    :pattern ((Prims.Refl @x0 @x1))
    :qid constructor_distinct_Prims.Refl))
  :named constructor_distinct_Prims.Refl))
; Constructor base
;;; Fact-ids: Name Prims.equals; Namespace Prims; Name Prims.Refl; Namespace Prims
(assert
 (! ;; def=Prims.fst(173,46-173,50); use=Prims.fst(173,46-173,50)
  (forall ((@x0 Term) (@x1 Term))
   (! (implies (is-Prims.Refl (Prims.Refl @x0 @x1)) (= (Prims.Refl @x0 @x1) Prims.Refl@base))
    :pattern ((Prims.Refl @x0 @x1))
    :qid constructor_base_Prims.Refl))
  :named constructor_base_Prims.Refl))
; pretyping
;;; Fact-ids: Name Prims.equals; Namespace Prims; Name Prims.Refl; Namespace Prims
(assert
 (! ;; def=Prims.fst(173,5-173,11); use=Prims.fst(173,5-173,11)
  (forall ((@x0 Term) (@u1 Fuel) (@x2 Term) (@x3 Term) (@x4 Term))
   (! (implies
     (HasTypeFuel @u1 @x0 (Prims.equals @x2 @x3 @x4))
     (= (Term_constr_id (Prims.equals @x2 @x3 @x4)) (Term_constr_id (PreType @x0))))
    :pattern ((HasTypeFuel @u1 @x0 (Prims.equals @x2 @x3 @x4)))
    :qid Prims_pretyping_b2d64ca214b8828a9eba2c140aea0816))
  :named Prims_pretyping_b2d64ca214b8828a9eba2c140aea0816))
(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(58,2-66,3)
(declare-fun label_6 () Bool)
(declare-fun label_5 () Bool)
(declare-fun label_4 () Bool)
(declare-fun label_3 () Bool)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; x5: Prims.int -> y6: Prims.int -> Type
(declare-fun Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0 () Term)
; kinding_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0
;;; Fact-ids: 
(assert
 (! (HasType Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0 Tm_type)
  :named kinding_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0))
; pre-typing for functions
;;; Fact-ids: 
(assert
 (! ;; def=Prims.fst(548,35-548,38); use=FStar.Math.Lemmas.fst(58,2-66,3)
  (forall ((@u0 Fuel) (@x1 Term))
   (! (implies
     (HasTypeFuel @u0 @x1 Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0)
     (is-Tm_arrow (PreType @x1)))
    :pattern ((HasTypeFuel @u0 @x1 Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0))
    :qid FStar.Math.Lemmas_pre_typing_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0))
  :named FStar.Math.Lemmas_pre_typing_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0))
; interpretation_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0
;;; Fact-ids: 
(assert
 (! ;; def=Prims.fst(548,35-548,38); use=FStar.Math.Lemmas.fst(58,2-66,3)
  (forall ((@x0 Term))
   (! (iff
     (HasTypeZ @x0 Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0)
     (and
      ;; def=Prims.fst(548,35-548,38); use=FStar.Math.Lemmas.fst(58,2-66,3)
      (forall ((@x1 Term) (@x2 Term))
       (! (implies
         (and (HasType @x1 Prims.int) (HasType @x2 Prims.int))
         (HasType (ApplyTT (ApplyTT @x0 @x1) @x2) Tm_type))
        :pattern ((ApplyTT (ApplyTT @x0 @x1) @x2))
        :qid FStar.Math.Lemmas_interpretation_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0.1))
      (IsTotFun @x0)
      ;; def=Prims.fst(548,35-548,38); use=FStar.Math.Lemmas.fst(58,2-66,3)
      (forall ((@x1 Term))
       (! (implies (HasType @x1 Prims.int) (IsTotFun (ApplyTT @x0 @x1)))
        :pattern ((ApplyTT @x0 @x1))
        :qid FStar.Math.Lemmas_interpretation_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0.2))))
    :pattern ((HasTypeZ @x0 Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0))
    :qid FStar.Math.Lemmas_interpretation_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0))
  :named FStar.Math.Lemmas_interpretation_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0))
(declare-fun Tm_abs_2d12df642cab58f318db60ed4861d203 () Term)
; typing_Tm_abs_2d12df642cab58f318db60ed4861d203
;;; Fact-ids: 
(assert
 (! (HasType Tm_abs_2d12df642cab58f318db60ed4861d203 Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0)
  :named typing_Tm_abs_2d12df642cab58f318db60ed4861d203))
; interpretation_Tm_abs_2d12df642cab58f318db60ed4861d203
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fst(60,2-60,4); use=FStar.Math.Lemmas.fst(58,2-66,3)
  (forall ((@x0 Term) (@x1 Term))
   (! (=
     (ApplyTT (ApplyTT Tm_abs_2d12df642cab58f318db60ed4861d203 @x0) @x1)
     (Prims.eq2 Prims.int @x0 @x1))
    :pattern ((ApplyTT (ApplyTT Tm_abs_2d12df642cab58f318db60ed4861d203 @x0) @x1))
    :qid interpretation_Tm_abs_2d12df642cab58f318db60ed4861d203))
  :named interpretation_Tm_abs_2d12df642cab58f318db60ed4861d203))
; _: Prims.unit -> FStar.Calc.calc_pack [fun x5 y6 -> x5 == y6 <: Type] (a * (b + c)) ((b + c) * a)
(declare-fun Tm_arrow_427e8fccd3f5c8770bedf8d39d2a37b5 (Term Term Term) Term)
; kinding_Tm_arrow_427e8fccd3f5c8770bedf8d39d2a37b5
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(58,2-66,3)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term))
   (! (HasType (Tm_arrow_427e8fccd3f5c8770bedf8d39d2a37b5 @x0 @x1 @x2) Tm_type)
    :pattern ((HasType (Tm_arrow_427e8fccd3f5c8770bedf8d39d2a37b5 @x0 @x1 @x2) Tm_type))
    :qid kinding_Tm_arrow_427e8fccd3f5c8770bedf8d39d2a37b5))
  :named kinding_Tm_arrow_427e8fccd3f5c8770bedf8d39d2a37b5))
; pre-typing for functions
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(58,2-66,3)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
   (! (implies
     (HasTypeFuel @u0 @x1 (Tm_arrow_427e8fccd3f5c8770bedf8d39d2a37b5 @x2 @x3 @x4))
     (is-Tm_arrow (PreType @x1)))
    :pattern ((HasTypeFuel @u0 @x1 (Tm_arrow_427e8fccd3f5c8770bedf8d39d2a37b5 @x2 @x3 @x4)))
    :qid FStar.Math.Lemmas_pre_typing_Tm_arrow_427e8fccd3f5c8770bedf8d39d2a37b5))
  :named FStar.Math.Lemmas_pre_typing_Tm_arrow_427e8fccd3f5c8770bedf8d39d2a37b5))
; interpretation_Tm_arrow_427e8fccd3f5c8770bedf8d39d2a37b5
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(58,2-66,3)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
   (! (iff
     (HasTypeZ @x0 (Tm_arrow_427e8fccd3f5c8770bedf8d39d2a37b5 @x1 @x2 @x3))
     (and
      ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(58,2-66,3)
      (forall ((@x4 Term))
       (! (implies
         (HasType @x4 Prims.unit)
         (HasType
          (ApplyTT @x0 @x4)
          (FStar.Calc.calc_pack
           Prims.int
           (Prims.Cons
            (FStar.Preorder.relation Prims.int)
            Tm_abs_2d12df642cab58f318db60ed4861d203
            (Prims.Nil (FStar.Preorder.relation Prims.int)))
           (Prims.op_Multiply @x3 (Prims.op_Addition @x2 @x1))
           (Prims.op_Multiply (Prims.op_Addition @x2 @x1) @x3))))
        :pattern ((ApplyTT @x0 @x4))
        :qid FStar.Math.Lemmas_interpretation_Tm_arrow_427e8fccd3f5c8770bedf8d39d2a37b5.1))
      (IsTotFun @x0)))
    :pattern ((HasTypeZ @x0 (Tm_arrow_427e8fccd3f5c8770bedf8d39d2a37b5 @x1 @x2 @x3)))
    :qid FStar.Math.Lemmas_interpretation_Tm_arrow_427e8fccd3f5c8770bedf8d39d2a37b5))
  :named FStar.Math.Lemmas_interpretation_Tm_arrow_427e8fccd3f5c8770bedf8d39d2a37b5))




; _: Prims.unit   -> FStar.Calc.calc_pack [(fun x7 y8 -> x7 == y8 <: Type); fun x5 y6 -> x5 == y6 <: Type]       (a * (b + c))       (b * a + c * a)
(declare-fun Tm_arrow_3ad6ee20865d35db39eda7ab199246aa (Term Term Term) Term)
; kinding_Tm_arrow_3ad6ee20865d35db39eda7ab199246aa
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(58,2-66,3)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term))
   (! (HasType (Tm_arrow_3ad6ee20865d35db39eda7ab199246aa @x0 @x1 @x2) Tm_type)
    :pattern ((HasType (Tm_arrow_3ad6ee20865d35db39eda7ab199246aa @x0 @x1 @x2) Tm_type))
    :qid kinding_Tm_arrow_3ad6ee20865d35db39eda7ab199246aa))
  :named kinding_Tm_arrow_3ad6ee20865d35db39eda7ab199246aa))
; pre-typing for functions
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(58,2-66,3)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
   (! (implies
     (HasTypeFuel @u0 @x1 (Tm_arrow_3ad6ee20865d35db39eda7ab199246aa @x2 @x3 @x4))
     (is-Tm_arrow (PreType @x1)))
    :pattern ((HasTypeFuel @u0 @x1 (Tm_arrow_3ad6ee20865d35db39eda7ab199246aa @x2 @x3 @x4)))
    :qid FStar.Math.Lemmas_pre_typing_Tm_arrow_3ad6ee20865d35db39eda7ab199246aa))
  :named FStar.Math.Lemmas_pre_typing_Tm_arrow_3ad6ee20865d35db39eda7ab199246aa))
; interpretation_Tm_arrow_3ad6ee20865d35db39eda7ab199246aa
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(58,2-66,3)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
   (! (iff
     (HasTypeZ @x0 (Tm_arrow_3ad6ee20865d35db39eda7ab199246aa @x1 @x2 @x3))
     (and
      ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(58,2-66,3)
      (forall ((@x4 Term))
       (! (implies
         (HasType @x4 Prims.unit)
         (HasType
          (ApplyTT @x0 @x4)
          (FStar.Calc.calc_pack
           Prims.int
           (Prims.Cons
            (FStar.Preorder.relation Prims.int)
            Tm_abs_2d12df642cab58f318db60ed4861d203
            (Prims.Cons
             (FStar.Preorder.relation Prims.int)
             Tm_abs_2d12df642cab58f318db60ed4861d203
             (Prims.Nil (FStar.Preorder.relation Prims.int))))
           (Prims.op_Multiply @x3 (Prims.op_Addition @x2 @x1))
           (Prims.op_Addition (Prims.op_Multiply @x2 @x3) (Prims.op_Multiply @x1 @x3)))))
        :pattern ((ApplyTT @x0 @x4))
        :qid FStar.Math.Lemmas_interpretation_Tm_arrow_3ad6ee20865d35db39eda7ab199246aa.1))
      (IsTotFun @x0)))
    :pattern ((HasTypeZ @x0 (Tm_arrow_3ad6ee20865d35db39eda7ab199246aa @x1 @x2 @x3)))
    :qid FStar.Math.Lemmas_interpretation_Tm_arrow_3ad6ee20865d35db39eda7ab199246aa))
  :named FStar.Math.Lemmas_interpretation_Tm_arrow_3ad6ee20865d35db39eda7ab199246aa))






; _: Prims.unit   -> FStar.Calc.calc_pack [         (fun x9 y10 -> x9 == y10 <: Type);         (fun x7 y8 -> x7 == y8 <: Type);         fun x5 y6 -> x5 == y6 <: Type       ]       (a * (b + c))       (a * b + a * c)
(declare-fun Tm_arrow_876356dfb7fd8352232e5639b7cb6de0 (Term Term Term) Term)
; kinding_Tm_arrow_876356dfb7fd8352232e5639b7cb6de0
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(81,6-81,36); use=FStar.Math.Lemmas.fst(58,2-66,3)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term))
   (! (HasType (Tm_arrow_876356dfb7fd8352232e5639b7cb6de0 @x0 @x1 @x2) Tm_type)
    :pattern ((HasType (Tm_arrow_876356dfb7fd8352232e5639b7cb6de0 @x0 @x1 @x2) Tm_type))
    :qid kinding_Tm_arrow_876356dfb7fd8352232e5639b7cb6de0))
  :named kinding_Tm_arrow_876356dfb7fd8352232e5639b7cb6de0))
; pre-typing for functions
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(81,6-81,36); use=FStar.Math.Lemmas.fst(58,2-66,3)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
   (! (implies
     (HasTypeFuel @u0 @x1 (Tm_arrow_876356dfb7fd8352232e5639b7cb6de0 @x2 @x3 @x4))
     (is-Tm_arrow (PreType @x1)))
    :pattern ((HasTypeFuel @u0 @x1 (Tm_arrow_876356dfb7fd8352232e5639b7cb6de0 @x2 @x3 @x4)))
    :qid FStar.Math.Lemmas_pre_typing_Tm_arrow_876356dfb7fd8352232e5639b7cb6de0))
  :named FStar.Math.Lemmas_pre_typing_Tm_arrow_876356dfb7fd8352232e5639b7cb6de0))
; interpretation_Tm_arrow_876356dfb7fd8352232e5639b7cb6de0
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(81,6-81,36); use=FStar.Math.Lemmas.fst(58,2-66,3)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
   (! (iff
     (HasTypeZ @x0 (Tm_arrow_876356dfb7fd8352232e5639b7cb6de0 @x1 @x2 @x3))
     (and
      ;; def=FStar.Calc.fsti(81,6-81,36); use=FStar.Math.Lemmas.fst(58,2-66,3)
      (forall ((@x4 Term))
       (! (implies
         (HasType @x4 Prims.unit)
         (HasType
          (ApplyTT @x0 @x4)
          (FStar.Calc.calc_pack
           Prims.int
           (Prims.Cons
            (FStar.Preorder.relation Prims.int)
            Tm_abs_2d12df642cab58f318db60ed4861d203
            (Prims.Cons
             (FStar.Preorder.relation Prims.int)
             Tm_abs_2d12df642cab58f318db60ed4861d203
             (Prims.Cons
              (FStar.Preorder.relation Prims.int)
              Tm_abs_2d12df642cab58f318db60ed4861d203
              (Prims.Nil (FStar.Preorder.relation Prims.int)))))
           (Prims.op_Multiply @x3 (Prims.op_Addition @x2 @x1))
           (Prims.op_Addition (Prims.op_Multiply @x3 @x2) (Prims.op_Multiply @x3 @x1)))))
        :pattern ((ApplyTT @x0 @x4))
        :qid FStar.Math.Lemmas_interpretation_Tm_arrow_876356dfb7fd8352232e5639b7cb6de0.1))
      (IsTotFun @x0)))
    :pattern ((HasTypeZ @x0 (Tm_arrow_876356dfb7fd8352232e5639b7cb6de0 @x1 @x2 @x3)))
    :qid FStar.Math.Lemmas_interpretation_Tm_arrow_876356dfb7fd8352232e5639b7cb6de0))
  :named FStar.Math.Lemmas_interpretation_Tm_arrow_876356dfb7fd8352232e5639b7cb6de0))
; Encoding query formula : forall (a: Prims.int) (b: Prims.int) (c: Prims.int).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     (forall (pure_result: Prims.unit). a * (b + c) = a * b + a * c ==> p pure_result) ==>
;     (forall (_: Prims.unit).
;         (*  - Could not prove post-condition
; *)
;         (forall (_: Prims.unit).
;             (*  - Could not prove post-condition
; *)
;             (forall (_: Prims.unit).
;                 (*  - Could not prove post-condition
; *)
;                 forall (_: Prims.unit).
;                   (*  - Could not prove post-condition
; *) a * (b + c) == (b + c) * a) /\
;             (forall (any_result:
;                 (_: Prims.unit
;                     -> FStar.Calc.calc_pack [fun x5 y6 -> x5 == y6 <: Type0]
;                         (a * (b + c))
;                         ((b + c) * a)))
;                 (_: Prims.unit).
;                 (*  - Could not prove post-condition
; *)
;                 forall (pure_result: Prims.unit).
;                   (b + c) * a = b * a + c * a ==> (b + c) * a == b * a + c * a)) /\
;         (forall (any_result:
;             (_: Prims.unit
;                 -> FStar.Calc.calc_pack [
;                       (fun x7 y8 -> x7 == y8 <: Type0);
;                       fun x5 y6 -> x5 == y6 <: Type0
;                     ]
;                     (a * (b + c))
;                     (b * a + c * a)))
;             (_: Prims.unit).
;             (*  - Could not prove post-condition
; *) b * a + c * a == a * b + a * c)) /\
;     (forall (any_result:
;         (_: Prims.unit
;             -> FStar.Calc.calc_pack [
;                   (fun x9 y10 -> x9 == y10 <: Type0);
;                   (fun x7 y8 -> x7 == y8 <: Type0);
;                   fun x5 y6 -> x5 == y6 <: Type0
;                 ]
;                 (a * (b + c))
;                 (a * b + a * c))).
;         FStar.Range.labeled (FStar.Sealed.seal FStar.Calc.fsti(86,37-86,50))
;           "Could not prove that this calc-chain is compatible"
;           (forall (x: Prims.int) (y: Prims.int).
;               (exists (w: Prims.int).
;                   (exists (w: Prims.int). (exists (w: Prims.int). x == w /\ w == w) /\ w == w) /\
;                   w == y) ==>
;               x == y) /\
;         (forall (pure_result: Prims.unit). a * (b + c) == a * b + a * c ==> p pure_result))
; Context: While encoding a query
; While typechecking the top-level declaration `let distributivity_add_right`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term) (@x2 Term))
    (! (implies
      (and (HasType @x0 Prims.int) (HasType @x1 Prims.int) (HasType @x2 Prims.int))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x3 Term))
       (! (implies
         (and
          (HasType @x3 (Prims.pure_post Prims.unit))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(58,2-66,3)
          (forall ((@x4 Term))
           (! (implies
             (and
              (or label_1 (HasType @x4 Prims.unit))
              ;; def=FStar.Math.Lemmas.fsti(58,2-58,31); use=FStar.Math.Lemmas.fst(58,2-66,3)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fsti(58,2-58,31); use=FStar.Math.Lemmas.fst(58,2-66,3)
               (=
                (Prims.op_Multiply @x0 (Prims.op_Addition @x1 @x2))
                (Prims.op_Addition (Prims.op_Multiply @x0 @x1) (Prims.op_Multiply @x0 @x2)))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(58,2-66,3)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(58,2-66,3)
              (ApplyTT @x3 @x4)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(58,2-66,3)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(58,2-66,3)
               (ApplyTT @x3 @x4)))
            :qid @query.2)))
         ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(58,2-66,3)
         (and
          ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(58,2-66,3)
          (forall ((@x4 Term))
           (! (implies
             (HasType @x4 Prims.unit)
             ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(58,2-66,3)
             (and
              ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(58,2-66,3)
              (forall ((@x5 Term))
               (! (implies
                 (HasType @x5 Prims.unit)
                 ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(58,2-66,3)
                 (and
                  ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(58,2-66,3)
                  (forall ((@x6 Term))
                   (! (implies
                     (HasType @x6 Prims.unit)
                     ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(58,2-66,3)
                     (forall ((@x7 Term))
                      (! (implies
                        (HasType @x7 Prims.unit)
                        ;; def=FStar.Math.Lemmas.fst(60,2-60,4); use=FStar.Math.Lemmas.fst(60,5-60,7)
                        (or
                         label_3
                         ;; def=FStar.Math.Lemmas.fst(60,2-60,4); use=FStar.Math.Lemmas.fst(60,5-60,7)
                         (=
                          (Prims.op_Multiply @x0 (Prims.op_Addition @x1 @x2))
                          (Prims.op_Multiply (Prims.op_Addition @x1 @x2) @x0))))
                       :qid @query.6)))
                    :qid @query.5))
                  ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(58,2-66,3)
                  (forall ((@x6 Term))
                   (! (implies
                     (HasType @x6 (Tm_arrow_427e8fccd3f5c8770bedf8d39d2a37b5 @x2 @x1 @x0))
                     ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(58,2-66,3)
                     (forall ((@x7 Term))
                      (! (implies
                        (HasType @x7 Prims.unit)
                        ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(62,7-62,30)
                        (forall ((@x8 Term))
                         (! (implies
                           (and
                            (HasType @x8 Prims.unit)
                            ;; def=FStar.Math.Lemmas.fsti(54,2-54,31); use=FStar.Math.Lemmas.fst(62,7-62,30)
                            (=
                             (Prims.op_Multiply (Prims.op_Addition @x1 @x2) @x0)
                             (Prims.op_Addition
                              (Prims.op_Multiply @x1 @x0)
                              (Prims.op_Multiply @x2 @x0))))
                           ;; def=FStar.Math.Lemmas.fst(62,2-62,4); use=FStar.Math.Lemmas.fst(62,7-62,36)
                           (or
                            label_4
                            ;; def=FStar.Math.Lemmas.fst(62,2-62,4); use=FStar.Math.Lemmas.fst(62,7-62,36)
                            (=
                             (Prims.op_Multiply (Prims.op_Addition @x1 @x2) @x0)
                             (Prims.op_Addition
                              (Prims.op_Multiply @x1 @x0)
                              (Prims.op_Multiply @x2 @x0)))))
                          :qid @query.9)))
                       :qid @query.8)))
                    :qid @query.7))))
                :qid @query.4))
              ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(58,2-66,3)
              (forall ((@x5 Term))
               (! (implies
                 (HasType @x5 (Tm_arrow_3ad6ee20865d35db39eda7ab199246aa @x2 @x1 @x0))
                 ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(58,2-66,3)
                 (forall ((@x6 Term))
                  (! (implies
                    (HasType @x6 Prims.unit)
                    ;; def=FStar.Math.Lemmas.fst(64,2-64,4); use=FStar.Math.Lemmas.fst(64,5-64,7)
                    (or
                     label_5
                     ;; def=FStar.Math.Lemmas.fst(64,2-64,4); use=FStar.Math.Lemmas.fst(64,5-64,7)
                     (=
                      (Prims.op_Addition (Prims.op_Multiply @x1 @x0) (Prims.op_Multiply @x2 @x0))
                      (Prims.op_Addition (Prims.op_Multiply @x0 @x1) (Prims.op_Multiply @x0 @x2)))))
                   :qid @query.11)))
                :qid @query.10))))
            :qid @query.3))
          ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(58,2-66,3)
          (forall ((@x4 Term))
           (! (implies
             (HasType @x4 (Tm_arrow_876356dfb7fd8352232e5639b7cb6de0 @x2 @x1 @x0))
             ;; def=Prims.fst(449,29-449,97); use=FStar.Math.Lemmas.fst(58,2-66,3)
             (and
              ;; def=FStar.Calc.fsti(47,4-47,55); use=FStar.Calc.fsti(47,4-47,55)
              (forall ((@x5 Term) (@x6 Term))
               (! (implies
                 (and
                  (HasType @x5 Prims.int)
                  (HasType @x6 Prims.int)
                  ;; def=FStar.Calc.fsti(42,16-42,65); use=FStar.Calc.fsti(42,16-42,65)
                  (exists ((@x7 Term))
                   (! (and
                     (HasType @x7 Prims.int)
                     ;; def=FStar.Calc.fsti(42,16-42,65); use=FStar.Calc.fsti(42,16-42,65)
                     (exists ((@x8 Term))
                      (! (and
                        (HasType @x8 Prims.int)
                        ;; def=FStar.Calc.fsti(42,16-42,65); use=FStar.Calc.fsti(42,16-42,65)
                        (exists ((@x9 Term))
                         (! (and
                           (HasType @x9 Prims.int)
                           ;; def=FStar.Calc.fsti(40,12-40,18); use=FStar.Calc.fsti(40,12-40,18)
                           (= @x5 @x9)
                           ;; def=FStar.Math.Lemmas.fst(60,2-60,4); use=FStar.Math.Lemmas.fst(58,2-66,3)
                           (= @x9 @x8))
                          :qid @query.16))
                        ;; def=FStar.Math.Lemmas.fst(62,2-62,4); use=FStar.Math.Lemmas.fst(58,2-66,3)
                        (= @x8 @x7))
                       :qid @query.15))
                     ;; def=FStar.Math.Lemmas.fst(64,2-64,4); use=FStar.Math.Lemmas.fst(58,2-66,3)
                     (= @x7 @x6))
                    :qid @query.14)))
                 ;; def=FStar.Math.Lemmas.fst(58,7-58,11); use=FStar.Math.Lemmas.fst(58,2-66,3)
                 (or
                  label_6
                  ;; def=FStar.Math.Lemmas.fst(58,7-58,11); use=FStar.Math.Lemmas.fst(58,2-66,3)
                  (= @x5 @x6)))
                :qid @query.13))
              ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(58,2-66,3)
              (forall ((@x5 Term))
               (! (implies
                 (and
                  (HasType @x5 Prims.unit)
                  ;; def=FStar.Math.Lemmas.fst(58,7-58,11); use=FStar.Math.Lemmas.fst(58,2-66,3)
                  (=
                   (Prims.op_Multiply @x0 (Prims.op_Addition @x1 @x2))
                   (Prims.op_Addition (Prims.op_Multiply @x0 @x1) (Prims.op_Multiply @x0 @x2))))
                 ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(58,2-66,3)
                 (Valid
                  ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(58,2-66,3)
                  (ApplyTT @x3 @x5)))
                :qid @query.17))))
            :qid @query.12))))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_6")
(eval label_6)
(echo "label_5")
(eval label_5)
(echo "label_4")
(eval label_4)
(echo "label_3")
(eval label_3)
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.distributivity_add_right, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let distributivity_add_right
; <Start encoding let distributivity_add_right>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.distributivity_add_right (Term Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.distributivity_add_right@tok () Term)
; </end encoding let distributivity_add_right>

; encoding sigelt val FStar.Math.Lemmas.paren_mul_left
; <Skipped val FStar.Math.Lemmas.paren_mul_left/>

; encoding sigelt let paren_mul_left
; <Start encoding let paren_mul_left>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.paren_mul_left (Term Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.paren_mul_left@tok () Term)
; </end encoding let paren_mul_left>

; encoding sigelt val FStar.Math.Lemmas.paren_mul_right
; <Skipped val FStar.Math.Lemmas.paren_mul_right/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(73,28-73,30)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (a: Prims.int) (b: Prims.int) (c: Prims.int).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     (forall (pure_result: Prims.unit). a * b * c = a * (b * c) ==> p pure_result) ==>
;     (forall (any_result: Prims.unit). p any_result)
; Context: While encoding a query
; While typechecking the top-level declaration `let paren_mul_right`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term) (@x2 Term))
    (! (implies
      (and (HasType @x0 Prims.int) (HasType @x1 Prims.int) (HasType @x2 Prims.int))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x3 Term))
       (! (implies
         (and
          (HasType @x3 (Prims.pure_post Prims.unit))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(73,28-73,30)
          (forall ((@x4 Term))
           (! (implies
             (and
              (or label_1 (HasType @x4 Prims.unit))
              ;; def=FStar.Math.Lemmas.fsti(67,2-67,27); use=FStar.Math.Lemmas.fst(73,28-73,30)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fsti(67,2-67,27); use=FStar.Math.Lemmas.fst(73,28-73,30)
               (=
                (Prims.op_Multiply (Prims.op_Multiply @x0 @x1) @x2)
                (Prims.op_Multiply @x0 (Prims.op_Multiply @x1 @x2)))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(73,28-73,30)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(73,28-73,30)
              (ApplyTT @x3 @x4)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(73,28-73,30)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(73,28-73,30)
               (ApplyTT @x3 @x4)))
            :qid @query.2)))
         ;; def=Prims.fst(459,66-459,102); use=Prims.fst(462,31-462,44)
         (forall ((@x4 Term))
          (! (implies
            (HasType @x4 Prims.unit)
            ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
            (Valid
             ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
             (ApplyTT @x3 @x4)))
           :qid @query.3)))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.paren_mul_right, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let paren_mul_right
; <Start encoding let paren_mul_right>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.paren_mul_right (Term Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.paren_mul_right@tok () Term)
; </end encoding let paren_mul_right>

; encoding sigelt val FStar.Math.Lemmas.paren_add_left
; <Skipped val FStar.Math.Lemmas.paren_add_left/>

; encoding sigelt let paren_add_left
; <Start encoding let paren_add_left>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.paren_add_left (Term Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.paren_add_left@tok () Term)
; </end encoding let paren_add_left>

; encoding sigelt val FStar.Math.Lemmas.paren_add_right
; <Skipped val FStar.Math.Lemmas.paren_add_right/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(79,28-79,30)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (a: Prims.int) (b: Prims.int) (c: Prims.int).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     (forall (pure_result: Prims.unit). a + b + c = a + (b + c) ==> p pure_result) ==>
;     (forall (any_result: Prims.unit). p any_result)
; Context: While encoding a query
; While typechecking the top-level declaration `let paren_add_right`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term) (@x2 Term))
    (! (implies
      (and (HasType @x0 Prims.int) (HasType @x1 Prims.int) (HasType @x2 Prims.int))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x3 Term))
       (! (implies
         (and
          (HasType @x3 (Prims.pure_post Prims.unit))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(79,28-79,30)
          (forall ((@x4 Term))
           (! (implies
             (and
              (or label_1 (HasType @x4 Prims.unit))
              ;; def=FStar.Math.Lemmas.fsti(75,2-75,27); use=FStar.Math.Lemmas.fst(79,28-79,30)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fsti(75,2-75,27); use=FStar.Math.Lemmas.fst(79,28-79,30)
               (=
                (Prims.op_Addition (Prims.op_Addition @x0 @x1) @x2)
                (Prims.op_Addition @x0 (Prims.op_Addition @x1 @x2)))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(79,28-79,30)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(79,28-79,30)
              (ApplyTT @x3 @x4)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(79,28-79,30)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(79,28-79,30)
               (ApplyTT @x3 @x4)))
            :qid @query.2)))
         ;; def=Prims.fst(459,66-459,102); use=Prims.fst(462,31-462,44)
         (forall ((@x4 Term))
          (! (implies
            (HasType @x4 Prims.unit)
            ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
            (Valid
             ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
             (ApplyTT @x3 @x4)))
           :qid @query.3)))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.paren_add_right, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let paren_add_right
; <Start encoding let paren_add_right>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.paren_add_right (Term Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.paren_add_right@tok () Term)
; </end encoding let paren_add_right>

; encoding sigelt val FStar.Math.Lemmas.addition_is_associative
; <Skipped val FStar.Math.Lemmas.addition_is_associative/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(81,36-81,38)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (a: Prims.int) (b: Prims.int) (c: Prims.int).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     (forall (pure_result: Prims.unit). a + b + c = a + (b + c) ==> p pure_result) ==>
;     (forall (any_result: Prims.unit). p any_result)
; Context: While encoding a query
; While typechecking the top-level declaration `let addition_is_associative`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term) (@x2 Term))
    (! (implies
      (and (HasType @x0 Prims.int) (HasType @x1 Prims.int) (HasType @x2 Prims.int))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x3 Term))
       (! (implies
         (and
          (HasType @x3 (Prims.pure_post Prims.unit))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(81,36-81,38)
          (forall ((@x4 Term))
           (! (implies
             (and
              (or label_1 (HasType @x4 Prims.unit))
              ;; def=FStar.Math.Lemmas.fsti(78,30-78,53); use=FStar.Math.Lemmas.fst(81,36-81,38)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fsti(78,30-78,53); use=FStar.Math.Lemmas.fst(81,36-81,38)
               (=
                (Prims.op_Addition (Prims.op_Addition @x0 @x1) @x2)
                (Prims.op_Addition @x0 (Prims.op_Addition @x1 @x2)))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(81,36-81,38)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(81,36-81,38)
              (ApplyTT @x3 @x4)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(81,36-81,38)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(81,36-81,38)
               (ApplyTT @x3 @x4)))
            :qid @query.2)))
         ;; def=Prims.fst(459,66-459,102); use=Prims.fst(462,31-462,44)
         (forall ((@x4 Term))
          (! (implies
            (HasType @x4 Prims.unit)
            ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
            (Valid
             ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
             (ApplyTT @x3 @x4)))
           :qid @query.3)))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.addition_is_associative, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let addition_is_associative
; <Start encoding let addition_is_associative>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.addition_is_associative (Term Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.addition_is_associative@tok () Term)
; </end encoding let addition_is_associative>

; encoding sigelt val FStar.Math.Lemmas.subtraction_is_distributive
; <Skipped val FStar.Math.Lemmas.subtraction_is_distributive/>

;;; Fact-ids: Name Prims.op_Minus; Namespace Prims
(assert
 (! ;; def=Prims.fst(566,4-566,12); use=Prims.fst(566,4-566,12)
  (forall ((@x0 Term))
   (! (= (Prims.op_Minus @x0) (BoxInt (- (BoxInt_proj_0 @x0))))
    :pattern ((Prims.op_Minus @x0))
    :qid primitive_Prims.op_Minus))
  :named primitive_Prims.op_Minus))
(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(83,40-83,42)
(declare-fun label_4 () Bool)
(declare-fun label_3 () Bool)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (a: Prims.int) (b: Prims.int) (c: Prims.int).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     (forall (pure_result: Prims.unit).
;         a - b - c = a - (b + c) /\ a + (- b - c) = a - b - c /\ a - (b - c) = a - b + c ==>
;         p pure_result) ==>
;     (forall (any_result: Prims.unit). p any_result)
; Context: While encoding a query
; While typechecking the top-level declaration `let subtraction_is_distributive`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term) (@x2 Term))
    (! (implies
      (and (HasType @x0 Prims.int) (HasType @x1 Prims.int) (HasType @x2 Prims.int))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x3 Term))
       (! (implies
         (and
          (HasType @x3 (Prims.pure_post Prims.unit))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(83,40-83,42)
          (forall ((@x4 Term))
           (! (implies
             (and
              (or label_1 (HasType @x4 Prims.unit))
              ;; def=FStar.Math.Lemmas.fsti(82,3-82,26); use=FStar.Math.Lemmas.fst(83,40-83,42)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fsti(82,3-82,26); use=FStar.Math.Lemmas.fst(83,40-83,42)
               (=
                (Prims.op_Subtraction (Prims.op_Subtraction @x0 @x1) @x2)
                (Prims.op_Subtraction @x0 (Prims.op_Addition @x1 @x2))))
              ;; def=FStar.Math.Lemmas.fsti(84,3-84,27); use=FStar.Math.Lemmas.fst(83,40-83,42)
              (or
               label_3
               ;; def=FStar.Math.Lemmas.fsti(84,3-84,27); use=FStar.Math.Lemmas.fst(83,40-83,42)
               (=
                (Prims.op_Addition @x0 (Prims.op_Subtraction (Prims.op_Minus @x1) @x2))
                (Prims.op_Subtraction (Prims.op_Subtraction @x0 @x1) @x2)))
              ;; def=FStar.Math.Lemmas.fsti(85,3-85,26); use=FStar.Math.Lemmas.fst(83,40-83,42)
              (or
               label_4
               ;; def=FStar.Math.Lemmas.fsti(85,3-85,26); use=FStar.Math.Lemmas.fst(83,40-83,42)
               (=
                (Prims.op_Subtraction @x0 (Prims.op_Subtraction @x1 @x2))
                (Prims.op_Addition (Prims.op_Subtraction @x0 @x1) @x2))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(83,40-83,42)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(83,40-83,42)
              (ApplyTT @x3 @x4)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(83,40-83,42)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(83,40-83,42)
               (ApplyTT @x3 @x4)))
            :qid @query.2)))
         ;; def=Prims.fst(459,66-459,102); use=Prims.fst(462,31-462,44)
         (forall ((@x4 Term))
          (! (implies
            (HasType @x4 Prims.unit)
            ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
            (Valid
             ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
             (ApplyTT @x3 @x4)))
           :qid @query.3)))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_4")
(eval label_4)
(echo "label_3")
(eval label_3)
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.subtraction_is_distributive, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let subtraction_is_distributive
; <Start encoding let subtraction_is_distributive>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.subtraction_is_distributive (Term Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.subtraction_is_distributive@tok () Term)
; </end encoding let subtraction_is_distributive>

; encoding sigelt val FStar.Math.Lemmas.swap_add_plus_minus
; <Skipped val FStar.Math.Lemmas.swap_add_plus_minus/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(85,32-85,34)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (a: Prims.int) (b: Prims.int) (c: Prims.int).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     (forall (pure_result: Prims.unit). a + b - c = a - c + b ==> p pure_result) ==>
;     (forall (any_result: Prims.unit). p any_result)
; Context: While encoding a query
; While typechecking the top-level declaration `let swap_add_plus_minus`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term) (@x2 Term))
    (! (implies
      (and (HasType @x0 Prims.int) (HasType @x1 Prims.int) (HasType @x2 Prims.int))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x3 Term))
       (! (implies
         (and
          (HasType @x3 (Prims.pure_post Prims.unit))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(85,32-85,34)
          (forall ((@x4 Term))
           (! (implies
             (and
              (or label_1 (HasType @x4 Prims.unit))
              ;; def=FStar.Math.Lemmas.fsti(88,2-88,27); use=FStar.Math.Lemmas.fst(85,32-85,34)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fsti(88,2-88,27); use=FStar.Math.Lemmas.fst(85,32-85,34)
               (=
                (Prims.op_Subtraction (Prims.op_Addition @x0 @x1) @x2)
                (Prims.op_Addition (Prims.op_Subtraction @x0 @x2) @x1))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(85,32-85,34)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(85,32-85,34)
              (ApplyTT @x3 @x4)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(85,32-85,34)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(85,32-85,34)
               (ApplyTT @x3 @x4)))
            :qid @query.2)))
         ;; def=Prims.fst(459,66-459,102); use=Prims.fst(462,31-462,44)
         (forall ((@x4 Term))
          (! (implies
            (HasType @x4 Prims.unit)
            ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
            (Valid
             ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
             (ApplyTT @x3 @x4)))
           :qid @query.3)))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.swap_add_plus_minus, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let swap_add_plus_minus
; <Start encoding let swap_add_plus_minus>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.swap_add_plus_minus (Term Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.swap_add_plus_minus@tok () Term)
; </end encoding let swap_add_plus_minus>

; encoding sigelt val FStar.Math.Lemmas.neg_mul_left
; <Skipped val FStar.Math.Lemmas.neg_mul_left/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(88,23-88,25)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (a: Prims.int) (b: Prims.int).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     (forall (pure_result: Prims.unit). - a * b = (- a) * b ==> p pure_result) ==>
;     (forall (any_result: Prims.unit). p any_result)
; Context: While encoding a query
; While typechecking the top-level declaration `let neg_mul_left`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term))
    (! (implies
      (and (HasType @x0 Prims.int) (HasType @x1 Prims.int))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x2 Term))
       (! (implies
         (and
          (HasType @x2 (Prims.pure_post Prims.unit))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(88,23-88,25)
          (forall ((@x3 Term))
           (! (implies
             (and
              (or label_1 (HasType @x3 Prims.unit))
              ;; def=FStar.Math.Lemmas.fsti(91,42-91,63); use=FStar.Math.Lemmas.fst(88,23-88,25)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fsti(91,42-91,63); use=FStar.Math.Lemmas.fst(88,23-88,25)
               (=
                (Prims.op_Minus (Prims.op_Multiply @x0 @x1))
                (Prims.op_Multiply (Prims.op_Minus @x0) @x1))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(88,23-88,25)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(88,23-88,25)
              (ApplyTT @x2 @x3)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(88,23-88,25)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(88,23-88,25)
               (ApplyTT @x2 @x3)))
            :qid @query.2)))
         ;; def=Prims.fst(459,66-459,102); use=Prims.fst(462,31-462,44)
         (forall ((@x3 Term))
          (! (implies
            (HasType @x3 Prims.unit)
            ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
            (Valid
             ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
             (ApplyTT @x2 @x3)))
           :qid @query.3)))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.neg_mul_left, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let neg_mul_left
; <Start encoding let neg_mul_left>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.neg_mul_left (Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.neg_mul_left@tok () Term)
; </end encoding let neg_mul_left>

; encoding sigelt val FStar.Math.Lemmas.neg_mul_right
; <Skipped val FStar.Math.Lemmas.neg_mul_right/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(91,24-91,26)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (a: Prims.int) (b: Prims.int).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     (forall (pure_result: Prims.unit). - a * b = a * (- b) ==> p pure_result) ==>
;     (forall (any_result: Prims.unit). p any_result)
; Context: While encoding a query
; While typechecking the top-level declaration `let neg_mul_right`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term))
    (! (implies
      (and (HasType @x0 Prims.int) (HasType @x1 Prims.int))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x2 Term))
       (! (implies
         (and
          (HasType @x2 (Prims.pure_post Prims.unit))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(91,24-91,26)
          (forall ((@x3 Term))
           (! (implies
             (and
              (or label_1 (HasType @x3 Prims.unit))
              ;; def=FStar.Math.Lemmas.fsti(94,43-94,64); use=FStar.Math.Lemmas.fst(91,24-91,26)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fsti(94,43-94,64); use=FStar.Math.Lemmas.fst(91,24-91,26)
               (=
                (Prims.op_Minus (Prims.op_Multiply @x0 @x1))
                (Prims.op_Multiply @x0 (Prims.op_Minus @x1)))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(91,24-91,26)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(91,24-91,26)
              (ApplyTT @x2 @x3)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(91,24-91,26)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(91,24-91,26)
               (ApplyTT @x2 @x3)))
            :qid @query.2)))
         ;; def=Prims.fst(459,66-459,102); use=Prims.fst(462,31-462,44)
         (forall ((@x3 Term))
          (! (implies
            (HasType @x3 Prims.unit)
            ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
            (Valid
             ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
             (ApplyTT @x2 @x3)))
           :qid @query.3)))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.neg_mul_right, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let neg_mul_right
; <Start encoding let neg_mul_right>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.neg_mul_right (Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.neg_mul_right@tok () Term)
; </end encoding let neg_mul_right>

; encoding sigelt val FStar.Math.Lemmas.swap_neg_mul
; <Skipped val FStar.Math.Lemmas.swap_neg_mul/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(94,2-95,19)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (a: Prims.int) (b: Prims.int).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     (forall (pure_result: Prims.unit). (- a) * b = a * (- b) ==> p pure_result) ==>
;     (forall (pure_result: Prims.unit).
;         - a * b = (- a) * b ==>
;         (forall (pure_result: Prims.unit). - a * b = a * (- b) ==> p pure_result))
; Context: While encoding a query
; While typechecking the top-level declaration `let swap_neg_mul`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term))
    (! (implies
      (and (HasType @x0 Prims.int) (HasType @x1 Prims.int))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x2 Term))
       (! (implies
         (and
          (HasType @x2 (Prims.pure_post Prims.unit))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(94,2-95,19)
          (forall ((@x3 Term))
           (! (implies
             (and
              (or label_1 (HasType @x3 Prims.unit))
              ;; def=FStar.Math.Lemmas.fsti(96,42-96,63); use=FStar.Math.Lemmas.fst(94,2-95,19)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fsti(96,42-96,63); use=FStar.Math.Lemmas.fst(94,2-95,19)
               (=
                (Prims.op_Multiply (Prims.op_Minus @x0) @x1)
                (Prims.op_Multiply @x0 (Prims.op_Minus @x1)))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(94,2-95,19)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(94,2-95,19)
              (ApplyTT @x2 @x3)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(94,2-95,19)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(94,2-95,19)
               (ApplyTT @x2 @x3)))
            :qid @query.2)))
         ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(94,2-94,14)
         (forall ((@x3 Term))
          (! (implies
            (and
             (HasType @x3 Prims.unit)
             ;; def=FStar.Math.Lemmas.fsti(91,42-91,63); use=FStar.Math.Lemmas.fst(94,2-94,14)
             (=
              (Prims.op_Minus (Prims.op_Multiply @x0 @x1))
              (Prims.op_Multiply (Prims.op_Minus @x0) @x1)))
            ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(95,2-95,15)
            (forall ((@x4 Term))
             (! (implies
               (and
                (HasType @x4 Prims.unit)
                ;; def=FStar.Math.Lemmas.fsti(94,43-94,64); use=FStar.Math.Lemmas.fst(95,2-95,15)
                (=
                 (Prims.op_Minus (Prims.op_Multiply @x0 @x1))
                 (Prims.op_Multiply @x0 (Prims.op_Minus @x1))))
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(95,2-95,15)
               (Valid
                ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(95,2-95,15)
                (ApplyTT @x2 @x4)))
              :qid @query.4)))
           :qid @query.3)))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.swap_neg_mul, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let swap_neg_mul
; <Start encoding let swap_neg_mul>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.swap_neg_mul (Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.swap_neg_mul@tok () Term)
; </end encoding let swap_neg_mul>

; encoding sigelt val FStar.Math.Lemmas.distributivity_sub_left
; <Skipped val FStar.Math.Lemmas.distributivity_sub_left/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(99,2-107,3)
(declare-fun label_6 () Bool)
(declare-fun label_5 () Bool)
(declare-fun label_4 () Bool)
(declare-fun label_3 () Bool)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; x5: Prims.int -> y6: Prims.int -> Type
(declare-fun Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0 () Term)
; kinding_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0
;;; Fact-ids: 
(assert
 (! (HasType Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0 Tm_type)
  :named kinding_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0))
; pre-typing for functions
;;; Fact-ids: 
(assert
 (! ;; def=Prims.fst(548,35-548,38); use=FStar.Math.Lemmas.fst(99,2-107,3)
  (forall ((@u0 Fuel) (@x1 Term))
   (! (implies
     (HasTypeFuel @u0 @x1 Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0)
     (is-Tm_arrow (PreType @x1)))
    :pattern ((HasTypeFuel @u0 @x1 Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0))
    :qid FStar.Math.Lemmas_pre_typing_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0))
  :named FStar.Math.Lemmas_pre_typing_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0))
; interpretation_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0
;;; Fact-ids: 
(assert
 (! ;; def=Prims.fst(548,35-548,38); use=FStar.Math.Lemmas.fst(99,2-107,3)
  (forall ((@x0 Term))
   (! (iff
     (HasTypeZ @x0 Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0)
     (and
      ;; def=Prims.fst(548,35-548,38); use=FStar.Math.Lemmas.fst(99,2-107,3)
      (forall ((@x1 Term) (@x2 Term))
       (! (implies
         (and (HasType @x1 Prims.int) (HasType @x2 Prims.int))
         (HasType (ApplyTT (ApplyTT @x0 @x1) @x2) Tm_type))
        :pattern ((ApplyTT (ApplyTT @x0 @x1) @x2))
        :qid FStar.Math.Lemmas_interpretation_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0.1))
      (IsTotFun @x0)
      ;; def=Prims.fst(548,35-548,38); use=FStar.Math.Lemmas.fst(99,2-107,3)
      (forall ((@x1 Term))
       (! (implies (HasType @x1 Prims.int) (IsTotFun (ApplyTT @x0 @x1)))
        :pattern ((ApplyTT @x0 @x1))
        :qid FStar.Math.Lemmas_interpretation_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0.2))))
    :pattern ((HasTypeZ @x0 Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0))
    :qid FStar.Math.Lemmas_interpretation_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0))
  :named FStar.Math.Lemmas_interpretation_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0))
(declare-fun Tm_abs_2d12df642cab58f318db60ed4861d203 () Term)
; typing_Tm_abs_2d12df642cab58f318db60ed4861d203
;;; Fact-ids: 
(assert
 (! (HasType Tm_abs_2d12df642cab58f318db60ed4861d203 Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0)
  :named typing_Tm_abs_2d12df642cab58f318db60ed4861d203))
; interpretation_Tm_abs_2d12df642cab58f318db60ed4861d203
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fst(101,2-101,4); use=FStar.Math.Lemmas.fst(99,2-107,3)
  (forall ((@x0 Term) (@x1 Term))
   (! (=
     (ApplyTT (ApplyTT Tm_abs_2d12df642cab58f318db60ed4861d203 @x0) @x1)
     (Prims.eq2 Prims.int @x0 @x1))
    :pattern ((ApplyTT (ApplyTT Tm_abs_2d12df642cab58f318db60ed4861d203 @x0) @x1))
    :qid interpretation_Tm_abs_2d12df642cab58f318db60ed4861d203))
  :named interpretation_Tm_abs_2d12df642cab58f318db60ed4861d203))
; _: Prims.unit -> FStar.Calc.calc_pack [fun x5 y6 -> x5 == y6 <: Type] ((a - b) * c) ((a + - b) * c)
(declare-fun Tm_arrow_87bd30850f6a342fbbbbbcdd7930478f (Term Term Term) Term)
; kinding_Tm_arrow_87bd30850f6a342fbbbbbcdd7930478f
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(99,2-107,3)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term))
   (! (HasType (Tm_arrow_87bd30850f6a342fbbbbbcdd7930478f @x0 @x1 @x2) Tm_type)
    :pattern ((HasType (Tm_arrow_87bd30850f6a342fbbbbbcdd7930478f @x0 @x1 @x2) Tm_type))
    :qid kinding_Tm_arrow_87bd30850f6a342fbbbbbcdd7930478f))
  :named kinding_Tm_arrow_87bd30850f6a342fbbbbbcdd7930478f))
; pre-typing for functions
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(99,2-107,3)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
   (! (implies
     (HasTypeFuel @u0 @x1 (Tm_arrow_87bd30850f6a342fbbbbbcdd7930478f @x2 @x3 @x4))
     (is-Tm_arrow (PreType @x1)))
    :pattern ((HasTypeFuel @u0 @x1 (Tm_arrow_87bd30850f6a342fbbbbbcdd7930478f @x2 @x3 @x4)))
    :qid FStar.Math.Lemmas_pre_typing_Tm_arrow_87bd30850f6a342fbbbbbcdd7930478f))
  :named FStar.Math.Lemmas_pre_typing_Tm_arrow_87bd30850f6a342fbbbbbcdd7930478f))
; interpretation_Tm_arrow_87bd30850f6a342fbbbbbcdd7930478f
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(99,2-107,3)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
   (! (iff
     (HasTypeZ @x0 (Tm_arrow_87bd30850f6a342fbbbbbcdd7930478f @x1 @x2 @x3))
     (and
      ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(99,2-107,3)
      (forall ((@x4 Term))
       (! (implies
         (HasType @x4 Prims.unit)
         (HasType
          (ApplyTT @x0 @x4)
          (FStar.Calc.calc_pack
           Prims.int
           (Prims.Cons
            (FStar.Preorder.relation Prims.int)
            Tm_abs_2d12df642cab58f318db60ed4861d203
            (Prims.Nil (FStar.Preorder.relation Prims.int)))
           (Prims.op_Multiply (Prims.op_Subtraction @x3 @x2) @x1)
           (Prims.op_Multiply (Prims.op_Addition @x3 (Prims.op_Minus @x2)) @x1))))
        :pattern ((ApplyTT @x0 @x4))
        :qid FStar.Math.Lemmas_interpretation_Tm_arrow_87bd30850f6a342fbbbbbcdd7930478f.1))
      (IsTotFun @x0)))
    :pattern ((HasTypeZ @x0 (Tm_arrow_87bd30850f6a342fbbbbbcdd7930478f @x1 @x2 @x3)))
    :qid FStar.Math.Lemmas_interpretation_Tm_arrow_87bd30850f6a342fbbbbbcdd7930478f))
  :named FStar.Math.Lemmas_interpretation_Tm_arrow_87bd30850f6a342fbbbbbcdd7930478f))




; _: Prims.unit   -> FStar.Calc.calc_pack [(fun x7 y8 -> x7 == y8 <: Type); fun x5 y6 -> x5 == y6 <: Type]       ((a - b) * c)       (a * c + (- b) * c)
(declare-fun Tm_arrow_1e389b85ade8345177768b3c7313348d (Term Term Term) Term)
; kinding_Tm_arrow_1e389b85ade8345177768b3c7313348d
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(99,2-107,3)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term))
   (! (HasType (Tm_arrow_1e389b85ade8345177768b3c7313348d @x0 @x1 @x2) Tm_type)
    :pattern ((HasType (Tm_arrow_1e389b85ade8345177768b3c7313348d @x0 @x1 @x2) Tm_type))
    :qid kinding_Tm_arrow_1e389b85ade8345177768b3c7313348d))
  :named kinding_Tm_arrow_1e389b85ade8345177768b3c7313348d))
; pre-typing for functions
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(99,2-107,3)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
   (! (implies
     (HasTypeFuel @u0 @x1 (Tm_arrow_1e389b85ade8345177768b3c7313348d @x2 @x3 @x4))
     (is-Tm_arrow (PreType @x1)))
    :pattern ((HasTypeFuel @u0 @x1 (Tm_arrow_1e389b85ade8345177768b3c7313348d @x2 @x3 @x4)))
    :qid FStar.Math.Lemmas_pre_typing_Tm_arrow_1e389b85ade8345177768b3c7313348d))
  :named FStar.Math.Lemmas_pre_typing_Tm_arrow_1e389b85ade8345177768b3c7313348d))
; interpretation_Tm_arrow_1e389b85ade8345177768b3c7313348d
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(99,2-107,3)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
   (! (iff
     (HasTypeZ @x0 (Tm_arrow_1e389b85ade8345177768b3c7313348d @x1 @x2 @x3))
     (and
      ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(99,2-107,3)
      (forall ((@x4 Term))
       (! (implies
         (HasType @x4 Prims.unit)
         (HasType
          (ApplyTT @x0 @x4)
          (FStar.Calc.calc_pack
           Prims.int
           (Prims.Cons
            (FStar.Preorder.relation Prims.int)
            Tm_abs_2d12df642cab58f318db60ed4861d203
            (Prims.Cons
             (FStar.Preorder.relation Prims.int)
             Tm_abs_2d12df642cab58f318db60ed4861d203
             (Prims.Nil (FStar.Preorder.relation Prims.int))))
           (Prims.op_Multiply (Prims.op_Subtraction @x3 @x2) @x1)
           (Prims.op_Addition
            (Prims.op_Multiply @x3 @x1)
            (Prims.op_Multiply (Prims.op_Minus @x2) @x1)))))
        :pattern ((ApplyTT @x0 @x4))
        :qid FStar.Math.Lemmas_interpretation_Tm_arrow_1e389b85ade8345177768b3c7313348d.1))
      (IsTotFun @x0)))
    :pattern ((HasTypeZ @x0 (Tm_arrow_1e389b85ade8345177768b3c7313348d @x1 @x2 @x3)))
    :qid FStar.Math.Lemmas_interpretation_Tm_arrow_1e389b85ade8345177768b3c7313348d))
  :named FStar.Math.Lemmas_interpretation_Tm_arrow_1e389b85ade8345177768b3c7313348d))






; _: Prims.unit   -> FStar.Calc.calc_pack [         (fun x9 y10 -> x9 == y10 <: Type);         (fun x7 y8 -> x7 == y8 <: Type);         fun x5 y6 -> x5 == y6 <: Type       ]       ((a - b) * c)       (a * c - b * c)
(declare-fun Tm_arrow_67d5d81848c59d18414f1bc630ccf2c5 (Term Term Term) Term)
; kinding_Tm_arrow_67d5d81848c59d18414f1bc630ccf2c5
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(81,6-81,36); use=FStar.Math.Lemmas.fst(99,2-107,3)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term))
   (! (HasType (Tm_arrow_67d5d81848c59d18414f1bc630ccf2c5 @x0 @x1 @x2) Tm_type)
    :pattern ((HasType (Tm_arrow_67d5d81848c59d18414f1bc630ccf2c5 @x0 @x1 @x2) Tm_type))
    :qid kinding_Tm_arrow_67d5d81848c59d18414f1bc630ccf2c5))
  :named kinding_Tm_arrow_67d5d81848c59d18414f1bc630ccf2c5))
; pre-typing for functions
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(81,6-81,36); use=FStar.Math.Lemmas.fst(99,2-107,3)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
   (! (implies
     (HasTypeFuel @u0 @x1 (Tm_arrow_67d5d81848c59d18414f1bc630ccf2c5 @x2 @x3 @x4))
     (is-Tm_arrow (PreType @x1)))
    :pattern ((HasTypeFuel @u0 @x1 (Tm_arrow_67d5d81848c59d18414f1bc630ccf2c5 @x2 @x3 @x4)))
    :qid FStar.Math.Lemmas_pre_typing_Tm_arrow_67d5d81848c59d18414f1bc630ccf2c5))
  :named FStar.Math.Lemmas_pre_typing_Tm_arrow_67d5d81848c59d18414f1bc630ccf2c5))
; interpretation_Tm_arrow_67d5d81848c59d18414f1bc630ccf2c5
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(81,6-81,36); use=FStar.Math.Lemmas.fst(99,2-107,3)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
   (! (iff
     (HasTypeZ @x0 (Tm_arrow_67d5d81848c59d18414f1bc630ccf2c5 @x1 @x2 @x3))
     (and
      ;; def=FStar.Calc.fsti(81,6-81,36); use=FStar.Math.Lemmas.fst(99,2-107,3)
      (forall ((@x4 Term))
       (! (implies
         (HasType @x4 Prims.unit)
         (HasType
          (ApplyTT @x0 @x4)
          (FStar.Calc.calc_pack
           Prims.int
           (Prims.Cons
            (FStar.Preorder.relation Prims.int)
            Tm_abs_2d12df642cab58f318db60ed4861d203
            (Prims.Cons
             (FStar.Preorder.relation Prims.int)
             Tm_abs_2d12df642cab58f318db60ed4861d203
             (Prims.Cons
              (FStar.Preorder.relation Prims.int)
              Tm_abs_2d12df642cab58f318db60ed4861d203
              (Prims.Nil (FStar.Preorder.relation Prims.int)))))
           (Prims.op_Multiply (Prims.op_Subtraction @x3 @x2) @x1)
           (Prims.op_Subtraction (Prims.op_Multiply @x3 @x1) (Prims.op_Multiply @x2 @x1)))))
        :pattern ((ApplyTT @x0 @x4))
        :qid FStar.Math.Lemmas_interpretation_Tm_arrow_67d5d81848c59d18414f1bc630ccf2c5.1))
      (IsTotFun @x0)))
    :pattern ((HasTypeZ @x0 (Tm_arrow_67d5d81848c59d18414f1bc630ccf2c5 @x1 @x2 @x3)))
    :qid FStar.Math.Lemmas_interpretation_Tm_arrow_67d5d81848c59d18414f1bc630ccf2c5))
  :named FStar.Math.Lemmas_interpretation_Tm_arrow_67d5d81848c59d18414f1bc630ccf2c5))
; Encoding query formula : forall (a: Prims.int) (b: Prims.int) (c: Prims.int).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     (forall (pure_result: Prims.unit). (a - b) * c = a * c - b * c ==> p pure_result) ==>
;     (forall (_: Prims.unit).
;         (*  - Could not prove post-condition
; *)
;         (forall (_: Prims.unit).
;             (*  - Could not prove post-condition
; *)
;             (forall (_: Prims.unit).
;                 (*  - Could not prove post-condition
; *)
;                 forall (_: Prims.unit).
;                   (*  - Could not prove post-condition
; *) (a - b) * c == (a + - b) * c) /\
;             (forall (any_result:
;                 (_: Prims.unit
;                     -> FStar.Calc.calc_pack [fun x5 y6 -> x5 == y6 <: Type0]
;                         ((a - b) * c)
;                         ((a + - b) * c)))
;                 (_: Prims.unit).
;                 (*  - Could not prove post-condition
; *)
;                 forall (pure_result: Prims.unit).
;                   (a + - b) * c = a * c + (- b) * c ==> (a + - b) * c == a * c + (- b) * c)) /\
;         (forall (any_result:
;             (_: Prims.unit
;                 -> FStar.Calc.calc_pack [
;                       (fun x7 y8 -> x7 == y8 <: Type0);
;                       fun x5 y6 -> x5 == y6 <: Type0
;                     ]
;                     ((a - b) * c)
;                     (a * c + (- b) * c)))
;             (_: Prims.unit).
;             (*  - Could not prove post-condition
; *)
;             forall (pure_result: Prims.unit).
;               - b * c = (- b) * c ==> a * c + (- b) * c == a * c - b * c)) /\
;     (forall (any_result:
;         (_: Prims.unit
;             -> FStar.Calc.calc_pack [
;                   (fun x9 y10 -> x9 == y10 <: Type0);
;                   (fun x7 y8 -> x7 == y8 <: Type0);
;                   fun x5 y6 -> x5 == y6 <: Type0
;                 ]
;                 ((a - b) * c)
;                 (a * c - b * c))).
;         FStar.Range.labeled (FStar.Sealed.seal FStar.Calc.fsti(86,37-86,50))
;           "Could not prove that this calc-chain is compatible"
;           (forall (x: Prims.int) (y: Prims.int).
;               (exists (w: Prims.int).
;                   (exists (w: Prims.int). (exists (w: Prims.int). x == w /\ w == w) /\ w == w) /\
;                   w == y) ==>
;               x == y) /\
;         (forall (pure_result: Prims.unit). (a - b) * c == a * c - b * c ==> p pure_result))
; Context: While encoding a query
; While typechecking the top-level declaration `let distributivity_sub_left`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term) (@x2 Term))
    (! (implies
      (and (HasType @x0 Prims.int) (HasType @x1 Prims.int) (HasType @x2 Prims.int))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x3 Term))
       (! (implies
         (and
          (HasType @x3 (Prims.pure_post Prims.unit))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(99,2-107,3)
          (forall ((@x4 Term))
           (! (implies
             (and
              (or label_1 (HasType @x4 Prims.unit))
              ;; def=FStar.Math.Lemmas.fsti(100,8-100,37); use=FStar.Math.Lemmas.fst(99,2-107,3)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fsti(100,8-100,37); use=FStar.Math.Lemmas.fst(99,2-107,3)
               (=
                (Prims.op_Multiply (Prims.op_Subtraction @x0 @x1) @x2)
                (Prims.op_Subtraction (Prims.op_Multiply @x0 @x2) (Prims.op_Multiply @x1 @x2)))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(99,2-107,3)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(99,2-107,3)
              (ApplyTT @x3 @x4)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(99,2-107,3)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(99,2-107,3)
               (ApplyTT @x3 @x4)))
            :qid @query.2)))
         ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(99,2-107,3)
         (and
          ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(99,2-107,3)
          (forall ((@x4 Term))
           (! (implies
             (HasType @x4 Prims.unit)
             ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(99,2-107,3)
             (and
              ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(99,2-107,3)
              (forall ((@x5 Term))
               (! (implies
                 (HasType @x5 Prims.unit)
                 ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(99,2-107,3)
                 (and
                  ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(99,2-107,3)
                  (forall ((@x6 Term))
                   (! (implies
                     (HasType @x6 Prims.unit)
                     ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(99,2-107,3)
                     (forall ((@x7 Term))
                      (! (implies
                        (HasType @x7 Prims.unit)
                        ;; def=FStar.Math.Lemmas.fst(101,2-101,4); use=FStar.Math.Lemmas.fst(101,5-101,7)
                        (or
                         label_3
                         ;; def=FStar.Math.Lemmas.fst(101,2-101,4); use=FStar.Math.Lemmas.fst(101,5-101,7)
                         (=
                          (Prims.op_Multiply (Prims.op_Subtraction @x0 @x1) @x2)
                          (Prims.op_Multiply (Prims.op_Addition @x0 (Prims.op_Minus @x1)) @x2))))
                       :qid @query.6)))
                    :qid @query.5))
                  ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(99,2-107,3)
                  (forall ((@x6 Term))
                   (! (implies
                     (HasType @x6 (Tm_arrow_87bd30850f6a342fbbbbbcdd7930478f @x2 @x1 @x0))
                     ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(99,2-107,3)
                     (forall ((@x7 Term))
                      (! (implies
                        (HasType @x7 Prims.unit)
                        ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(103,7-103,30)
                        (forall ((@x8 Term))
                         (! (implies
                           (and
                            (HasType @x8 Prims.unit)
                            ;; def=FStar.Math.Lemmas.fsti(54,2-54,31); use=FStar.Math.Lemmas.fst(103,7-103,30)
                            (=
                             (Prims.op_Multiply (Prims.op_Addition @x0 (Prims.op_Minus @x1)) @x2)
                             (Prims.op_Addition
                              (Prims.op_Multiply @x0 @x2)
                              (Prims.op_Multiply (Prims.op_Minus @x1) @x2))))
                           ;; def=FStar.Math.Lemmas.fst(103,2-103,4); use=FStar.Math.Lemmas.fst(103,7-103,39)
                           (or
                            label_4
                            ;; def=FStar.Math.Lemmas.fst(103,2-103,4); use=FStar.Math.Lemmas.fst(103,7-103,39)
                            (=
                             (Prims.op_Multiply (Prims.op_Addition @x0 (Prims.op_Minus @x1)) @x2)
                             (Prims.op_Addition
                              (Prims.op_Multiply @x0 @x2)
                              (Prims.op_Multiply (Prims.op_Minus @x1) @x2)))))
                          :qid @query.9)))
                       :qid @query.8)))
                    :qid @query.7))))
                :qid @query.4))
              ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(99,2-107,3)
              (forall ((@x5 Term))
               (! (implies
                 (HasType @x5 (Tm_arrow_1e389b85ade8345177768b3c7313348d @x2 @x1 @x0))
                 ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(99,2-107,3)
                 (forall ((@x6 Term))
                  (! (implies
                    (HasType @x6 Prims.unit)
                    ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(105,7-105,19)
                    (forall ((@x7 Term))
                     (! (implies
                       (and
                        (HasType @x7 Prims.unit)
                        ;; def=FStar.Math.Lemmas.fsti(91,42-91,63); use=FStar.Math.Lemmas.fst(105,7-105,19)
                        (=
                         (Prims.op_Minus (Prims.op_Multiply @x1 @x2))
                         (Prims.op_Multiply (Prims.op_Minus @x1) @x2)))
                       ;; def=FStar.Math.Lemmas.fst(105,2-105,4); use=FStar.Math.Lemmas.fst(105,7-105,23)
                       (or
                        label_5
                        ;; def=FStar.Math.Lemmas.fst(105,2-105,4); use=FStar.Math.Lemmas.fst(105,7-105,23)
                        (=
                         (Prims.op_Addition
                          (Prims.op_Multiply @x0 @x2)
                          (Prims.op_Multiply (Prims.op_Minus @x1) @x2))
                         (Prims.op_Subtraction
                          (Prims.op_Multiply @x0 @x2)
                          (Prims.op_Multiply @x1 @x2)))))
                      :qid @query.12)))
                   :qid @query.11)))
                :qid @query.10))))
            :qid @query.3))
          ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(99,2-107,3)
          (forall ((@x4 Term))
           (! (implies
             (HasType @x4 (Tm_arrow_67d5d81848c59d18414f1bc630ccf2c5 @x2 @x1 @x0))
             ;; def=Prims.fst(449,29-449,97); use=FStar.Math.Lemmas.fst(99,2-107,3)
             (and
              ;; def=FStar.Calc.fsti(47,4-47,55); use=FStar.Calc.fsti(47,4-47,55)
              (forall ((@x5 Term) (@x6 Term))
               (! (implies
                 (and
                  (HasType @x5 Prims.int)
                  (HasType @x6 Prims.int)
                  ;; def=FStar.Calc.fsti(42,16-42,65); use=FStar.Calc.fsti(42,16-42,65)
                  (exists ((@x7 Term))
                   (! (and
                     (HasType @x7 Prims.int)
                     ;; def=FStar.Calc.fsti(42,16-42,65); use=FStar.Calc.fsti(42,16-42,65)
                     (exists ((@x8 Term))
                      (! (and
                        (HasType @x8 Prims.int)
                        ;; def=FStar.Calc.fsti(42,16-42,65); use=FStar.Calc.fsti(42,16-42,65)
                        (exists ((@x9 Term))
                         (! (and
                           (HasType @x9 Prims.int)
                           ;; def=FStar.Calc.fsti(40,12-40,18); use=FStar.Calc.fsti(40,12-40,18)
                           (= @x5 @x9)
                           ;; def=FStar.Math.Lemmas.fst(101,2-101,4); use=FStar.Math.Lemmas.fst(99,2-107,3)
                           (= @x9 @x8))
                          :qid @query.17))
                        ;; def=FStar.Math.Lemmas.fst(103,2-103,4); use=FStar.Math.Lemmas.fst(99,2-107,3)
                        (= @x8 @x7))
                       :qid @query.16))
                     ;; def=FStar.Math.Lemmas.fst(105,2-105,4); use=FStar.Math.Lemmas.fst(99,2-107,3)
                     (= @x7 @x6))
                    :qid @query.15)))
                 ;; def=FStar.Math.Lemmas.fst(99,7-99,11); use=FStar.Math.Lemmas.fst(99,2-107,3)
                 (or
                  label_6
                  ;; def=FStar.Math.Lemmas.fst(99,7-99,11); use=FStar.Math.Lemmas.fst(99,2-107,3)
                  (= @x5 @x6)))
                :qid @query.14))
              ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(99,2-107,3)
              (forall ((@x5 Term))
               (! (implies
                 (and
                  (HasType @x5 Prims.unit)
                  ;; def=FStar.Math.Lemmas.fst(99,7-99,11); use=FStar.Math.Lemmas.fst(99,2-107,3)
                  (=
                   (Prims.op_Multiply (Prims.op_Subtraction @x0 @x1) @x2)
                   (Prims.op_Subtraction (Prims.op_Multiply @x0 @x2) (Prims.op_Multiply @x1 @x2))))
                 ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(99,2-107,3)
                 (Valid
                  ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(99,2-107,3)
                  (ApplyTT @x3 @x5)))
                :qid @query.18))))
            :qid @query.13))))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_6")
(eval label_6)
(echo "label_5")
(eval label_5)
(echo "label_4")
(eval label_4)
(echo "label_3")
(eval label_3)
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.distributivity_sub_left, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let distributivity_sub_left
; <Start encoding let distributivity_sub_left>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.distributivity_sub_left (Term Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.distributivity_sub_left@tok () Term)
; </end encoding let distributivity_sub_left>

; encoding sigelt val FStar.Math.Lemmas.distributivity_sub_right
; <Skipped val FStar.Math.Lemmas.distributivity_sub_right/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(111,2-119,3)
(declare-fun label_6 () Bool)
(declare-fun label_5 () Bool)
(declare-fun label_4 () Bool)
(declare-fun label_3 () Bool)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; x5: Prims.int -> y6: Prims.int -> Type
(declare-fun Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0 () Term)
; kinding_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0
;;; Fact-ids: 
(assert
 (! (HasType Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0 Tm_type)
  :named kinding_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0))
; pre-typing for functions
;;; Fact-ids: 
(assert
 (! ;; def=Prims.fst(548,35-548,38); use=FStar.Math.Lemmas.fst(111,2-119,3)
  (forall ((@u0 Fuel) (@x1 Term))
   (! (implies
     (HasTypeFuel @u0 @x1 Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0)
     (is-Tm_arrow (PreType @x1)))
    :pattern ((HasTypeFuel @u0 @x1 Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0))
    :qid FStar.Math.Lemmas_pre_typing_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0))
  :named FStar.Math.Lemmas_pre_typing_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0))
; interpretation_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0
;;; Fact-ids: 
(assert
 (! ;; def=Prims.fst(548,35-548,38); use=FStar.Math.Lemmas.fst(111,2-119,3)
  (forall ((@x0 Term))
   (! (iff
     (HasTypeZ @x0 Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0)
     (and
      ;; def=Prims.fst(548,35-548,38); use=FStar.Math.Lemmas.fst(111,2-119,3)
      (forall ((@x1 Term) (@x2 Term))
       (! (implies
         (and (HasType @x1 Prims.int) (HasType @x2 Prims.int))
         (HasType (ApplyTT (ApplyTT @x0 @x1) @x2) Tm_type))
        :pattern ((ApplyTT (ApplyTT @x0 @x1) @x2))
        :qid FStar.Math.Lemmas_interpretation_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0.1))
      (IsTotFun @x0)
      ;; def=Prims.fst(548,35-548,38); use=FStar.Math.Lemmas.fst(111,2-119,3)
      (forall ((@x1 Term))
       (! (implies (HasType @x1 Prims.int) (IsTotFun (ApplyTT @x0 @x1)))
        :pattern ((ApplyTT @x0 @x1))
        :qid FStar.Math.Lemmas_interpretation_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0.2))))
    :pattern ((HasTypeZ @x0 Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0))
    :qid FStar.Math.Lemmas_interpretation_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0))
  :named FStar.Math.Lemmas_interpretation_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0))
(declare-fun Tm_abs_2d12df642cab58f318db60ed4861d203 () Term)
; typing_Tm_abs_2d12df642cab58f318db60ed4861d203
;;; Fact-ids: 
(assert
 (! (HasType Tm_abs_2d12df642cab58f318db60ed4861d203 Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0)
  :named typing_Tm_abs_2d12df642cab58f318db60ed4861d203))
; interpretation_Tm_abs_2d12df642cab58f318db60ed4861d203
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fst(113,2-113,4); use=FStar.Math.Lemmas.fst(111,2-119,3)
  (forall ((@x0 Term) (@x1 Term))
   (! (=
     (ApplyTT (ApplyTT Tm_abs_2d12df642cab58f318db60ed4861d203 @x0) @x1)
     (Prims.eq2 Prims.int @x0 @x1))
    :pattern ((ApplyTT (ApplyTT Tm_abs_2d12df642cab58f318db60ed4861d203 @x0) @x1))
    :qid interpretation_Tm_abs_2d12df642cab58f318db60ed4861d203))
  :named interpretation_Tm_abs_2d12df642cab58f318db60ed4861d203))
; _: Prims.unit -> FStar.Calc.calc_pack [fun x5 y6 -> x5 == y6 <: Type] (a * (b - c)) (a * (b + - c))
(declare-fun Tm_arrow_189a4c05cd6d173f2a5e005e66fa1967 (Term Term Term) Term)
; kinding_Tm_arrow_189a4c05cd6d173f2a5e005e66fa1967
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(111,2-119,3)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term))
   (! (HasType (Tm_arrow_189a4c05cd6d173f2a5e005e66fa1967 @x0 @x1 @x2) Tm_type)
    :pattern ((HasType (Tm_arrow_189a4c05cd6d173f2a5e005e66fa1967 @x0 @x1 @x2) Tm_type))
    :qid kinding_Tm_arrow_189a4c05cd6d173f2a5e005e66fa1967))
  :named kinding_Tm_arrow_189a4c05cd6d173f2a5e005e66fa1967))
; pre-typing for functions
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(111,2-119,3)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
   (! (implies
     (HasTypeFuel @u0 @x1 (Tm_arrow_189a4c05cd6d173f2a5e005e66fa1967 @x2 @x3 @x4))
     (is-Tm_arrow (PreType @x1)))
    :pattern ((HasTypeFuel @u0 @x1 (Tm_arrow_189a4c05cd6d173f2a5e005e66fa1967 @x2 @x3 @x4)))
    :qid FStar.Math.Lemmas_pre_typing_Tm_arrow_189a4c05cd6d173f2a5e005e66fa1967))
  :named FStar.Math.Lemmas_pre_typing_Tm_arrow_189a4c05cd6d173f2a5e005e66fa1967))
; interpretation_Tm_arrow_189a4c05cd6d173f2a5e005e66fa1967
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(111,2-119,3)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
   (! (iff
     (HasTypeZ @x0 (Tm_arrow_189a4c05cd6d173f2a5e005e66fa1967 @x1 @x2 @x3))
     (and
      ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(111,2-119,3)
      (forall ((@x4 Term))
       (! (implies
         (HasType @x4 Prims.unit)
         (HasType
          (ApplyTT @x0 @x4)
          (FStar.Calc.calc_pack
           Prims.int
           (Prims.Cons
            (FStar.Preorder.relation Prims.int)
            Tm_abs_2d12df642cab58f318db60ed4861d203
            (Prims.Nil (FStar.Preorder.relation Prims.int)))
           (Prims.op_Multiply @x3 (Prims.op_Subtraction @x2 @x1))
           (Prims.op_Multiply @x3 (Prims.op_Addition @x2 (Prims.op_Minus @x1))))))
        :pattern ((ApplyTT @x0 @x4))
        :qid FStar.Math.Lemmas_interpretation_Tm_arrow_189a4c05cd6d173f2a5e005e66fa1967.1))
      (IsTotFun @x0)))
    :pattern ((HasTypeZ @x0 (Tm_arrow_189a4c05cd6d173f2a5e005e66fa1967 @x1 @x2 @x3)))
    :qid FStar.Math.Lemmas_interpretation_Tm_arrow_189a4c05cd6d173f2a5e005e66fa1967))
  :named FStar.Math.Lemmas_interpretation_Tm_arrow_189a4c05cd6d173f2a5e005e66fa1967))




; _: Prims.unit   -> FStar.Calc.calc_pack [(fun x7 y8 -> x7 == y8 <: Type); fun x5 y6 -> x5 == y6 <: Type]       (a * (b - c))       (a * b + a * (- c))
(declare-fun Tm_arrow_e7fd5acab42c75d426d945198b285a08 (Term Term Term) Term)
; kinding_Tm_arrow_e7fd5acab42c75d426d945198b285a08
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(111,2-119,3)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term))
   (! (HasType (Tm_arrow_e7fd5acab42c75d426d945198b285a08 @x0 @x1 @x2) Tm_type)
    :pattern ((HasType (Tm_arrow_e7fd5acab42c75d426d945198b285a08 @x0 @x1 @x2) Tm_type))
    :qid kinding_Tm_arrow_e7fd5acab42c75d426d945198b285a08))
  :named kinding_Tm_arrow_e7fd5acab42c75d426d945198b285a08))
; pre-typing for functions
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(111,2-119,3)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
   (! (implies
     (HasTypeFuel @u0 @x1 (Tm_arrow_e7fd5acab42c75d426d945198b285a08 @x2 @x3 @x4))
     (is-Tm_arrow (PreType @x1)))
    :pattern ((HasTypeFuel @u0 @x1 (Tm_arrow_e7fd5acab42c75d426d945198b285a08 @x2 @x3 @x4)))
    :qid FStar.Math.Lemmas_pre_typing_Tm_arrow_e7fd5acab42c75d426d945198b285a08))
  :named FStar.Math.Lemmas_pre_typing_Tm_arrow_e7fd5acab42c75d426d945198b285a08))
; interpretation_Tm_arrow_e7fd5acab42c75d426d945198b285a08
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(111,2-119,3)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
   (! (iff
     (HasTypeZ @x0 (Tm_arrow_e7fd5acab42c75d426d945198b285a08 @x1 @x2 @x3))
     (and
      ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(111,2-119,3)
      (forall ((@x4 Term))
       (! (implies
         (HasType @x4 Prims.unit)
         (HasType
          (ApplyTT @x0 @x4)
          (FStar.Calc.calc_pack
           Prims.int
           (Prims.Cons
            (FStar.Preorder.relation Prims.int)
            Tm_abs_2d12df642cab58f318db60ed4861d203
            (Prims.Cons
             (FStar.Preorder.relation Prims.int)
             Tm_abs_2d12df642cab58f318db60ed4861d203
             (Prims.Nil (FStar.Preorder.relation Prims.int))))
           (Prims.op_Multiply @x3 (Prims.op_Subtraction @x2 @x1))
           (Prims.op_Addition
            (Prims.op_Multiply @x3 @x2)
            (Prims.op_Multiply @x3 (Prims.op_Minus @x1))))))
        :pattern ((ApplyTT @x0 @x4))
        :qid FStar.Math.Lemmas_interpretation_Tm_arrow_e7fd5acab42c75d426d945198b285a08.1))
      (IsTotFun @x0)))
    :pattern ((HasTypeZ @x0 (Tm_arrow_e7fd5acab42c75d426d945198b285a08 @x1 @x2 @x3)))
    :qid FStar.Math.Lemmas_interpretation_Tm_arrow_e7fd5acab42c75d426d945198b285a08))
  :named FStar.Math.Lemmas_interpretation_Tm_arrow_e7fd5acab42c75d426d945198b285a08))






; _: Prims.unit   -> FStar.Calc.calc_pack [         (fun x9 y10 -> x9 == y10 <: Type);         (fun x7 y8 -> x7 == y8 <: Type);         fun x5 y6 -> x5 == y6 <: Type       ]       (a * (b - c))       (a * b - a * c)
(declare-fun Tm_arrow_abf5bd1aa3542b88a99df3cb53df049e (Term Term Term) Term)
; kinding_Tm_arrow_abf5bd1aa3542b88a99df3cb53df049e
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(81,6-81,36); use=FStar.Math.Lemmas.fst(111,2-119,3)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term))
   (! (HasType (Tm_arrow_abf5bd1aa3542b88a99df3cb53df049e @x0 @x1 @x2) Tm_type)
    :pattern ((HasType (Tm_arrow_abf5bd1aa3542b88a99df3cb53df049e @x0 @x1 @x2) Tm_type))
    :qid kinding_Tm_arrow_abf5bd1aa3542b88a99df3cb53df049e))
  :named kinding_Tm_arrow_abf5bd1aa3542b88a99df3cb53df049e))
; pre-typing for functions
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(81,6-81,36); use=FStar.Math.Lemmas.fst(111,2-119,3)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
   (! (implies
     (HasTypeFuel @u0 @x1 (Tm_arrow_abf5bd1aa3542b88a99df3cb53df049e @x2 @x3 @x4))
     (is-Tm_arrow (PreType @x1)))
    :pattern ((HasTypeFuel @u0 @x1 (Tm_arrow_abf5bd1aa3542b88a99df3cb53df049e @x2 @x3 @x4)))
    :qid FStar.Math.Lemmas_pre_typing_Tm_arrow_abf5bd1aa3542b88a99df3cb53df049e))
  :named FStar.Math.Lemmas_pre_typing_Tm_arrow_abf5bd1aa3542b88a99df3cb53df049e))
; interpretation_Tm_arrow_abf5bd1aa3542b88a99df3cb53df049e
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(81,6-81,36); use=FStar.Math.Lemmas.fst(111,2-119,3)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
   (! (iff
     (HasTypeZ @x0 (Tm_arrow_abf5bd1aa3542b88a99df3cb53df049e @x1 @x2 @x3))
     (and
      ;; def=FStar.Calc.fsti(81,6-81,36); use=FStar.Math.Lemmas.fst(111,2-119,3)
      (forall ((@x4 Term))
       (! (implies
         (HasType @x4 Prims.unit)
         (HasType
          (ApplyTT @x0 @x4)
          (FStar.Calc.calc_pack
           Prims.int
           (Prims.Cons
            (FStar.Preorder.relation Prims.int)
            Tm_abs_2d12df642cab58f318db60ed4861d203
            (Prims.Cons
             (FStar.Preorder.relation Prims.int)
             Tm_abs_2d12df642cab58f318db60ed4861d203
             (Prims.Cons
              (FStar.Preorder.relation Prims.int)
              Tm_abs_2d12df642cab58f318db60ed4861d203
              (Prims.Nil (FStar.Preorder.relation Prims.int)))))
           (Prims.op_Multiply @x3 (Prims.op_Subtraction @x2 @x1))
           (Prims.op_Subtraction (Prims.op_Multiply @x3 @x2) (Prims.op_Multiply @x3 @x1)))))
        :pattern ((ApplyTT @x0 @x4))
        :qid FStar.Math.Lemmas_interpretation_Tm_arrow_abf5bd1aa3542b88a99df3cb53df049e.1))
      (IsTotFun @x0)))
    :pattern ((HasTypeZ @x0 (Tm_arrow_abf5bd1aa3542b88a99df3cb53df049e @x1 @x2 @x3)))
    :qid FStar.Math.Lemmas_interpretation_Tm_arrow_abf5bd1aa3542b88a99df3cb53df049e))
  :named FStar.Math.Lemmas_interpretation_Tm_arrow_abf5bd1aa3542b88a99df3cb53df049e))
; Encoding query formula : forall (a: Prims.int) (b: Prims.int) (c: Prims.int).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     (forall (pure_result: Prims.unit). a * (b - c) = a * b - a * c ==> p pure_result) ==>
;     (forall (_: Prims.unit).
;         (*  - Could not prove post-condition
; *)
;         (forall (_: Prims.unit).
;             (*  - Could not prove post-condition
; *)
;             (forall (_: Prims.unit).
;                 (*  - Could not prove post-condition
; *)
;                 forall (_: Prims.unit).
;                   (*  - Could not prove post-condition
; *) a * (b - c) == a * (b + - c)) /\
;             (forall (any_result:
;                 (_: Prims.unit
;                     -> FStar.Calc.calc_pack [fun x5 y6 -> x5 == y6 <: Type0]
;                         (a * (b - c))
;                         (a * (b + - c))))
;                 (_: Prims.unit).
;                 (*  - Could not prove post-condition
; *)
;                 forall (pure_result: Prims.unit).
;                   a * (b + - c) = a * b + a * (- c) ==> a * (b + - c) == a * b + a * (- c))) /\
;         (forall (any_result:
;             (_: Prims.unit
;                 -> FStar.Calc.calc_pack [
;                       (fun x7 y8 -> x7 == y8 <: Type0);
;                       fun x5 y6 -> x5 == y6 <: Type0
;                     ]
;                     (a * (b - c))
;                     (a * b + a * (- c))))
;             (_: Prims.unit).
;             (*  - Could not prove post-condition
; *)
;             forall (pure_result: Prims.unit).
;               - a * c = a * (- c) ==> a * b + a * (- c) == a * b - a * c)) /\
;     (forall (any_result:
;         (_: Prims.unit
;             -> FStar.Calc.calc_pack [
;                   (fun x9 y10 -> x9 == y10 <: Type0);
;                   (fun x7 y8 -> x7 == y8 <: Type0);
;                   fun x5 y6 -> x5 == y6 <: Type0
;                 ]
;                 (a * (b - c))
;                 (a * b - a * c))).
;         FStar.Range.labeled (FStar.Sealed.seal FStar.Calc.fsti(86,37-86,50))
;           "Could not prove that this calc-chain is compatible"
;           (forall (x: Prims.int) (y: Prims.int).
;               (exists (w: Prims.int).
;                   (exists (w: Prims.int). (exists (w: Prims.int). x == w /\ w == w) /\ w == w) /\
;                   w == y) ==>
;               x == y) /\
;         (forall (pure_result: Prims.unit). a * (b - c) == a * b - a * c ==> p pure_result))
; Context: While encoding a query
; While typechecking the top-level declaration `let distributivity_sub_right`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term) (@x2 Term))
    (! (implies
      (and (HasType @x0 Prims.int) (HasType @x1 Prims.int) (HasType @x2 Prims.int))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x3 Term))
       (! (implies
         (and
          (HasType @x3 (Prims.pure_post Prims.unit))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(111,2-119,3)
          (forall ((@x4 Term))
           (! (implies
             (and
              (or label_1 (HasType @x4 Prims.unit))
              ;; def=FStar.Math.Lemmas.fsti(104,8-104,39); use=FStar.Math.Lemmas.fst(111,2-119,3)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fsti(104,8-104,39); use=FStar.Math.Lemmas.fst(111,2-119,3)
               (=
                (Prims.op_Multiply @x0 (Prims.op_Subtraction @x1 @x2))
                (Prims.op_Subtraction (Prims.op_Multiply @x0 @x1) (Prims.op_Multiply @x0 @x2)))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(111,2-119,3)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(111,2-119,3)
              (ApplyTT @x3 @x4)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(111,2-119,3)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(111,2-119,3)
               (ApplyTT @x3 @x4)))
            :qid @query.2)))
         ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(111,2-119,3)
         (and
          ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(111,2-119,3)
          (forall ((@x4 Term))
           (! (implies
             (HasType @x4 Prims.unit)
             ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(111,2-119,3)
             (and
              ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(111,2-119,3)
              (forall ((@x5 Term))
               (! (implies
                 (HasType @x5 Prims.unit)
                 ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(111,2-119,3)
                 (and
                  ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(111,2-119,3)
                  (forall ((@x6 Term))
                   (! (implies
                     (HasType @x6 Prims.unit)
                     ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(111,2-119,3)
                     (forall ((@x7 Term))
                      (! (implies
                        (HasType @x7 Prims.unit)
                        ;; def=FStar.Math.Lemmas.fst(113,2-113,4); use=FStar.Math.Lemmas.fst(113,5-113,7)
                        (or
                         label_3
                         ;; def=FStar.Math.Lemmas.fst(113,2-113,4); use=FStar.Math.Lemmas.fst(113,5-113,7)
                         (=
                          (Prims.op_Multiply @x0 (Prims.op_Subtraction @x1 @x2))
                          (Prims.op_Multiply @x0 (Prims.op_Addition @x1 (Prims.op_Minus @x2))))))
                       :qid @query.6)))
                    :qid @query.5))
                  ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(111,2-119,3)
                  (forall ((@x6 Term))
                   (! (implies
                     (HasType @x6 (Tm_arrow_189a4c05cd6d173f2a5e005e66fa1967 @x2 @x1 @x0))
                     ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(111,2-119,3)
                     (forall ((@x7 Term))
                      (! (implies
                        (HasType @x7 Prims.unit)
                        ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(115,7-115,31)
                        (forall ((@x8 Term))
                         (! (implies
                           (and
                            (HasType @x8 Prims.unit)
                            ;; def=FStar.Math.Lemmas.fsti(58,2-58,31); use=FStar.Math.Lemmas.fst(115,7-115,31)
                            (=
                             (Prims.op_Multiply @x0 (Prims.op_Addition @x1 (Prims.op_Minus @x2)))
                             (Prims.op_Addition
                              (Prims.op_Multiply @x0 @x1)
                              (Prims.op_Multiply @x0 (Prims.op_Minus @x2)))))
                           ;; def=FStar.Math.Lemmas.fst(115,2-115,4); use=FStar.Math.Lemmas.fst(115,7-115,40)
                           (or
                            label_4
                            ;; def=FStar.Math.Lemmas.fst(115,2-115,4); use=FStar.Math.Lemmas.fst(115,7-115,40)
                            (=
                             (Prims.op_Multiply @x0 (Prims.op_Addition @x1 (Prims.op_Minus @x2)))
                             (Prims.op_Addition
                              (Prims.op_Multiply @x0 @x1)
                              (Prims.op_Multiply @x0 (Prims.op_Minus @x2))))))
                          :qid @query.9)))
                       :qid @query.8)))
                    :qid @query.7))))
                :qid @query.4))
              ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(111,2-119,3)
              (forall ((@x5 Term))
               (! (implies
                 (HasType @x5 (Tm_arrow_e7fd5acab42c75d426d945198b285a08 @x2 @x1 @x0))
                 ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(111,2-119,3)
                 (forall ((@x6 Term))
                  (! (implies
                    (HasType @x6 Prims.unit)
                    ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(117,7-117,20)
                    (forall ((@x7 Term))
                     (! (implies
                       (and
                        (HasType @x7 Prims.unit)
                        ;; def=FStar.Math.Lemmas.fsti(94,43-94,64); use=FStar.Math.Lemmas.fst(117,7-117,20)
                        (=
                         (Prims.op_Minus (Prims.op_Multiply @x0 @x2))
                         (Prims.op_Multiply @x0 (Prims.op_Minus @x2))))
                       ;; def=FStar.Math.Lemmas.fst(117,2-117,4); use=FStar.Math.Lemmas.fst(117,7-117,24)
                       (or
                        label_5
                        ;; def=FStar.Math.Lemmas.fst(117,2-117,4); use=FStar.Math.Lemmas.fst(117,7-117,24)
                        (=
                         (Prims.op_Addition
                          (Prims.op_Multiply @x0 @x1)
                          (Prims.op_Multiply @x0 (Prims.op_Minus @x2)))
                         (Prims.op_Subtraction
                          (Prims.op_Multiply @x0 @x1)
                          (Prims.op_Multiply @x0 @x2)))))
                      :qid @query.12)))
                   :qid @query.11)))
                :qid @query.10))))
            :qid @query.3))
          ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(111,2-119,3)
          (forall ((@x4 Term))
           (! (implies
             (HasType @x4 (Tm_arrow_abf5bd1aa3542b88a99df3cb53df049e @x2 @x1 @x0))
             ;; def=Prims.fst(449,29-449,97); use=FStar.Math.Lemmas.fst(111,2-119,3)
             (and
              ;; def=FStar.Calc.fsti(47,4-47,55); use=FStar.Calc.fsti(47,4-47,55)
              (forall ((@x5 Term) (@x6 Term))
               (! (implies
                 (and
                  (HasType @x5 Prims.int)
                  (HasType @x6 Prims.int)
                  ;; def=FStar.Calc.fsti(42,16-42,65); use=FStar.Calc.fsti(42,16-42,65)
                  (exists ((@x7 Term))
                   (! (and
                     (HasType @x7 Prims.int)
                     ;; def=FStar.Calc.fsti(42,16-42,65); use=FStar.Calc.fsti(42,16-42,65)
                     (exists ((@x8 Term))
                      (! (and
                        (HasType @x8 Prims.int)
                        ;; def=FStar.Calc.fsti(42,16-42,65); use=FStar.Calc.fsti(42,16-42,65)
                        (exists ((@x9 Term))
                         (! (and
                           (HasType @x9 Prims.int)
                           ;; def=FStar.Calc.fsti(40,12-40,18); use=FStar.Calc.fsti(40,12-40,18)
                           (= @x5 @x9)
                           ;; def=FStar.Math.Lemmas.fst(113,2-113,4); use=FStar.Math.Lemmas.fst(111,2-119,3)
                           (= @x9 @x8))
                          :qid @query.17))
                        ;; def=FStar.Math.Lemmas.fst(115,2-115,4); use=FStar.Math.Lemmas.fst(111,2-119,3)
                        (= @x8 @x7))
                       :qid @query.16))
                     ;; def=FStar.Math.Lemmas.fst(117,2-117,4); use=FStar.Math.Lemmas.fst(111,2-119,3)
                     (= @x7 @x6))
                    :qid @query.15)))
                 ;; def=FStar.Math.Lemmas.fst(111,7-111,11); use=FStar.Math.Lemmas.fst(111,2-119,3)
                 (or
                  label_6
                  ;; def=FStar.Math.Lemmas.fst(111,7-111,11); use=FStar.Math.Lemmas.fst(111,2-119,3)
                  (= @x5 @x6)))
                :qid @query.14))
              ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(111,2-119,3)
              (forall ((@x5 Term))
               (! (implies
                 (and
                  (HasType @x5 Prims.unit)
                  ;; def=FStar.Math.Lemmas.fst(111,7-111,11); use=FStar.Math.Lemmas.fst(111,2-119,3)
                  (=
                   (Prims.op_Multiply @x0 (Prims.op_Subtraction @x1 @x2))
                   (Prims.op_Subtraction (Prims.op_Multiply @x0 @x1) (Prims.op_Multiply @x0 @x2))))
                 ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(111,2-119,3)
                 (Valid
                  ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(111,2-119,3)
                  (ApplyTT @x3 @x5)))
                :qid @query.18))))
            :qid @query.13))))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_6")
(eval label_6)
(echo "label_5")
(eval label_5)
(echo "label_4")
(eval label_4)
(echo "label_3")
(eval label_3)
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.distributivity_sub_right, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let distributivity_sub_right
; <Start encoding let distributivity_sub_right>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.distributivity_sub_right (Term Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.distributivity_sub_right@tok () Term)
; </end encoding let distributivity_sub_right>

; encoding sigelt val FStar.Math.Lemmas.mul_binds_tighter
; <Skipped val FStar.Math.Lemmas.mul_binds_tighter/>

; encoding sigelt let mul_binds_tighter
; <Start encoding let mul_binds_tighter>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.mul_binds_tighter (Term Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.mul_binds_tighter@tok () Term)
; </end encoding let mul_binds_tighter>

; encoding sigelt val FStar.Math.Lemmas.lemma_abs_mul
; <Skipped val FStar.Math.Lemmas.lemma_abs_mul/>

; free var typing
;;; Fact-ids: Name FStar.Math.Lib.abs; Namespace FStar.Math.Lib
(assert
 (! ;; def=FStar.Math.Lib.fst(66,4-66,7); use=FStar.Math.Lib.fst(66,4-66,7)
  (forall ((@x0 Term))
   (! (implies
     (HasType @x0 Prims.int)
     (HasType (FStar.Math.Lib.abs @x0) (Tm_refine_5b706f1316bc4c0722dc2171363a324f @x0)))
    :pattern ((FStar.Math.Lib.abs @x0))
    :qid typing_FStar.Math.Lib.abs))
  :named typing_FStar.Math.Lib.abs))
; refinement kinding
;;; Fact-ids: Name FStar.Math.Lib.abs; Namespace FStar.Math.Lib
(assert
 (! ;; def=FStar.Math.Lib.fst(65,22-65,73); use=FStar.Math.Lib.fst(66,4-66,7)
  (forall ((@x0 Term))
   (! (HasType (Tm_refine_5b706f1316bc4c0722dc2171363a324f @x0) Tm_type)
    :pattern ((HasType (Tm_refine_5b706f1316bc4c0722dc2171363a324f @x0) Tm_type))
    :qid refinement_kinding_Tm_refine_5b706f1316bc4c0722dc2171363a324f))
  :named refinement_kinding_Tm_refine_5b706f1316bc4c0722dc2171363a324f))
; refinement_interpretation
;;; Fact-ids: Name FStar.Math.Lib.abs; Namespace FStar.Math.Lib
(assert
 (! ;; def=FStar.Math.Lib.fst(65,22-65,73); use=FStar.Math.Lib.fst(66,4-66,7)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
   (! (iff
     (HasTypeFuel @u0 @x1 (Tm_refine_5b706f1316bc4c0722dc2171363a324f @x2))
     (and
      (HasTypeFuel @u0 @x1 Prims.int)
      ;; def=FStar.Math.Lib.fst(65,30-65,48); use=FStar.Math.Lib.fst(66,4-66,7)
      (implies
       ;; def=FStar.Math.Lib.fst(65,31-65,37); use=FStar.Math.Lib.fst(66,4-66,7)
       (>= (BoxInt_proj_0 @x2) (BoxInt_proj_0 (BoxInt 0)))
       ;; def=FStar.Math.Lib.fst(65,42-65,47); use=FStar.Math.Lib.fst(66,4-66,7)
       (= @x1 @x2))
      ;; def=FStar.Math.Lib.fst(65,52-65,70); use=FStar.Math.Lib.fst(66,4-66,7)
      (implies
       ;; def=FStar.Math.Lib.fst(65,53-65,58); use=FStar.Math.Lib.fst(66,4-66,7)
       (< (BoxInt_proj_0 @x2) (BoxInt_proj_0 (BoxInt 0)))
       ;; def=FStar.Math.Lib.fst(65,63-65,69); use=FStar.Math.Lib.fst(66,4-66,7)
       (= @x1 (Prims.op_Minus @x2)))))
    :pattern ((HasTypeFuel @u0 @x1 (Tm_refine_5b706f1316bc4c0722dc2171363a324f @x2)))
    :qid refinement_interpretation_Tm_refine_5b706f1316bc4c0722dc2171363a324f))
  :named refinement_interpretation_Tm_refine_5b706f1316bc4c0722dc2171363a324f))
;;; Fact-ids: Name Prims.op_GreaterThanOrEqual; Namespace Prims
(assert
 (! ;; def=Prims.fst(584,4-584,25); use=Prims.fst(584,4-584,25)
  (forall ((@x0 Term) (@x1 Term))
   (! (=
     (Prims.op_GreaterThanOrEqual @x0 @x1)
     (BoxBool (>= (BoxInt_proj_0 @x0) (BoxInt_proj_0 @x1))))
    :pattern ((Prims.op_GreaterThanOrEqual @x0 @x1))
    :qid primitive_Prims.op_GreaterThanOrEqual))
  :named primitive_Prims.op_GreaterThanOrEqual))
; haseq for Tm_refine_5b706f1316bc4c0722dc2171363a324f
;;; Fact-ids: Name FStar.Math.Lib.abs; Namespace FStar.Math.Lib
(assert
 (! ;; def=FStar.Math.Lib.fst(65,22-65,73); use=FStar.Math.Lib.fst(66,4-66,7)
  (forall ((@x0 Term))
   (! (iff
     (Valid (Prims.hasEq (Tm_refine_5b706f1316bc4c0722dc2171363a324f @x0)))
     (Valid (Prims.hasEq Prims.int)))
    :pattern ((Valid (Prims.hasEq (Tm_refine_5b706f1316bc4c0722dc2171363a324f @x0))))
    :qid haseqTm_refine_5b706f1316bc4c0722dc2171363a324f))
  :named haseqTm_refine_5b706f1316bc4c0722dc2171363a324f))
; Equation for FStar.Math.Lib.abs
;;; Fact-ids: Name FStar.Math.Lib.abs; Namespace FStar.Math.Lib
(assert
 (! ;; def=FStar.Math.Lib.fst(66,4-66,7); use=FStar.Math.Lib.fst(66,4-66,7)
  (forall ((@x0 Term))
   (! (=
     (FStar.Math.Lib.abs @x0)
     (let ((@lb1 (Prims.op_GreaterThanOrEqual @x0 (BoxInt 0))))
      (ite (= @lb1 (BoxBool true)) @x0 (Prims.op_Minus @x0))))
    :pattern ((FStar.Math.Lib.abs @x0))
    :qid equation_FStar.Math.Lib.abs))
  :named equation_FStar.Math.Lib.abs))
(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(124,24-124,26)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (a: Prims.int) (b: Prims.int).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     (forall (pure_result: Prims.unit).
;         FStar.Math.Lib.abs a * FStar.Math.Lib.abs b = FStar.Math.Lib.abs (a * b) ==> p pure_result) ==>
;     (forall (any_result: Prims.unit). p any_result)
; Context: While encoding a query
; While typechecking the top-level declaration `let lemma_abs_mul`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term))
    (! (implies
      (and (HasType @x0 Prims.int) (HasType @x1 Prims.int))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x2 Term))
       (! (implies
         (and
          (HasType @x2 (Prims.pure_post Prims.unit))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(124,24-124,26)
          (forall ((@x3 Term))
           (! (implies
             (and
              (or label_1 (HasType @x3 Prims.unit))
              ;; def=FStar.Math.Lemmas.fsti(109,44-109,73); use=FStar.Math.Lemmas.fst(124,24-124,26)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fsti(109,44-109,73); use=FStar.Math.Lemmas.fst(124,24-124,26)
               (=
                (Prims.op_Multiply (FStar.Math.Lib.abs @x0) (FStar.Math.Lib.abs @x1))
                (FStar.Math.Lib.abs (Prims.op_Multiply @x0 @x1)))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(124,24-124,26)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(124,24-124,26)
              (ApplyTT @x2 @x3)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(124,24-124,26)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(124,24-124,26)
               (ApplyTT @x2 @x3)))
            :qid @query.2)))
         ;; def=Prims.fst(459,66-459,102); use=Prims.fst(462,31-462,44)
         (forall ((@x3 Term))
          (! (implies
            (HasType @x3 Prims.unit)
            ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
            (Valid
             ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
             (ApplyTT @x2 @x3)))
           :qid @query.3)))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.lemma_abs_mul, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let lemma_abs_mul
; <Start encoding let lemma_abs_mul>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.lemma_abs_mul (Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.lemma_abs_mul@tok () Term)
; </end encoding let lemma_abs_mul>

; encoding sigelt val FStar.Math.Lemmas.lemma_abs_bound
; <Skipped val FStar.Math.Lemmas.lemma_abs_bound/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(126,26-126,28)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (a: Prims.int) (b: Prims.nat).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     (forall (pure_result: Prims.unit).
;         (FStar.Math.Lib.abs a < b <==> - b < a /\ a < b) ==> p pure_result) ==>
;     (forall (any_result: Prims.unit). p any_result)
; Context: While encoding a query
; While typechecking the top-level declaration `let lemma_abs_bound`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term))
    (! (implies
      (and (HasType @x0 Prims.int) (HasType @x1 Prims.nat))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x2 Term))
       (! (implies
         (and
          (HasType @x2 (Prims.pure_post Prims.unit))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(126,26-126,28)
          (forall ((@x3 Term))
           (! (implies
             (and
              (or label_1 (HasType @x3 Prims.unit))
              ;; def=FStar.Math.Lemmas.fsti(111,46-111,78); use=FStar.Math.Lemmas.fst(126,26-126,28)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fsti(111,46-111,78); use=FStar.Math.Lemmas.fst(126,26-126,28)
               (iff
                ;; def=FStar.Math.Lemmas.fsti(111,47-111,56); use=FStar.Math.Lemmas.fst(126,26-126,28)
                (< (BoxInt_proj_0 (FStar.Math.Lib.abs @x0)) (BoxInt_proj_0 @x1))
                ;; def=FStar.Math.Lemmas.fsti(111,62-111,77); use=FStar.Math.Lemmas.fst(126,26-126,28)
                (and
                 ;; def=FStar.Math.Lemmas.fsti(111,62-111,68); use=FStar.Math.Lemmas.fst(126,26-126,28)
                 (< (BoxInt_proj_0 (Prims.op_Minus @x1)) (BoxInt_proj_0 @x0))
                 ;; def=FStar.Math.Lemmas.fsti(111,72-111,77); use=FStar.Math.Lemmas.fst(126,26-126,28)
                 (< (BoxInt_proj_0 @x0) (BoxInt_proj_0 @x1))))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(126,26-126,28)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(126,26-126,28)
              (ApplyTT @x2 @x3)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(126,26-126,28)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(126,26-126,28)
               (ApplyTT @x2 @x3)))
            :qid @query.2)))
         ;; def=Prims.fst(459,66-459,102); use=Prims.fst(462,31-462,44)
         (forall ((@x3 Term))
          (! (implies
            (HasType @x3 Prims.unit)
            ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
            (Valid
             ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
             (ApplyTT @x2 @x3)))
           :qid @query.3)))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.lemma_abs_bound, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let lemma_abs_bound
; <Start encoding let lemma_abs_bound>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.lemma_abs_bound (Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.lemma_abs_bound@tok () Term)
; </end encoding let lemma_abs_bound>

; encoding sigelt val FStar.Math.Lemmas.mul_ineq1
; <Skipped val FStar.Math.Lemmas.mul_ineq1/>

;;; Fact-ids: Name Prims.op_Equality; Namespace Prims
(assert
 (! ;; def=Prims.fst(596,4-596,15); use=Prims.fst(596,4-596,15)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term))
   (! (= (Prims.op_Equality @x0 @x1 @x2) (BoxBool (= @x1 @x2)))
    :pattern ((Prims.op_Equality @x0 @x1 @x2))
    :qid primitive_Prims.op_Equality))
  :named primitive_Prims.op_Equality))
;;; Fact-ids: Name Prims.op_BarBar; Namespace Prims
(assert
 (! ;; def=Prims.fst(536,4-536,13); use=Prims.fst(536,4-536,13)
  (forall ((@x0 Term) (@x1 Term))
   (! (= (Prims.op_BarBar @x0 @x1) (BoxBool (or (BoxBool_proj_0 @x0) (BoxBool_proj_0 @x1))))
    :pattern ((Prims.op_BarBar @x0 @x1))
    :qid primitive_Prims.op_BarBar))
  :named primitive_Prims.op_BarBar))
(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(129,2-138,5)
(declare-fun label_8 () Bool)
(declare-fun label_7 () Bool)
(declare-fun label_6 () Bool)
(declare-fun label_5 () Bool)
(declare-fun label_4 () Bool)
(declare-fun label_3 () Bool)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (a: Prims.int) (b: Prims.nat) (c: Prims.int) (d: Prims.nat).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     - b < a /\ a < b /\ - d < c /\ c < d /\
;     (forall (pure_result: Prims.unit). - b * d < a * c /\ a * c < b * d ==> p pure_result) ==>
;     (forall (k: Prims.pure_post Prims.unit).
;         (forall (x: Prims.unit). {:pattern Prims.guard_free (k x)} p x ==> k x) ==>
;         ((a = 0 || c = 0) == true ==> (forall (any_result: Prims.unit). k any_result)) /\
;         (~((a = 0 || c = 0) = true) ==>
;           (forall (b: Prims.bool).
;               (a = 0 || c = 0) == b ==>
;               (forall (pure_result: Prims.unit).
;                   (FStar.Math.Lib.abs a < b <==> - b < a /\ a < b) ==>
;                   (forall (pure_result: Prims.unit).
;                       (FStar.Math.Lib.abs c < d <==> - d < c /\ c < d) ==>
;                       (forall (pure_result: Prims.unit).
;                           FStar.Math.Lib.abs a * FStar.Math.Lib.abs c = FStar.Math.Lib.abs (a * c) ==>
;                           ((a >= 0 ==> FStar.Math.Lib.abs a = a) /\
;                             (a < 0 ==> FStar.Math.Lib.abs a = - a) ==>
;                             FStar.Math.Lib.abs a > 0) /\
;                           (forall (return_val: Prims.pos).
;                               return_val == FStar.Math.Lib.abs a ==>
;                               FStar.Math.Lib.abs c < d /\
;                               (forall (pure_result: Prims.unit).
;                                   FStar.Math.Lib.abs a * FStar.Math.Lib.abs c <
;                                   FStar.Math.Lib.abs a * d ==>
;                                   (d >= 0 ==> d > 0) /\
;                                   (forall (any_result: Prims.nat).
;                                       d == any_result ==>
;                                       FStar.Math.Lib.abs a < b /\
;                                       (forall (pure_result: Prims.unit).
;                                           FStar.Math.Lib.abs a * d < b * d ==>
;                                           b * d >= 0 /\
;                                           (forall (return_val: Prims.nat).
;                                               return_val == b * d ==>
;                                               (forall (pure_result: Prims.unit).
;                                                   (FStar.Math.Lib.abs (a * c) < b * d <==>
;                                                     - b * d < a * c /\ a * c < b * d) ==>
;                                                   (forall (any_result: Prims.unit). k any_result))))
;                                   )))))))))
; Context: While encoding a query
; While typechecking the top-level declaration `let mul_ineq1`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
    (! (implies
      (and
       (HasType @x0 Prims.int)
       (HasType @x1 Prims.nat)
       (HasType @x2 Prims.int)
       (HasType @x3 Prims.nat))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x4 Term))
       (! (implies
         (and
          (HasType @x4 (Prims.pure_post Prims.unit))
          ;; def=FStar.Math.Lemmas.fsti(116,15-116,21); use=FStar.Math.Lemmas.fst(129,2-138,5)
          (< (BoxInt_proj_0 (Prims.op_Minus @x1)) (BoxInt_proj_0 @x0))
          ;; def=FStar.Math.Lemmas.fsti(116,25-116,30); use=FStar.Math.Lemmas.fst(129,2-138,5)
          (< (BoxInt_proj_0 @x0) (BoxInt_proj_0 @x1))
          ;; def=FStar.Math.Lemmas.fsti(117,15-117,21); use=FStar.Math.Lemmas.fst(129,2-138,5)
          (< (BoxInt_proj_0 (Prims.op_Minus @x3)) (BoxInt_proj_0 @x2))
          ;; def=FStar.Math.Lemmas.fsti(117,25-117,30); use=FStar.Math.Lemmas.fst(129,2-138,5)
          (< (BoxInt_proj_0 @x2) (BoxInt_proj_0 @x3))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(129,2-138,5)
          (forall ((@x5 Term))
           (! (implies
             (and
              (or label_1 (HasType @x5 Prims.unit))
              ;; def=FStar.Math.Lemmas.fsti(118,15-118,31); use=FStar.Math.Lemmas.fst(129,2-138,5)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fsti(118,15-118,31); use=FStar.Math.Lemmas.fst(129,2-138,5)
               (<
                (BoxInt_proj_0 (Prims.op_Minus (Prims.op_Multiply @x1 @x3)))
                (BoxInt_proj_0 (Prims.op_Multiply @x0 @x2))))
              ;; def=FStar.Math.Lemmas.fsti(118,35-118,48); use=FStar.Math.Lemmas.fst(129,2-138,5)
              (or
               label_3
               ;; def=FStar.Math.Lemmas.fsti(118,35-118,48); use=FStar.Math.Lemmas.fst(129,2-138,5)
               (<
                (BoxInt_proj_0 (Prims.op_Multiply @x0 @x2))
                (BoxInt_proj_0 (Prims.op_Multiply @x1 @x3)))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(129,2-138,5)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(129,2-138,5)
              (ApplyTT @x4 @x5)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(129,2-138,5)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(129,2-138,5)
               (ApplyTT @x4 @x5)))
            :qid @query.2)))
         ;; def=Prims.fst(410,2-410,97); use=FStar.Math.Lemmas.fst(129,2-138,5)
         (forall ((@x5 Term))
          (! (implies
            (and
             (HasType @x5 (Prims.pure_post Prims.unit))
             ;; def=Prims.fst(410,2-410,97); use=FStar.Math.Lemmas.fst(129,2-138,5)
             (forall ((@x6 Term))
              (! (implies
                ;; def=Prims.fst(410,73-410,79); use=FStar.Math.Lemmas.fst(129,2-138,5)
                (Valid
                 ;; def=Prims.fst(410,73-410,79); use=FStar.Math.Lemmas.fst(129,2-138,5)
                 (ApplyTT @x4 @x6))
                ;; def=Prims.fst(410,84-410,87); use=FStar.Math.Lemmas.fst(129,2-138,5)
                (Valid
                 ;; def=Prims.fst(410,84-410,87); use=FStar.Math.Lemmas.fst(129,2-138,5)
                 (ApplyTT @x5 @x6)))
               :weight 0
               :pattern ((ApplyTT @x5 @x6))
               :qid @query.4)))
            ;; def=Prims.fst(397,2-397,39); use=FStar.Math.Lemmas.fst(129,2-138,5)
            (and
             (implies
              ;; def=FStar.Math.Lemmas.fst(129,5-129,19); use=FStar.Math.Lemmas.fst(129,5-129,19)
              (=
               (Prims.op_BarBar
                (Prims.op_Equality Prims.int @x0 (BoxInt 0))
                (Prims.op_Equality Prims.int @x2 (BoxInt 0)))
               (BoxBool true))
              ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(129,2-138,5)
              (forall ((@x6 Term))
               (! (implies
                 (HasType @x6 Prims.unit)
                 ;; def=Prims.fst(459,90-459,102); use=FStar.Math.Lemmas.fst(129,2-138,5)
                 (Valid
                  ;; def=Prims.fst(459,90-459,102); use=FStar.Math.Lemmas.fst(129,2-138,5)
                  (ApplyTT @x5 @x6)))
                :qid @query.5)))
             (implies
              ;; def=Prims.fst(397,19-397,21); use=FStar.Math.Lemmas.fst(129,2-138,5)
              (not
               ;; def=FStar.Math.Lemmas.fst(129,5-129,19); use=FStar.Math.Lemmas.fst(129,5-129,19)
               (=
                (Prims.op_BarBar
                 (Prims.op_Equality Prims.int @x0 (BoxInt 0))
                 (Prims.op_Equality Prims.int @x2 (BoxInt 0)))
                (BoxBool true)))
              ;; def=Prims.fst(421,99-421,120); use=FStar.Math.Lemmas.fst(129,2-138,5)
              (forall ((@x6 Term))
               (! (implies
                 (and
                  (HasType @x6 Prims.bool)
                  ;; def=FStar.Math.Lemmas.fst(129,5-137,6); use=FStar.Math.Lemmas.fst(129,5-137,6)
                  (=
                   (Prims.op_BarBar
                    (Prims.op_Equality Prims.int @x0 (BoxInt 0))
                    (Prims.op_Equality Prims.int @x2 (BoxInt 0)))
                   @x6))
                 ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(131,4-131,19)
                 (forall ((@x7 Term))
                  (! (implies
                    (and
                     (HasType @x7 Prims.unit)
                     ;; def=FStar.Math.Lemmas.fsti(111,46-111,78); use=FStar.Math.Lemmas.fst(131,4-131,19)
                     (iff
                      ;; def=FStar.Math.Lemmas.fsti(111,47-111,56); use=FStar.Math.Lemmas.fst(131,4-131,19)
                      (< (BoxInt_proj_0 (FStar.Math.Lib.abs @x0)) (BoxInt_proj_0 @x1))
                      ;; def=FStar.Math.Lemmas.fsti(111,62-111,77); use=FStar.Math.Lemmas.fst(131,4-131,19)
                      (and
                       ;; def=FStar.Math.Lemmas.fsti(111,62-111,68); use=FStar.Math.Lemmas.fst(131,4-131,19)
                       (< (BoxInt_proj_0 (Prims.op_Minus @x1)) (BoxInt_proj_0 @x0))
                       ;; def=FStar.Math.Lemmas.fsti(111,72-111,77); use=FStar.Math.Lemmas.fst(131,4-131,19)
                       (< (BoxInt_proj_0 @x0) (BoxInt_proj_0 @x1)))))
                    ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(132,4-132,19)
                    (forall ((@x8 Term))
                     (! (implies
                       (and
                        (HasType @x8 Prims.unit)
                        ;; def=FStar.Math.Lemmas.fsti(111,46-111,78); use=FStar.Math.Lemmas.fst(132,4-132,19)
                        (iff
                         ;; def=FStar.Math.Lemmas.fsti(111,47-111,56); use=FStar.Math.Lemmas.fst(132,4-132,19)
                         (< (BoxInt_proj_0 (FStar.Math.Lib.abs @x2)) (BoxInt_proj_0 @x3))
                         ;; def=FStar.Math.Lemmas.fsti(111,62-111,77); use=FStar.Math.Lemmas.fst(132,4-132,19)
                         (and
                          ;; def=FStar.Math.Lemmas.fsti(111,62-111,68); use=FStar.Math.Lemmas.fst(132,4-132,19)
                          (< (BoxInt_proj_0 (Prims.op_Minus @x3)) (BoxInt_proj_0 @x2))
                          ;; def=FStar.Math.Lemmas.fsti(111,72-111,77); use=FStar.Math.Lemmas.fst(132,4-132,19)
                          (< (BoxInt_proj_0 @x2) (BoxInt_proj_0 @x3)))))
                       ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(133,4-133,17)
                       (forall ((@x9 Term))
                        (! (implies
                          (and
                           (HasType @x9 Prims.unit)
                           ;; def=FStar.Math.Lemmas.fsti(109,44-109,73); use=FStar.Math.Lemmas.fst(133,4-133,17)
                           (=
                            (Prims.op_Multiply (FStar.Math.Lib.abs @x0) (FStar.Math.Lib.abs @x2))
                            (FStar.Math.Lib.abs (Prims.op_Multiply @x0 @x2))))
                          ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(129,2-138,5)
                          (and
                           (implies
                            ;; def=FStar.Math.Lib.fst(65,30-65,70); use=FStar.Math.Lemmas.fst(134,23-134,30)
                            (and
                             ;; def=FStar.Math.Lib.fst(65,30-65,48); use=FStar.Math.Lemmas.fst(134,23-134,30)
                             (implies
                              ;; def=FStar.Math.Lib.fst(65,31-65,37); use=FStar.Math.Lemmas.fst(134,23-134,30)
                              (>= (BoxInt_proj_0 @x0) (BoxInt_proj_0 (BoxInt 0)))
                              ;; def=FStar.Math.Lib.fst(65,42-65,47); use=FStar.Math.Lemmas.fst(134,23-134,30)
                              (= (FStar.Math.Lib.abs @x0) @x0))
                             ;; def=FStar.Math.Lib.fst(65,52-65,70); use=FStar.Math.Lemmas.fst(134,23-134,30)
                             (implies
                              ;; def=FStar.Math.Lib.fst(65,53-65,58); use=FStar.Math.Lemmas.fst(134,23-134,30)
                              (< (BoxInt_proj_0 @x0) (BoxInt_proj_0 (BoxInt 0)))
                              ;; def=FStar.Math.Lib.fst(65,63-65,69); use=FStar.Math.Lemmas.fst(134,23-134,30)
                              (= (FStar.Math.Lib.abs @x0) (Prims.op_Minus @x0))))
                            ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(134,23-134,30)
                            (or
                             label_4
                             ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(134,23-134,30)
                             (> (BoxInt_proj_0 (FStar.Math.Lib.abs @x0)) (BoxInt_proj_0 (BoxInt 0)))))
                           ;; def=Prims.fst(364,2-364,58); use=FStar.Math.Lemmas.fst(129,2-138,5)
                           (forall ((@x10 Term))
                            (! (implies
                              (and
                               (HasType @x10 Prims.pos)
                               ;; def=Prims.fst(364,26-364,41); use=FStar.Math.Lemmas.fst(129,2-138,5)
                               (= @x10 (FStar.Math.Lib.abs @x0)))
                              ;; def=Prims.fst(449,29-449,97); use=FStar.Math.Lemmas.fst(134,4-134,22)
                              (and
                               ;; def=FStar.Math.Lemmas.fsti(37,12-37,19); use=FStar.Math.Lemmas.fst(134,4-134,22)
                               (or
                                label_5
                                ;; def=FStar.Math.Lemmas.fsti(37,12-37,19); use=FStar.Math.Lemmas.fst(134,4-134,22)
                                (< (BoxInt_proj_0 (FStar.Math.Lib.abs @x2)) (BoxInt_proj_0 @x3)))
                               ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(134,4-134,22)
                               (forall ((@x11 Term))
                                (! (implies
                                  (and
                                   (HasType @x11 Prims.unit)
                                   ;; def=FStar.Math.Lemmas.fsti(38,12-38,27); use=FStar.Math.Lemmas.fst(134,4-134,22)
                                   (<
                                    (BoxInt_proj_0
                                     (Prims.op_Multiply
                                      (FStar.Math.Lib.abs @x0)
                                      (FStar.Math.Lib.abs @x2)))
                                    (BoxInt_proj_0 (Prims.op_Multiply (FStar.Math.Lib.abs @x0) @x3))))
                                  ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(129,2-138,5)
                                  (and
                                   (implies
                                    ;; def=Prims.fst(682,18-682,24); use=FStar.Math.Lemmas.fst(135,24-135,25)
                                    (>= (BoxInt_proj_0 @x3) (BoxInt_proj_0 (BoxInt 0)))
                                    ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(135,24-135,25)
                                    (or
                                     label_6
                                     ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(135,24-135,25)
                                     (> (BoxInt_proj_0 @x3) (BoxInt_proj_0 (BoxInt 0)))))
                                   ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(129,2-138,5)
                                   (forall ((@x12 Term))
                                    (! (implies
                                      (and
                                       (HasType @x12 Prims.nat)
                                       ;; def=FStar.Math.Lemmas.fsti(40,25-40,26); use=FStar.Math.Lemmas.fst(129,2-138,5)
                                       (= @x3 @x12))
                                      ;; def=Prims.fst(449,29-449,97); use=FStar.Math.Lemmas.fst(135,4-135,23)
                                      (and
                                       ;; def=FStar.Math.Lemmas.fsti(41,12-41,19); use=FStar.Math.Lemmas.fst(135,4-135,23)
                                       (or
                                        label_7
                                        ;; def=FStar.Math.Lemmas.fsti(41,12-41,19); use=FStar.Math.Lemmas.fst(135,4-135,23)
                                        (<
                                         (BoxInt_proj_0 (FStar.Math.Lib.abs @x0))
                                         (BoxInt_proj_0 @x1)))
                                       ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(135,4-135,23)
                                       (forall ((@x13 Term))
                                        (! (implies
                                          (and
                                           (HasType @x13 Prims.unit)
                                           ;; def=FStar.Math.Lemmas.fsti(42,12-42,27); use=FStar.Math.Lemmas.fst(135,4-135,23)
                                           (<
                                            (BoxInt_proj_0
                                             (Prims.op_Multiply (FStar.Math.Lib.abs @x0) @x3))
                                            (BoxInt_proj_0 (Prims.op_Multiply @x1 @x3))))
                                          ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(129,2-138,5)
                                          (and
                                           ;; def=Prims.fst(682,18-682,24); use=FStar.Math.Lemmas.fst(136,28-136,35)
                                           (or
                                            label_8
                                            ;; def=Prims.fst(682,18-682,24); use=FStar.Math.Lemmas.fst(136,28-136,35)
                                            (>=
                                             (BoxInt_proj_0 (Prims.op_Multiply @x1 @x3))
                                             (BoxInt_proj_0 (BoxInt 0))))
                                           ;; def=Prims.fst(364,2-364,58); use=FStar.Math.Lemmas.fst(129,2-138,5)
                                           (forall ((@x14 Term))
                                            (! (implies
                                              (and
                                               (HasType @x14 Prims.nat)
                                               ;; def=Prims.fst(364,26-364,41); use=FStar.Math.Lemmas.fst(129,2-138,5)
                                               (= @x14 (Prims.op_Multiply @x1 @x3)))
                                              ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(136,4-136,19)
                                              (forall ((@x15 Term))
                                               (! (implies
                                                 (and
                                                  (HasType @x15 Prims.unit)
                                                  ;; def=FStar.Math.Lemmas.fsti(111,46-111,78); use=FStar.Math.Lemmas.fst(136,4-136,19)
                                                  (iff
                                                   ;; def=FStar.Math.Lemmas.fsti(111,47-111,56); use=FStar.Math.Lemmas.fst(136,4-136,19)
                                                   (<
                                                    (BoxInt_proj_0
                                                     (FStar.Math.Lib.abs (Prims.op_Multiply @x0 @x2)))
                                                    (BoxInt_proj_0 (Prims.op_Multiply @x1 @x3)))
                                                   ;; def=FStar.Math.Lemmas.fsti(111,62-111,77); use=FStar.Math.Lemmas.fst(136,4-136,19)
                                                   (and
                                                    ;; def=FStar.Math.Lemmas.fsti(111,62-111,68); use=FStar.Math.Lemmas.fst(136,4-136,19)
                                                    (<
                                                     (BoxInt_proj_0
                                                      (Prims.op_Minus (Prims.op_Multiply @x1 @x3)))
                                                     (BoxInt_proj_0 (Prims.op_Multiply @x0 @x2)))
                                                    ;; def=FStar.Math.Lemmas.fsti(111,72-111,77); use=FStar.Math.Lemmas.fst(136,4-136,19)
                                                    (<
                                                     (BoxInt_proj_0 (Prims.op_Multiply @x0 @x2))
                                                     (BoxInt_proj_0 (Prims.op_Multiply @x1 @x3))))))
                                                 ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(129,2-138,5)
                                                 (forall ((@x16 Term))
                                                  (! (implies
                                                    (HasType @x16 Prims.unit)
                                                    ;; def=Prims.fst(459,90-459,102); use=FStar.Math.Lemmas.fst(129,2-138,5)
                                                    (Valid
                                                     ;; def=Prims.fst(459,90-459,102); use=FStar.Math.Lemmas.fst(129,2-138,5)
                                                     (ApplyTT @x5 @x16)))
                                                   :qid @query.16)))
                                                :qid @query.15)))
                                             :qid @query.14))))
                                         :qid @query.13))))
                                     :qid @query.12))))
                                 :qid @query.11))))
                             :qid @query.10))))
                         :qid @query.9)))
                      :qid @query.8)))
                   :qid @query.7)))
                :qid @query.6)))))
           :qid @query.3)))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_8")
(eval label_8)
(echo "label_7")
(eval label_7)
(echo "label_6")
(eval label_6)
(echo "label_5")
(eval label_5)
(echo "label_4")
(eval label_4)
(echo "label_3")
(eval label_3)
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.mul_ineq1, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let mul_ineq1
; <Start encoding let mul_ineq1>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.mul_ineq1 (Term Term Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.mul_ineq1@tok () Term)
; </end encoding let mul_ineq1>

; encoding sigelt val FStar.Math.Lemmas.add_zero_left_is_same
; <Skipped val FStar.Math.Lemmas.add_zero_left_is_same/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(141,57-141,59)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (n: Prims.int).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     (forall (pure_result: Prims.unit). 0 + n = n ==> p pure_result) ==>
;     (forall (any_result: Prims.unit). p any_result)
; Context: While encoding a query
; While typechecking the top-level declaration `let add_zero_left_is_same`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term))
    (! (implies
      (HasType @x0 Prims.int)
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x1 Term))
       (! (implies
         (and
          (HasType @x1 (Prims.pure_post Prims.unit))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(141,57-141,59)
          (forall ((@x2 Term))
           (! (implies
             (and
              (or label_1 (HasType @x2 Prims.unit))
              ;; def=FStar.Math.Lemmas.fst(141,43-141,54); use=FStar.Math.Lemmas.fst(141,57-141,59)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fst(141,43-141,54); use=FStar.Math.Lemmas.fst(141,57-141,59)
               (= (Prims.op_Addition (BoxInt 0) @x0) @x0)))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(141,57-141,59)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(141,57-141,59)
              (ApplyTT @x1 @x2)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(141,57-141,59)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(141,57-141,59)
               (ApplyTT @x1 @x2)))
            :qid @query.2)))
         ;; def=Prims.fst(459,66-459,102); use=Prims.fst(462,31-462,44)
         (forall ((@x2 Term))
          (! (implies
            (HasType @x2 Prims.unit)
            ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
            (Valid
             ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
             (ApplyTT @x1 @x2)))
           :qid @query.3)))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.add_zero_left_is_same, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let add_zero_left_is_same
; <Start encoding let add_zero_left_is_same>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.add_zero_left_is_same (Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.add_zero_left_is_same@tok () Term)
; </end encoding let add_zero_left_is_same>

; encoding sigelt val FStar.Math.Lemmas.add_zero_right_is_same
; <Skipped val FStar.Math.Lemmas.add_zero_right_is_same/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(142,58-142,60)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (n: Prims.int).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     (forall (pure_result: Prims.unit). n + 0 = n ==> p pure_result) ==>
;     (forall (any_result: Prims.unit). p any_result)
; Context: While encoding a query
; While typechecking the top-level declaration `let add_zero_right_is_same`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term))
    (! (implies
      (HasType @x0 Prims.int)
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x1 Term))
       (! (implies
         (and
          (HasType @x1 (Prims.pure_post Prims.unit))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(142,58-142,60)
          (forall ((@x2 Term))
           (! (implies
             (and
              (or label_1 (HasType @x2 Prims.unit))
              ;; def=FStar.Math.Lemmas.fst(142,44-142,55); use=FStar.Math.Lemmas.fst(142,58-142,60)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fst(142,44-142,55); use=FStar.Math.Lemmas.fst(142,58-142,60)
               (= (Prims.op_Addition @x0 (BoxInt 0)) @x0)))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(142,58-142,60)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(142,58-142,60)
              (ApplyTT @x1 @x2)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(142,58-142,60)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(142,58-142,60)
               (ApplyTT @x1 @x2)))
            :qid @query.2)))
         ;; def=Prims.fst(459,66-459,102); use=Prims.fst(462,31-462,44)
         (forall ((@x2 Term))
          (! (implies
            (HasType @x2 Prims.unit)
            ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
            (Valid
             ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
             (ApplyTT @x1 @x2)))
           :qid @query.3)))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.add_zero_right_is_same, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let add_zero_right_is_same
; <Start encoding let add_zero_right_is_same>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.add_zero_right_is_same (Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.add_zero_right_is_same@tok () Term)
; </end encoding let add_zero_right_is_same>

; encoding sigelt val FStar.Math.Lemmas.mul_one_left_is_same
; <Skipped val FStar.Math.Lemmas.mul_one_left_is_same/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(145,56-145,58)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (n: Prims.int).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     (forall (pure_result: Prims.unit). 1 * n = n ==> p pure_result) ==>
;     (forall (any_result: Prims.unit). p any_result)
; Context: While encoding a query
; While typechecking the top-level declaration `let mul_one_left_is_same`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term))
    (! (implies
      (HasType @x0 Prims.int)
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x1 Term))
       (! (implies
         (and
          (HasType @x1 (Prims.pure_post Prims.unit))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(145,56-145,58)
          (forall ((@x2 Term))
           (! (implies
             (and
              (or label_1 (HasType @x2 Prims.unit))
              ;; def=FStar.Math.Lemmas.fst(145,42-145,53); use=FStar.Math.Lemmas.fst(145,56-145,58)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fst(145,42-145,53); use=FStar.Math.Lemmas.fst(145,56-145,58)
               (= (Prims.op_Multiply (BoxInt 1) @x0) @x0)))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(145,56-145,58)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(145,56-145,58)
              (ApplyTT @x1 @x2)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(145,56-145,58)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(145,56-145,58)
               (ApplyTT @x1 @x2)))
            :qid @query.2)))
         ;; def=Prims.fst(459,66-459,102); use=Prims.fst(462,31-462,44)
         (forall ((@x2 Term))
          (! (implies
            (HasType @x2 Prims.unit)
            ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
            (Valid
             ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
             (ApplyTT @x1 @x2)))
           :qid @query.3)))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.mul_one_left_is_same, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let mul_one_left_is_same
; <Start encoding let mul_one_left_is_same>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.mul_one_left_is_same (Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.mul_one_left_is_same@tok () Term)
; </end encoding let mul_one_left_is_same>

; encoding sigelt val FStar.Math.Lemmas.mul_one_right_is_same
; <Skipped val FStar.Math.Lemmas.mul_one_right_is_same/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(146,57-146,59)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (n: Prims.int).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     (forall (pure_result: Prims.unit). n * 1 = n ==> p pure_result) ==>
;     (forall (any_result: Prims.unit). p any_result)
; Context: While encoding a query
; While typechecking the top-level declaration `let mul_one_right_is_same`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term))
    (! (implies
      (HasType @x0 Prims.int)
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x1 Term))
       (! (implies
         (and
          (HasType @x1 (Prims.pure_post Prims.unit))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(146,57-146,59)
          (forall ((@x2 Term))
           (! (implies
             (and
              (or label_1 (HasType @x2 Prims.unit))
              ;; def=FStar.Math.Lemmas.fst(146,43-146,54); use=FStar.Math.Lemmas.fst(146,57-146,59)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fst(146,43-146,54); use=FStar.Math.Lemmas.fst(146,57-146,59)
               (= (Prims.op_Multiply @x0 (BoxInt 1)) @x0)))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(146,57-146,59)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(146,57-146,59)
              (ApplyTT @x1 @x2)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(146,57-146,59)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(146,57-146,59)
               (ApplyTT @x1 @x2)))
            :qid @query.2)))
         ;; def=Prims.fst(459,66-459,102); use=Prims.fst(462,31-462,44)
         (forall ((@x2 Term))
          (! (implies
            (HasType @x2 Prims.unit)
            ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
            (Valid
             ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
             (ApplyTT @x1 @x2)))
           :qid @query.3)))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.mul_one_right_is_same, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let mul_one_right_is_same
; <Start encoding let mul_one_right_is_same>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.mul_one_right_is_same (Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.mul_one_right_is_same@tok () Term)
; </end encoding let mul_one_right_is_same>

; encoding sigelt val FStar.Math.Lemmas.mul_zero_left_is_zero
; <Skipped val FStar.Math.Lemmas.mul_zero_left_is_zero/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(149,57-149,59)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (n: Prims.int).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     (forall (pure_result: Prims.unit). 0 * n = 0 ==> p pure_result) ==>
;     (forall (any_result: Prims.unit). p any_result)
; Context: While encoding a query
; While typechecking the top-level declaration `let mul_zero_left_is_zero`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term))
    (! (implies
      (HasType @x0 Prims.int)
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x1 Term))
       (! (implies
         (and
          (HasType @x1 (Prims.pure_post Prims.unit))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(149,57-149,59)
          (forall ((@x2 Term))
           (! (implies
             (and
              (or label_1 (HasType @x2 Prims.unit))
              ;; def=FStar.Math.Lemmas.fst(149,43-149,54); use=FStar.Math.Lemmas.fst(149,57-149,59)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fst(149,43-149,54); use=FStar.Math.Lemmas.fst(149,57-149,59)
               (= (Prims.op_Multiply (BoxInt 0) @x0) (BoxInt 0))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(149,57-149,59)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(149,57-149,59)
              (ApplyTT @x1 @x2)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(149,57-149,59)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(149,57-149,59)
               (ApplyTT @x1 @x2)))
            :qid @query.2)))
         ;; def=Prims.fst(459,66-459,102); use=Prims.fst(462,31-462,44)
         (forall ((@x2 Term))
          (! (implies
            (HasType @x2 Prims.unit)
            ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
            (Valid
             ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
             (ApplyTT @x1 @x2)))
           :qid @query.3)))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.mul_zero_left_is_zero, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let mul_zero_left_is_zero
; <Start encoding let mul_zero_left_is_zero>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.mul_zero_left_is_zero (Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.mul_zero_left_is_zero@tok () Term)
; </end encoding let mul_zero_left_is_zero>

; encoding sigelt val FStar.Math.Lemmas.mul_zero_right_is_zero
; <Skipped val FStar.Math.Lemmas.mul_zero_right_is_zero/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(150,58-150,60)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (n: Prims.int).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     (forall (pure_result: Prims.unit). n * 0 = 0 ==> p pure_result) ==>
;     (forall (any_result: Prims.unit). p any_result)
; Context: While encoding a query
; While typechecking the top-level declaration `let mul_zero_right_is_zero`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term))
    (! (implies
      (HasType @x0 Prims.int)
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x1 Term))
       (! (implies
         (and
          (HasType @x1 (Prims.pure_post Prims.unit))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(150,58-150,60)
          (forall ((@x2 Term))
           (! (implies
             (and
              (or label_1 (HasType @x2 Prims.unit))
              ;; def=FStar.Math.Lemmas.fst(150,44-150,55); use=FStar.Math.Lemmas.fst(150,58-150,60)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fst(150,44-150,55); use=FStar.Math.Lemmas.fst(150,58-150,60)
               (= (Prims.op_Multiply @x0 (BoxInt 0)) (BoxInt 0))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(150,58-150,60)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(150,58-150,60)
              (ApplyTT @x1 @x2)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(150,58-150,60)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(150,58-150,60)
               (ApplyTT @x1 @x2)))
            :qid @query.2)))
         ;; def=Prims.fst(459,66-459,102); use=Prims.fst(462,31-462,44)
         (forall ((@x2 Term))
          (! (implies
            (HasType @x2 Prims.unit)
            ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
            (Valid
             ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
             (ApplyTT @x1 @x2)))
           :qid @query.3)))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.mul_zero_right_is_zero, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let mul_zero_right_is_zero
; <Start encoding let mul_zero_right_is_zero>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.mul_zero_right_is_zero (Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.mul_zero_right_is_zero@tok () Term)
; </end encoding let mul_zero_right_is_zero>

; encoding sigelt val FStar.Math.Lemmas.nat_times_nat_is_nat
; <Skipped val FStar.Math.Lemmas.nat_times_nat_is_nat/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(152,31-152,33)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (a: Prims.nat) (b: Prims.nat).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     (forall (pure_result: Prims.unit). a * b >= 0 ==> p pure_result) ==>
;     (forall (any_result: Prims.unit). p any_result)
; Context: While encoding a query
; While typechecking the top-level declaration `let nat_times_nat_is_nat`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term))
    (! (implies
      (and (HasType @x0 Prims.nat) (HasType @x1 Prims.nat))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x2 Term))
       (! (implies
         (and
          (HasType @x2 (Prims.pure_post Prims.unit))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(152,31-152,33)
          (forall ((@x3 Term))
           (! (implies
             (and
              (or label_1 (HasType @x3 Prims.unit))
              ;; def=FStar.Math.Lemmas.fsti(132,50-132,62); use=FStar.Math.Lemmas.fst(152,31-152,33)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fsti(132,50-132,62); use=FStar.Math.Lemmas.fst(152,31-152,33)
               (>= (BoxInt_proj_0 (Prims.op_Multiply @x0 @x1)) (BoxInt_proj_0 (BoxInt 0)))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(152,31-152,33)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(152,31-152,33)
              (ApplyTT @x2 @x3)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(152,31-152,33)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(152,31-152,33)
               (ApplyTT @x2 @x3)))
            :qid @query.2)))
         ;; def=Prims.fst(459,66-459,102); use=Prims.fst(462,31-462,44)
         (forall ((@x3 Term))
          (! (implies
            (HasType @x3 Prims.unit)
            ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
            (Valid
             ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
             (ApplyTT @x2 @x3)))
           :qid @query.3)))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.nat_times_nat_is_nat, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let nat_times_nat_is_nat
; <Start encoding let nat_times_nat_is_nat>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.nat_times_nat_is_nat (Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.nat_times_nat_is_nat@tok () Term)
; </end encoding let nat_times_nat_is_nat>

; encoding sigelt val FStar.Math.Lemmas.pos_times_pos_is_pos
; <Skipped val FStar.Math.Lemmas.pos_times_pos_is_pos/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(154,31-154,33)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (a: Prims.pos) (b: Prims.pos).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     (forall (pure_result: Prims.unit). a * b > 0 ==> p pure_result) ==>
;     (forall (any_result: Prims.unit). p any_result)
; Context: While encoding a query
; While typechecking the top-level declaration `let pos_times_pos_is_pos`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term))
    (! (implies
      (and (HasType @x0 Prims.pos) (HasType @x1 Prims.pos))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x2 Term))
       (! (implies
         (and
          (HasType @x2 (Prims.pure_post Prims.unit))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(154,31-154,33)
          (forall ((@x3 Term))
           (! (implies
             (and
              (or label_1 (HasType @x3 Prims.unit))
              ;; def=FStar.Math.Lemmas.fsti(134,50-134,61); use=FStar.Math.Lemmas.fst(154,31-154,33)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fsti(134,50-134,61); use=FStar.Math.Lemmas.fst(154,31-154,33)
               (> (BoxInt_proj_0 (Prims.op_Multiply @x0 @x1)) (BoxInt_proj_0 (BoxInt 0)))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(154,31-154,33)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(154,31-154,33)
              (ApplyTT @x2 @x3)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(154,31-154,33)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(154,31-154,33)
               (ApplyTT @x2 @x3)))
            :qid @query.2)))
         ;; def=Prims.fst(459,66-459,102); use=Prims.fst(462,31-462,44)
         (forall ((@x3 Term))
          (! (implies
            (HasType @x3 Prims.unit)
            ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
            (Valid
             ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
             (ApplyTT @x2 @x3)))
           :qid @query.3)))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.pos_times_pos_is_pos, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let pos_times_pos_is_pos
; <Start encoding let pos_times_pos_is_pos>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.pos_times_pos_is_pos (Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.pos_times_pos_is_pos@tok () Term)
; </end encoding let pos_times_pos_is_pos>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fsti(136,0-136,61)
(declare-fun label_1 () Bool)
(declare-fun Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9 () Term)
; refinement kinding
;;; Fact-ids: 
(assert
 (! (HasType Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9 Tm_type)
  :named refinement_kinding_Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
; refinement_interpretation
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fsti(136,43-136,61); use=FStar.Math.Lemmas.fsti(136,43-136,48)
  (forall ((@u0 Fuel) (@x1 Term))
   (! (iff
     (HasTypeFuel @u0 @x1 Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9)
     (HasTypeFuel @u0 @x1 Prims.unit))
    :pattern ((HasTypeFuel @u0 @x1 Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
    :qid refinement_interpretation_Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
  :named refinement_interpretation_Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
; haseq for Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9
;;; Fact-ids: 
(assert
 (! (iff
   (Valid (Prims.hasEq Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
   (Valid (Prims.hasEq Prims.unit)))
  :named haseqTm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
; Encoding query formula : forall (a: Prims.nat) (b: Prims.pos) (_: Prims.squash Prims.l_True).
;   (*  - Could not prove post-condition
; *) b > 0 ==> b <> 0
; Context: While encoding a query
; While typechecking the top-level declaration `val FStar.Math.Lemmas.nat_over_pos_is_nat`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fsti(136,0-136,61)
   (forall ((@x0 Term) (@x1 Term) (@x2 Term))
    (! (implies
      (and
       (HasType @x0 Prims.nat)
       (HasType @x1 Prims.pos)
       (HasType @x2 Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9)
       ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fsti(136,54-136,55)
       (> (BoxInt_proj_0 @x1) (BoxInt_proj_0 (BoxInt 0))))
      ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fsti(136,54-136,55)
      (or
       label_1
       ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fsti(136,54-136,55)
       (not (= @x1 (BoxInt 0)))))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.nat_over_pos_is_nat, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt val FStar.Math.Lemmas.nat_over_pos_is_nat
; <Skipped val FStar.Math.Lemmas.nat_over_pos_is_nat/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(156,30-156,32)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (a: Prims.nat) (b: Prims.pos).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     (forall (pure_result: Prims.unit). a / b >= 0 ==> p pure_result) ==>
;     (forall (any_result: Prims.unit). p any_result)
; Context: While encoding a query
; While typechecking the top-level declaration `let nat_over_pos_is_nat`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term))
    (! (implies
      (and (HasType @x0 Prims.nat) (HasType @x1 Prims.pos))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x2 Term))
       (! (implies
         (and
          (HasType @x2 (Prims.pure_post Prims.unit))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(156,30-156,32)
          (forall ((@x3 Term))
           (! (implies
             (and
              (or label_1 (HasType @x3 Prims.unit))
              ;; def=FStar.Math.Lemmas.fsti(136,49-136,61); use=FStar.Math.Lemmas.fst(156,30-156,32)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fsti(136,49-136,61); use=FStar.Math.Lemmas.fst(156,30-156,32)
               (>= (BoxInt_proj_0 (Prims.op_Division @x0 @x1)) (BoxInt_proj_0 (BoxInt 0)))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(156,30-156,32)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(156,30-156,32)
              (ApplyTT @x2 @x3)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(156,30-156,32)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(156,30-156,32)
               (ApplyTT @x2 @x3)))
            :qid @query.2)))
         ;; def=Prims.fst(459,66-459,102); use=Prims.fst(462,31-462,44)
         (forall ((@x3 Term))
          (! (implies
            (HasType @x3 Prims.unit)
            ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
            (Valid
             ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
             (ApplyTT @x2 @x3)))
           :qid @query.3)))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.nat_over_pos_is_nat, 2)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let nat_over_pos_is_nat
; <Start encoding let nat_over_pos_is_nat>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.nat_over_pos_is_nat (Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.nat_over_pos_is_nat@tok () Term)
; </end encoding let nat_over_pos_is_nat>

; encoding sigelt val FStar.Math.Lemmas.nat_plus_nat_equal_zero_lemma
; <Skipped val FStar.Math.Lemmas.nat_plus_nat_equal_zero_lemma/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(158,40-158,42)
(declare-fun label_3 () Bool)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
(declare-fun Tm_refine_eccf147327f3985dffafc88d990d08b8 (Term) Term)
; refinement kinding
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fsti(138,44-138,60); use=FStar.Math.Lemmas.fst(158,4-158,33)
  (forall ((@x0 Term))
   (! (HasType (Tm_refine_eccf147327f3985dffafc88d990d08b8 @x0) Tm_type)
    :pattern ((HasType (Tm_refine_eccf147327f3985dffafc88d990d08b8 @x0) Tm_type))
    :qid refinement_kinding_Tm_refine_eccf147327f3985dffafc88d990d08b8))
  :named refinement_kinding_Tm_refine_eccf147327f3985dffafc88d990d08b8))
; refinement_interpretation
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fsti(138,44-138,60); use=FStar.Math.Lemmas.fst(158,4-158,33)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
   (! (iff
     (HasTypeFuel @u0 @x1 (Tm_refine_eccf147327f3985dffafc88d990d08b8 @x2))
     (and
      (HasTypeFuel @u0 @x1 Prims.nat)
      ;; def=FStar.Math.Lemmas.fsti(138,50-138,59); use=FStar.Math.Lemmas.fst(158,4-158,33)
      (= (Prims.op_Addition @x2 @x1) (BoxInt 0))))
    :pattern ((HasTypeFuel @u0 @x1 (Tm_refine_eccf147327f3985dffafc88d990d08b8 @x2)))
    :qid refinement_interpretation_Tm_refine_eccf147327f3985dffafc88d990d08b8))
  :named refinement_interpretation_Tm_refine_eccf147327f3985dffafc88d990d08b8))
; haseq for Tm_refine_eccf147327f3985dffafc88d990d08b8
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fsti(138,44-138,60); use=FStar.Math.Lemmas.fst(158,4-158,33)
  (forall ((@x0 Term))
   (! (iff
     (Valid (Prims.hasEq (Tm_refine_eccf147327f3985dffafc88d990d08b8 @x0)))
     (Valid (Prims.hasEq Prims.nat)))
    :pattern ((Valid (Prims.hasEq (Tm_refine_eccf147327f3985dffafc88d990d08b8 @x0))))
    :qid haseqTm_refine_eccf147327f3985dffafc88d990d08b8))
  :named haseqTm_refine_eccf147327f3985dffafc88d990d08b8))
; Encoding query formula : forall (a: Prims.nat) (b: Prims.nat{a + b = 0}).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     (forall (pure_result: Prims.unit). a = 0 /\ b = 0 ==> p pure_result) ==>
;     (forall (any_result: Prims.unit). p any_result)
; Context: While encoding a query
; While typechecking the top-level declaration `let nat_plus_nat_equal_zero_lemma`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term))
    (! (implies
      (and (HasType @x0 Prims.nat) (HasType @x1 (Tm_refine_eccf147327f3985dffafc88d990d08b8 @x0)))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x2 Term))
       (! (implies
         (and
          (HasType @x2 (Prims.pure_post Prims.unit))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(158,40-158,42)
          (forall ((@x3 Term))
           (! (implies
             (and
              (or label_1 (HasType @x3 Prims.unit))
              ;; def=FStar.Math.Lemmas.fsti(138,70-138,75); use=FStar.Math.Lemmas.fst(158,40-158,42)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fsti(138,70-138,75); use=FStar.Math.Lemmas.fst(158,40-158,42)
               (= @x0 (BoxInt 0)))
              ;; def=FStar.Math.Lemmas.fsti(138,79-138,84); use=FStar.Math.Lemmas.fst(158,40-158,42)
              (or
               label_3
               ;; def=FStar.Math.Lemmas.fsti(138,79-138,84); use=FStar.Math.Lemmas.fst(158,40-158,42)
               (= @x1 (BoxInt 0))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(158,40-158,42)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(158,40-158,42)
              (ApplyTT @x2 @x3)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(158,40-158,42)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(158,40-158,42)
               (ApplyTT @x2 @x3)))
            :qid @query.2)))
         ;; def=Prims.fst(459,66-459,102); use=Prims.fst(462,31-462,44)
         (forall ((@x3 Term))
          (! (implies
            (HasType @x3 Prims.unit)
            ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
            (Valid
             ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
             (ApplyTT @x2 @x3)))
           :qid @query.3)))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_3")
(eval label_3)
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.nat_plus_nat_equal_zero_lemma, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let nat_plus_nat_equal_zero_lemma
; <Start encoding let nat_plus_nat_equal_zero_lemma>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.nat_plus_nat_equal_zero_lemma (Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.nat_plus_nat_equal_zero_lemma@tok () Term)
; </end encoding let nat_plus_nat_equal_zero_lemma>

; encoding sigelt val FStar.Math.Lemmas.int_times_int_equal_zero_lemma
; <Skipped val FStar.Math.Lemmas.int_times_int_equal_zero_lemma/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(160,41-160,43)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
(declare-fun Tm_refine_2b01395e9078edff94f88e62ec027673 (Term) Term)
; refinement kinding
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fsti(140,45-140,61); use=FStar.Math.Lemmas.fst(160,4-160,34)
  (forall ((@x0 Term))
   (! (HasType (Tm_refine_2b01395e9078edff94f88e62ec027673 @x0) Tm_type)
    :pattern ((HasType (Tm_refine_2b01395e9078edff94f88e62ec027673 @x0) Tm_type))
    :qid refinement_kinding_Tm_refine_2b01395e9078edff94f88e62ec027673))
  :named refinement_kinding_Tm_refine_2b01395e9078edff94f88e62ec027673))
; refinement_interpretation
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fsti(140,45-140,61); use=FStar.Math.Lemmas.fst(160,4-160,34)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
   (! (iff
     (HasTypeFuel @u0 @x1 (Tm_refine_2b01395e9078edff94f88e62ec027673 @x2))
     (and
      (HasTypeFuel @u0 @x1 Prims.int)
      ;; def=FStar.Math.Lemmas.fsti(140,51-140,60); use=FStar.Math.Lemmas.fst(160,4-160,34)
      (= (Prims.op_Multiply @x2 @x1) (BoxInt 0))))
    :pattern ((HasTypeFuel @u0 @x1 (Tm_refine_2b01395e9078edff94f88e62ec027673 @x2)))
    :qid refinement_interpretation_Tm_refine_2b01395e9078edff94f88e62ec027673))
  :named refinement_interpretation_Tm_refine_2b01395e9078edff94f88e62ec027673))
; haseq for Tm_refine_2b01395e9078edff94f88e62ec027673
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fsti(140,45-140,61); use=FStar.Math.Lemmas.fst(160,4-160,34)
  (forall ((@x0 Term))
   (! (iff
     (Valid (Prims.hasEq (Tm_refine_2b01395e9078edff94f88e62ec027673 @x0)))
     (Valid (Prims.hasEq Prims.int)))
    :pattern ((Valid (Prims.hasEq (Tm_refine_2b01395e9078edff94f88e62ec027673 @x0))))
    :qid haseqTm_refine_2b01395e9078edff94f88e62ec027673))
  :named haseqTm_refine_2b01395e9078edff94f88e62ec027673))
; Encoding query formula : forall (a: Prims.int) (b: Prims.int{a * b = 0}).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     (forall (pure_result: Prims.unit). a = 0 \/ b = 0 ==> p pure_result) ==>
;     (forall (any_result: Prims.unit). p any_result)
; Context: While encoding a query
; While typechecking the top-level declaration `let int_times_int_equal_zero_lemma`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term))
    (! (implies
      (and (HasType @x0 Prims.int) (HasType @x1 (Tm_refine_2b01395e9078edff94f88e62ec027673 @x0)))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x2 Term))
       (! (implies
         (and
          (HasType @x2 (Prims.pure_post Prims.unit))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(160,41-160,43)
          (forall ((@x3 Term))
           (! (implies
             (and
              (or label_1 (HasType @x3 Prims.unit))
              ;; def=FStar.Math.Lemmas.fsti(140,70-140,86); use=FStar.Math.Lemmas.fst(160,41-160,43)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fsti(140,71-140,76); use=FStar.Math.Lemmas.fst(160,41-160,43)
               (= @x0 (BoxInt 0))
               ;; def=FStar.Math.Lemmas.fsti(140,80-140,85); use=FStar.Math.Lemmas.fst(160,41-160,43)
               (= @x1 (BoxInt 0))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(160,41-160,43)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(160,41-160,43)
              (ApplyTT @x2 @x3)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(160,41-160,43)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(160,41-160,43)
               (ApplyTT @x2 @x3)))
            :qid @query.2)))
         ;; def=Prims.fst(459,66-459,102); use=Prims.fst(462,31-462,44)
         (forall ((@x3 Term))
          (! (implies
            (HasType @x3 Prims.unit)
            ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
            (Valid
             ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
             (ApplyTT @x2 @x3)))
           :qid @query.3)))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.int_times_int_equal_zero_lemma, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let int_times_int_equal_zero_lemma
; <Start encoding let int_times_int_equal_zero_lemma>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.int_times_int_equal_zero_lemma (Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.int_times_int_equal_zero_lemma@tok () Term)
; </end encoding let int_times_int_equal_zero_lemma>

; encoding sigelt #push-options "--fuel 1"
; <Skipped #push-options "--fuel 1"/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fsti(142,0-142,68)
(declare-fun label_1 () Bool)
(declare-fun Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9 () Term)
; refinement kinding
;;; Fact-ids: 
(assert
 (! (HasType Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9 Tm_type)
  :named refinement_kinding_Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
; refinement_interpretation
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fsti(142,30-142,68); use=FStar.Math.Lemmas.fsti(142,30-142,35)
  (forall ((@u0 Fuel) (@x1 Term))
   (! (iff
     (HasTypeFuel @u0 @x1 Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9)
     (HasTypeFuel @u0 @x1 Prims.unit))
    :pattern ((HasTypeFuel @u0 @x1 Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
    :qid refinement_interpretation_Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
  :named refinement_interpretation_Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
; haseq for Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9
;;; Fact-ids: 
(assert
 (! (iff
   (Valid (Prims.hasEq Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
   (Valid (Prims.hasEq Prims.unit)))
  :named haseqTm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
; Encoding query formula : forall (n: Prims.nat) (_: Prims.squash Prims.l_True).
;   (*  - Could not prove post-condition
; *) n + 1 >= 0
; Context: While encoding a query
; While typechecking the top-level declaration `val FStar.Math.Lemmas.pow2_double_sum`
(push) ;; push{0
; <fuel='1' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel (SFuel ZFuel)) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fsti(142,0-142,68)
   (forall ((@x0 Term) (@x1 Term))
    (! (implies
      (and (HasType @x0 Prims.nat) (HasType @x1 Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
      ;; def=Prims.fst(682,18-682,24); use=FStar.Math.Lemmas.fsti(142,60-142,67)
      (or
       label_1
       ;; def=Prims.fst(682,18-682,24); use=FStar.Math.Lemmas.fsti(142,60-142,67)
       (>= (BoxInt_proj_0 (Prims.op_Addition @x0 (BoxInt 1))) (BoxInt_proj_0 (BoxInt 0)))))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.pow2_double_sum, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt val FStar.Math.Lemmas.pow2_double_sum
; <Skipped val FStar.Math.Lemmas.pow2_double_sum/>

; free var typing
;;; Fact-ids: Name Prims.pow2; Namespace Prims
(assert
 (! ;; def=Prims.fst(710,8-710,12); use=Prims.fst(710,8-710,12)
  (forall ((@x0 Term))
   (! (implies (HasType @x0 Prims.nat) (HasType (Prims.pow2 @x0) Prims.pos))
    :pattern ((Prims.pow2 @x0))
    :qid typing_Prims.pow2))
  :named typing_Prims.pow2))
; Typing correspondence of token to term
;;; Fact-ids: Name Prims.pow2; Namespace Prims
(assert
 (! ;; def=Prims.fst(710,8-710,12); use=Prims.fst(710,8-710,12)
  (forall ((@u0 Fuel) (@x1 Term))
   (! (implies (HasType @x1 Prims.nat) (HasType (Prims.pow2.fuel_instrumented @u0 @x1) Prims.pos))
    :pattern ((Prims.pow2.fuel_instrumented @u0 @x1))
    :qid token_correspondence_Prims.pow2.fuel_instrumented))
  :named token_correspondence_Prims.pow2.fuel_instrumented))
; Equation for fuel-instrumented recursive function: Prims.pow2
;;; Fact-ids: Name Prims.pow2; Namespace Prims
(assert
 (! ;; def=Prims.fst(710,8-710,12); use=Prims.fst(710,8-710,12)
  (forall ((@u0 Fuel) (@x1 Term))
   (! (implies
     (HasType @x1 Prims.nat)
     (=
      (Prims.pow2.fuel_instrumented (SFuel @u0) @x1)
      (let ((@lb2 @x1))
       (ite
        (= @lb2 (BoxInt 0))
        (BoxInt 1)
        (Prims.op_Multiply
         (BoxInt 2)
         (Prims.pow2.fuel_instrumented @u0 (Prims.op_Subtraction @x1 (BoxInt 1))))))))
    :weight 0
    :pattern ((Prims.pow2.fuel_instrumented (SFuel @u0) @x1))
    :qid equation_with_fuel_Prims.pow2.fuel_instrumented))
  :named equation_with_fuel_Prims.pow2.fuel_instrumented))
; Fuel irrelevance
;;; Fact-ids: Name Prims.pow2; Namespace Prims
(assert
 (! ;; def=Prims.fst(710,8-710,12); use=Prims.fst(710,8-710,12)
  (forall ((@u0 Fuel) (@x1 Term))
   (! (= (Prims.pow2.fuel_instrumented (SFuel @u0) @x1) (Prims.pow2.fuel_instrumented ZFuel @x1))
    :pattern ((Prims.pow2.fuel_instrumented (SFuel @u0) @x1))
    :qid @fuel_irrelevance_Prims.pow2.fuel_instrumented))
  :named @fuel_irrelevance_Prims.pow2.fuel_instrumented))
; Correspondence of recursive function to instrumented version
;;; Fact-ids: Name Prims.pow2; Namespace Prims
(assert
 (! ;; def=Prims.fst(710,8-710,12); use=Prims.fst(710,8-710,12)
  (forall ((@x0 Term))
   (! (= (Prims.pow2 @x0) (Prims.pow2.fuel_instrumented MaxFuel @x0))
    :pattern ((Prims.pow2 @x0))
    :qid @fuel_correspondence_Prims.pow2.fuel_instrumented))
  :named @fuel_correspondence_Prims.pow2.fuel_instrumented))
(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(163,24-163,26)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (n: Prims.nat).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     (forall (pure_result: Prims.unit).
;         Prims.pow2 n + Prims.pow2 n = Prims.pow2 (n + 1) ==> p pure_result) ==>
;     (forall (any_result: Prims.unit). p any_result)
; Context: While encoding a query
; While typechecking the top-level declaration `let pow2_double_sum`
(push) ;; push{0
; <fuel='1' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel (SFuel ZFuel)) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term))
    (! (implies
      (HasType @x0 Prims.nat)
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x1 Term))
       (! (implies
         (and
          (HasType @x1 (Prims.pure_post Prims.unit))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(163,24-163,26)
          (forall ((@x2 Term))
           (! (implies
             (and
              (or label_1 (HasType @x2 Prims.unit))
              ;; def=FStar.Math.Lemmas.fsti(142,36-142,68); use=FStar.Math.Lemmas.fst(163,24-163,26)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fsti(142,36-142,68); use=FStar.Math.Lemmas.fst(163,24-163,26)
               (=
                (Prims.op_Addition (Prims.pow2 @x0) (Prims.pow2 @x0))
                (Prims.pow2 (Prims.op_Addition @x0 (BoxInt 1))))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(163,24-163,26)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(163,24-163,26)
              (ApplyTT @x1 @x2)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(163,24-163,26)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(163,24-163,26)
               (ApplyTT @x1 @x2)))
            :qid @query.2)))
         ;; def=Prims.fst(459,66-459,102); use=Prims.fst(462,31-462,44)
         (forall ((@x2 Term))
          (! (implies
            (HasType @x2 Prims.unit)
            ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
            (Valid
             ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
             (ApplyTT @x1 @x2)))
           :qid @query.3)))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.pow2_double_sum, 2)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let pow2_double_sum
; <Start encoding let pow2_double_sum>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.pow2_double_sum (Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.pow2_double_sum@tok () Term)
; </end encoding let pow2_double_sum>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fsti(144,0-144,64)
(declare-fun label_1 () Bool)
(declare-fun Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9 () Term)
; refinement kinding
;;; Fact-ids: 
(assert
 (! (HasType Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9 Tm_type)
  :named refinement_kinding_Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
; refinement_interpretation
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fsti(144,31-144,64); use=FStar.Math.Lemmas.fsti(144,31-144,36)
  (forall ((@u0 Fuel) (@x1 Term))
   (! (iff
     (HasTypeFuel @u0 @x1 Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9)
     (HasTypeFuel @u0 @x1 Prims.unit))
    :pattern ((HasTypeFuel @u0 @x1 Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
    :qid refinement_interpretation_Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
  :named refinement_interpretation_Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
; haseq for Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9
;;; Fact-ids: 
(assert
 (! (iff
   (Valid (Prims.hasEq Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
   (Valid (Prims.hasEq Prims.unit)))
  :named haseqTm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
; Encoding query formula : forall (n: Prims.nat) (_: Prims.squash Prims.l_True).
;   (*  - Could not prove post-condition
; *) n + 1 >= 0
; Context: While encoding a query
; While typechecking the top-level declaration `val FStar.Math.Lemmas.pow2_double_mult`
(push) ;; push{0
; <fuel='1' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel (SFuel ZFuel)) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fsti(144,0-144,64)
   (forall ((@x0 Term) (@x1 Term))
    (! (implies
      (and (HasType @x0 Prims.nat) (HasType @x1 Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
      ;; def=Prims.fst(682,18-682,24); use=FStar.Math.Lemmas.fsti(144,56-144,63)
      (or
       label_1
       ;; def=Prims.fst(682,18-682,24); use=FStar.Math.Lemmas.fsti(144,56-144,63)
       (>= (BoxInt_proj_0 (Prims.op_Addition @x0 (BoxInt 1))) (BoxInt_proj_0 (BoxInt 0)))))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.pow2_double_mult, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt val FStar.Math.Lemmas.pow2_double_mult
; <Skipped val FStar.Math.Lemmas.pow2_double_mult/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(165,25-165,42)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (n: Prims.nat).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     (forall (pure_result: Prims.unit). 2 * Prims.pow2 n = Prims.pow2 (n + 1) ==> p pure_result) ==>
;     (forall (pure_result: Prims.unit).
;         Prims.pow2 n + Prims.pow2 n = Prims.pow2 (n + 1) ==> p pure_result)
; Context: While encoding a query
; While typechecking the top-level declaration `let pow2_double_mult`
(push) ;; push{0
; <fuel='1' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel (SFuel ZFuel)) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term))
    (! (implies
      (HasType @x0 Prims.nat)
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x1 Term))
       (! (implies
         (and
          (HasType @x1 (Prims.pure_post Prims.unit))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(165,25-165,42)
          (forall ((@x2 Term))
           (! (implies
             (and
              (or label_1 (HasType @x2 Prims.unit))
              ;; def=FStar.Math.Lemmas.fsti(144,37-144,64); use=FStar.Math.Lemmas.fst(165,25-165,42)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fsti(144,37-144,64); use=FStar.Math.Lemmas.fst(165,25-165,42)
               (=
                (Prims.op_Multiply (BoxInt 2) (Prims.pow2 @x0))
                (Prims.pow2 (Prims.op_Addition @x0 (BoxInt 1))))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(165,25-165,42)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(165,25-165,42)
              (ApplyTT @x1 @x2)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(165,25-165,42)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(165,25-165,42)
               (ApplyTT @x1 @x2)))
            :qid @query.2)))
         ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(165,25-165,42)
         (forall ((@x2 Term))
          (! (implies
            (and
             (HasType @x2 Prims.unit)
             ;; def=FStar.Math.Lemmas.fsti(142,36-142,68); use=FStar.Math.Lemmas.fst(165,25-165,40)
             (=
              (Prims.op_Addition (Prims.pow2 @x0) (Prims.pow2 @x0))
              (Prims.pow2 (Prims.op_Addition @x0 (BoxInt 1)))))
            ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(165,25-165,42)
            (Valid
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(165,25-165,42)
             (ApplyTT @x1 @x2)))
           :qid @query.3)))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.pow2_double_mult, 2)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let pow2_double_mult
; <Start encoding let pow2_double_mult>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.pow2_double_mult (Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.pow2_double_mult@tok () Term)
; </end encoding let pow2_double_mult>

; encoding sigelt val FStar.Math.Lemmas.pow2_lt_compat
; <Skipped val FStar.Math.Lemmas.pow2_lt_compat/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(168,2-170,35)
; n : Prims.nat (Prims.nat)
(declare-fun x_bb4e1c9af0265270f8e7a5f250f730e2_0 () Term)
; binder_x_bb4e1c9af0265270f8e7a5f250f730e2_0
;;; Fact-ids: 
(assert
 (! (HasType x_bb4e1c9af0265270f8e7a5f250f730e2_0 Prims.nat)
  :named binder_x_bb4e1c9af0265270f8e7a5f250f730e2_0))
; m : Prims.nat (Prims.nat)
(declare-fun x_bb4e1c9af0265270f8e7a5f250f730e2_1 () Term)
; binder_x_bb4e1c9af0265270f8e7a5f250f730e2_1
;;; Fact-ids: 
(assert
 (! (HasType x_bb4e1c9af0265270f8e7a5f250f730e2_1 Prims.nat)
  :named binder_x_bb4e1c9af0265270f8e7a5f250f730e2_1))
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.pow2_lt_compat (Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.pow2_lt_compat@tok () Term)
(declare-fun label_6 () Bool)
(declare-fun label_5 () Bool)
(declare-fun label_4 () Bool)
(declare-fun label_3 () Bool)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
(declare-fun Tm_refine_cf3de402d0721f07edf81164c265e2b6 () Term)
; refinement kinding
;;; Fact-ids: 
(assert
 (! (HasType Tm_refine_cf3de402d0721f07edf81164c265e2b6 Tm_type)
  :named refinement_kinding_Tm_refine_cf3de402d0721f07edf81164c265e2b6))
; refinement_interpretation
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fst(168,2-170,35); use=FStar.Math.Lemmas.fst(170,9-170,23)
  (forall ((@u0 Fuel) (@x1 Term))
   (! (iff
     (HasTypeFuel @u0 @x1 Tm_refine_cf3de402d0721f07edf81164c265e2b6)
     (and
      (HasTypeFuel @u0 @x1 Prims.nat)
      ;; def=FStar.Math.Lemmas.fst(168,2-170,35); use=FStar.Math.Lemmas.fst(170,9-170,23)
      ;; def=FStar.Math.Lemmas.fst(168,2-170,35); use=FStar.Math.Lemmas.fst(170,9-170,23)
      (Valid
       ;; def=FStar.Math.Lemmas.fst(168,2-170,35); use=FStar.Math.Lemmas.fst(170,9-170,23)
       (Prims.precedes Prims.nat Prims.nat @x1 x_bb4e1c9af0265270f8e7a5f250f730e2_1))))
    :pattern ((HasTypeFuel @u0 @x1 Tm_refine_cf3de402d0721f07edf81164c265e2b6))
    :qid refinement_interpretation_Tm_refine_cf3de402d0721f07edf81164c265e2b6))
  :named refinement_interpretation_Tm_refine_cf3de402d0721f07edf81164c265e2b6))
; haseq for Tm_refine_cf3de402d0721f07edf81164c265e2b6
;;; Fact-ids: 
(assert
 (! (iff
   (Valid (Prims.hasEq Tm_refine_cf3de402d0721f07edf81164c265e2b6))
   (Valid (Prims.hasEq Prims.nat)))
  :named haseqTm_refine_cf3de402d0721f07edf81164c265e2b6))
; Encoding query formula : forall (p: Prims.pure_post Prims.unit).
;   m < n /\ (forall (pure_result: Prims.unit). Prims.pow2 m < Prims.pow2 n ==> p pure_result) ==>
;   (forall (k: Prims.pure_post Prims.unit).
;       (forall (x: Prims.unit). {:pattern Prims.guard_free (k x)} p x ==> k x) ==>
;       (m == 0 ==> (forall (any_result: Prims.unit). k any_result)) /\
;       (~(m = 0) ==>
;         (forall (b: Prims.int).
;             m == b ==>
;             n - 1 >= 0 /\
;             (forall (return_val: Prims.nat).
;                 return_val == n - 1 ==>
;                 m - 1 >= 0 /\ m - 1 << m /\
;                 (forall (return_val: m: Prims.nat{m << m}).
;                     return_val == m - 1 ==>
;                     m - 1 < n - 1 /\
;                     (forall (pure_result: Prims.unit).
;                         Prims.pow2 (m - 1) < Prims.pow2 (n - 1) ==> k pure_result))))))
; Context: While encoding a query
; While typechecking the top-level declaration `let rec pow2_lt_compat`
(push) ;; push{0
; <fuel='1' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel (SFuel ZFuel)) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   ;; def=FStar.Math.Lemmas.fst(168,2-170,35); use=FStar.Math.Lemmas.fst(168,2-170,35)
   (forall ((@x0 Term))
    (! (implies
      (and
       (HasType @x0 (Prims.pure_post Prims.unit))
       ;; def=FStar.Math.Lemmas.fsti(147,12-147,19); use=FStar.Math.Lemmas.fst(168,2-170,35)
       (<
        (BoxInt_proj_0 x_bb4e1c9af0265270f8e7a5f250f730e2_1)
        (BoxInt_proj_0 x_bb4e1c9af0265270f8e7a5f250f730e2_0))
       ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(168,2-170,35)
       (forall ((@x1 Term))
        (! (implies
          (and
           (or label_1 (HasType @x1 Prims.unit))
           ;; def=FStar.Math.Lemmas.fsti(148,12-148,29); use=FStar.Math.Lemmas.fst(168,2-170,35)
           (or
            label_2
            ;; def=FStar.Math.Lemmas.fsti(148,12-148,29); use=FStar.Math.Lemmas.fst(168,2-170,35)
            (<
             (BoxInt_proj_0 (Prims.pow2 x_bb4e1c9af0265270f8e7a5f250f730e2_1))
             (BoxInt_proj_0 (Prims.pow2 x_bb4e1c9af0265270f8e7a5f250f730e2_0)))))
          ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(168,2-170,35)
          (Valid
           ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(168,2-170,35)
           (ApplyTT @x0 @x1)))
         :pattern
          (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(168,2-170,35)
           (Valid
            ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(168,2-170,35)
            (ApplyTT @x0 @x1)))
         :qid @query.1)))
      ;; def=Prims.fst(410,2-410,97); use=FStar.Math.Lemmas.fst(168,2-170,35)
      (forall ((@x1 Term))
       (! (implies
         (and
          (HasType @x1 (Prims.pure_post Prims.unit))
          ;; def=Prims.fst(410,2-410,97); use=FStar.Math.Lemmas.fst(168,2-170,35)
          (forall ((@x2 Term))
           (! (implies
             ;; def=Prims.fst(410,73-410,79); use=FStar.Math.Lemmas.fst(168,2-170,35)
             (Valid
              ;; def=Prims.fst(410,73-410,79); use=FStar.Math.Lemmas.fst(168,2-170,35)
              (ApplyTT @x0 @x2))
             ;; def=Prims.fst(410,84-410,87); use=FStar.Math.Lemmas.fst(168,2-170,35)
             (Valid
              ;; def=Prims.fst(410,84-410,87); use=FStar.Math.Lemmas.fst(168,2-170,35)
              (ApplyTT @x1 @x2)))
            :weight 0
            :pattern ((ApplyTT @x1 @x2))
            :qid @query.3)))
         ;; def=Prims.fst(397,2-397,39); use=FStar.Math.Lemmas.fst(168,2-170,35)
         (and
          (implies
           ;; def=FStar.Math.Lemmas.fst(167,25-169,5); use=FStar.Math.Lemmas.fst(168,8-169,5)
           (= x_bb4e1c9af0265270f8e7a5f250f730e2_1 (BoxInt 0))
           ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(168,2-170,35)
           (forall ((@x2 Term))
            (! (implies
              (HasType @x2 Prims.unit)
              ;; def=Prims.fst(459,90-459,102); use=FStar.Math.Lemmas.fst(168,2-170,35)
              (Valid
               ;; def=Prims.fst(459,90-459,102); use=FStar.Math.Lemmas.fst(168,2-170,35)
               (ApplyTT @x1 @x2)))
             :qid @query.4)))
          (implies
           ;; def=Prims.fst(397,19-397,21); use=FStar.Math.Lemmas.fst(168,2-170,35)
           (not
            ;; def=FStar.Math.Lemmas.fst(167,25-169,5); use=FStar.Math.Lemmas.fst(168,8-169,5)
            (= x_bb4e1c9af0265270f8e7a5f250f730e2_1 (BoxInt 0)))
           ;; def=Prims.fst(421,99-421,120); use=FStar.Math.Lemmas.fst(168,2-170,35)
           (forall ((@x2 Term))
            (! (implies
              (and
               (HasType @x2 Prims.int)
               ;; def=FStar.Math.Lemmas.fst(167,25-170,5); use=FStar.Math.Lemmas.fst(168,8-170,5)
               (= x_bb4e1c9af0265270f8e7a5f250f730e2_1 @x2))
              ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(168,2-170,35)
              (and
               ;; def=Prims.fst(682,18-682,24); use=FStar.Math.Lemmas.fst(170,24-170,29)
               (or
                label_3
                ;; def=Prims.fst(682,18-682,24); use=FStar.Math.Lemmas.fst(170,24-170,29)
                (>=
                 (BoxInt_proj_0
                  (Prims.op_Subtraction x_bb4e1c9af0265270f8e7a5f250f730e2_0 (BoxInt 1)))
                 (BoxInt_proj_0 (BoxInt 0))))
               ;; def=Prims.fst(364,2-364,58); use=FStar.Math.Lemmas.fst(168,2-170,35)
               (forall ((@x3 Term))
                (! (implies
                  (and
                   (HasType @x3 Prims.nat)
                   ;; def=Prims.fst(364,26-364,41); use=FStar.Math.Lemmas.fst(168,2-170,35)
                   (= @x3 (Prims.op_Subtraction x_bb4e1c9af0265270f8e7a5f250f730e2_0 (BoxInt 1))))
                  ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(168,2-170,35)
                  (and
                   ;; def=Prims.fst(682,18-682,24); use=FStar.Math.Lemmas.fst(170,30-170,35)
                   (or
                    label_4
                    ;; def=Prims.fst(682,18-682,24); use=FStar.Math.Lemmas.fst(170,30-170,35)
                    (>=
                     (BoxInt_proj_0
                      (Prims.op_Subtraction x_bb4e1c9af0265270f8e7a5f250f730e2_1 (BoxInt 1)))
                     (BoxInt_proj_0 (BoxInt 0))))
                   ;; def=FStar.Math.Lemmas.fst(168,2-170,35); use=FStar.Math.Lemmas.fst(170,30-170,35)
                   (or
                    label_5
                    ;; def=FStar.Math.Lemmas.fst(168,2-170,35); use=FStar.Math.Lemmas.fst(170,30-170,35)
                    (Valid
                     ;; def=FStar.Math.Lemmas.fst(168,2-170,35); use=FStar.Math.Lemmas.fst(170,30-170,35)
                     (Prims.precedes
                      Prims.nat
                      Prims.nat
                      (Prims.op_Subtraction x_bb4e1c9af0265270f8e7a5f250f730e2_1 (BoxInt 1))
                      x_bb4e1c9af0265270f8e7a5f250f730e2_1)))
                   ;; def=Prims.fst(364,2-364,58); use=FStar.Math.Lemmas.fst(168,2-170,35)
                   (forall ((@x4 Term))
                    (! (implies
                      (and
                       (HasType @x4 Tm_refine_cf3de402d0721f07edf81164c265e2b6)
                       ;; def=Prims.fst(364,26-364,41); use=FStar.Math.Lemmas.fst(168,2-170,35)
                       (= @x4 (Prims.op_Subtraction x_bb4e1c9af0265270f8e7a5f250f730e2_1 (BoxInt 1))))
                      ;; def=Prims.fst(449,29-449,97); use=FStar.Math.Lemmas.fst(170,9-170,23)
                      (and
                       ;; def=FStar.Math.Lemmas.fsti(147,12-147,19); use=FStar.Math.Lemmas.fst(170,9-170,23)
                       (or
                        label_6
                        ;; def=FStar.Math.Lemmas.fsti(147,12-147,19); use=FStar.Math.Lemmas.fst(170,9-170,23)
                        (<
                         (BoxInt_proj_0
                          (Prims.op_Subtraction x_bb4e1c9af0265270f8e7a5f250f730e2_1 (BoxInt 1)))
                         (BoxInt_proj_0
                          (Prims.op_Subtraction x_bb4e1c9af0265270f8e7a5f250f730e2_0 (BoxInt 1)))))
                       ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(170,9-170,23)
                       (forall ((@x5 Term))
                        (! (implies
                          (and
                           (HasType @x5 Prims.unit)
                           ;; def=FStar.Math.Lemmas.fsti(148,12-148,29); use=FStar.Math.Lemmas.fst(170,9-170,23)
                           (<
                            (BoxInt_proj_0
                             (Prims.pow2
                              (Prims.op_Subtraction x_bb4e1c9af0265270f8e7a5f250f730e2_1 (BoxInt 1))))
                            (BoxInt_proj_0
                             (Prims.pow2
                              (Prims.op_Subtraction x_bb4e1c9af0265270f8e7a5f250f730e2_0 (BoxInt 1))))))
                          ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(170,9-170,23)
                          (Valid
                           ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(170,9-170,23)
                           (ApplyTT @x1 @x5)))
                         :qid @query.8))))
                     :qid @query.7))))
                 :qid @query.6))))
             :qid @query.5)))))
        :qid @query.2)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_6")
(eval label_6)
(echo "label_5")
(eval label_5)
(echo "label_4")
(eval label_4)
(echo "label_3")
(eval label_3)
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.pow2_lt_compat, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let rec pow2_lt_compat
; <Start encoding let rec pow2_lt_compat>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.pow2_lt_compat (Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.pow2_lt_compat@tok () Term)
; </end encoding let rec pow2_lt_compat>

; encoding sigelt #pop-options
; <Skipped #pop-options/>

; encoding sigelt val FStar.Math.Lemmas.pow2_le_compat
; <Skipped val FStar.Math.Lemmas.pow2_le_compat/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(174,2-174,34)
(declare-fun label_3 () Bool)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (n: Prims.nat) (m: Prims.nat).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     m <= n /\ (forall (pure_result: Prims.unit). Prims.pow2 m <= Prims.pow2 n ==> p pure_result) ==>
;     (forall (k: Prims.pure_post Prims.unit).
;         (forall (x: Prims.unit). {:pattern Prims.guard_free (k x)} p x ==> k x) ==>
;         (m < n == true ==>
;           m < n /\ (forall (pure_result: Prims.unit). Prims.pow2 m < Prims.pow2 n ==> k pure_result)
;         ) /\
;         (~(m < n = true) ==>
;           (forall (b: Prims.bool). m < n == b ==> (forall (any_result: Prims.unit). k any_result))))
; Context: While encoding a query
; While typechecking the top-level declaration `let pow2_le_compat`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term))
    (! (implies
      (and (HasType @x0 Prims.nat) (HasType @x1 Prims.nat))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x2 Term))
       (! (implies
         (and
          (HasType @x2 (Prims.pure_post Prims.unit))
          ;; def=FStar.Math.Lemmas.fsti(152,12-152,20); use=FStar.Math.Lemmas.fst(174,2-174,34)
          (<= (BoxInt_proj_0 @x1) (BoxInt_proj_0 @x0))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(174,2-174,34)
          (forall ((@x3 Term))
           (! (implies
             (and
              (or label_1 (HasType @x3 Prims.unit))
              ;; def=FStar.Math.Lemmas.fsti(153,12-153,30); use=FStar.Math.Lemmas.fst(174,2-174,34)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fsti(153,12-153,30); use=FStar.Math.Lemmas.fst(174,2-174,34)
               (<= (BoxInt_proj_0 (Prims.pow2 @x1)) (BoxInt_proj_0 (Prims.pow2 @x0)))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(174,2-174,34)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(174,2-174,34)
              (ApplyTT @x2 @x3)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(174,2-174,34)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(174,2-174,34)
               (ApplyTT @x2 @x3)))
            :qid @query.2)))
         ;; def=Prims.fst(410,2-410,97); use=FStar.Math.Lemmas.fst(174,2-174,34)
         (forall ((@x3 Term))
          (! (implies
            (and
             (HasType @x3 (Prims.pure_post Prims.unit))
             ;; def=Prims.fst(410,2-410,97); use=FStar.Math.Lemmas.fst(174,2-174,34)
             (forall ((@x4 Term))
              (! (implies
                ;; def=Prims.fst(410,73-410,79); use=FStar.Math.Lemmas.fst(174,2-174,34)
                (Valid
                 ;; def=Prims.fst(410,73-410,79); use=FStar.Math.Lemmas.fst(174,2-174,34)
                 (ApplyTT @x2 @x4))
                ;; def=Prims.fst(410,84-410,87); use=FStar.Math.Lemmas.fst(174,2-174,34)
                (Valid
                 ;; def=Prims.fst(410,84-410,87); use=FStar.Math.Lemmas.fst(174,2-174,34)
                 (ApplyTT @x3 @x4)))
               :weight 0
               :pattern ((ApplyTT @x3 @x4))
               :qid @query.4)))
            ;; def=Prims.fst(397,2-397,39); use=FStar.Math.Lemmas.fst(174,2-174,34)
            (and
             (implies
              ;; def=FStar.Math.Lemmas.fst(174,5-174,10); use=FStar.Math.Lemmas.fst(174,5-174,10)
              (= (Prims.op_LessThan @x1 @x0) (BoxBool true))
              ;; def=Prims.fst(449,29-449,97); use=FStar.Math.Lemmas.fst(174,16-174,30)
              (and
               ;; def=FStar.Math.Lemmas.fsti(147,12-147,19); use=FStar.Math.Lemmas.fst(174,16-174,30)
               (or
                label_3
                ;; def=FStar.Math.Lemmas.fsti(147,12-147,19); use=FStar.Math.Lemmas.fst(174,16-174,30)
                (< (BoxInt_proj_0 @x1) (BoxInt_proj_0 @x0)))
               ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(174,16-174,30)
               (forall ((@x4 Term))
                (! (implies
                  (and
                   (HasType @x4 Prims.unit)
                   ;; def=FStar.Math.Lemmas.fsti(148,12-148,29); use=FStar.Math.Lemmas.fst(174,16-174,30)
                   (< (BoxInt_proj_0 (Prims.pow2 @x1)) (BoxInt_proj_0 (Prims.pow2 @x0))))
                  ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(174,16-174,30)
                  (Valid
                   ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(174,16-174,30)
                   (ApplyTT @x3 @x4)))
                 :qid @query.5))))
             (implies
              ;; def=Prims.fst(397,19-397,21); use=FStar.Math.Lemmas.fst(174,2-174,34)
              (not
               ;; def=FStar.Math.Lemmas.fst(174,5-174,10); use=FStar.Math.Lemmas.fst(174,5-174,10)
               (= (Prims.op_LessThan @x1 @x0) (BoxBool true)))
              ;; def=Prims.fst(421,99-421,120); use=FStar.Math.Lemmas.fst(174,2-174,34)
              (forall ((@x4 Term))
               (! (implies
                 (and
                  (HasType @x4 Prims.bool)
                  ;; def=FStar.Math.Lemmas.fst(174,2-174,34); use=FStar.Math.Lemmas.fst(174,2-174,34)
                  (= (Prims.op_LessThan @x1 @x0) @x4))
                 ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(174,2-174,34)
                 (forall ((@x5 Term))
                  (! (implies
                    (HasType @x5 Prims.unit)
                    ;; def=Prims.fst(459,90-459,102); use=FStar.Math.Lemmas.fst(174,2-174,34)
                    (Valid
                     ;; def=Prims.fst(459,90-459,102); use=FStar.Math.Lemmas.fst(174,2-174,34)
                     (ApplyTT @x3 @x5)))
                   :qid @query.7)))
                :qid @query.6)))))
           :qid @query.3)))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_3")
(eval label_3)
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.pow2_le_compat, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let pow2_le_compat
; <Start encoding let pow2_le_compat>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.pow2_le_compat (Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.pow2_le_compat@tok () Term)
; </end encoding let pow2_le_compat>

; encoding sigelt #push-options "--fuel 1"
; <Skipped #push-options "--fuel 1"/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fsti(155,0-157,15)
(declare-fun label_1 () Bool)
(declare-fun Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9 () Term)
; refinement kinding
;;; Fact-ids: 
(assert
 (! (HasType Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9 Tm_type)
  :named refinement_kinding_Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
; refinement_interpretation
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fsti(155,33-157,15); use=FStar.Math.Lemmas.fsti(155,33-155,38)
  (forall ((@u0 Fuel) (@x1 Term))
   (! (iff
     (HasTypeFuel @u0 @x1 Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9)
     (HasTypeFuel @u0 @x1 Prims.unit))
    :pattern ((HasTypeFuel @u0 @x1 Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
    :qid refinement_interpretation_Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
  :named refinement_interpretation_Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
; haseq for Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9
;;; Fact-ids: 
(assert
 (! (iff
   (Valid (Prims.hasEq Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
   (Valid (Prims.hasEq Prims.unit)))
  :named haseqTm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
; Encoding query formula : forall (n: Prims.nat) (m: Prims.nat) (_: Prims.squash Prims.l_True).
;   (*  - Could not prove post-condition
; *) n + m >= 0
; Context: While encoding a query
; While typechecking the top-level declaration `val FStar.Math.Lemmas.pow2_plus`
(push) ;; push{0
; <fuel='1' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel (SFuel ZFuel)) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fsti(155,0-157,15)
   (forall ((@x0 Term) (@x1 Term) (@x2 Term))
    (! (implies
      (and
       (HasType @x0 Prims.nat)
       (HasType @x1 Prims.nat)
       (HasType @x2 Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
      ;; def=Prims.fst(682,18-682,24); use=FStar.Math.Lemmas.fsti(156,35-156,42)
      (or
       label_1
       ;; def=Prims.fst(682,18-682,24); use=FStar.Math.Lemmas.fsti(156,35-156,42)
       (>= (BoxInt_proj_0 (Prims.op_Addition @x0 @x1)) (BoxInt_proj_0 (BoxInt 0)))))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.pow2_plus, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt val FStar.Math.Lemmas.pow2_plus
; <Skipped val FStar.Math.Lemmas.pow2_plus/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(178,2-180,28)
; n : Prims.nat (Prims.nat)
(declare-fun x_bb4e1c9af0265270f8e7a5f250f730e2_0 () Term)
; binder_x_bb4e1c9af0265270f8e7a5f250f730e2_0
;;; Fact-ids: 
(assert
 (! (HasType x_bb4e1c9af0265270f8e7a5f250f730e2_0 Prims.nat)
  :named binder_x_bb4e1c9af0265270f8e7a5f250f730e2_0))
; m : Prims.nat (Prims.nat)
(declare-fun x_bb4e1c9af0265270f8e7a5f250f730e2_1 () Term)
; binder_x_bb4e1c9af0265270f8e7a5f250f730e2_1
;;; Fact-ids: 
(assert
 (! (HasType x_bb4e1c9af0265270f8e7a5f250f730e2_1 Prims.nat)
  :named binder_x_bb4e1c9af0265270f8e7a5f250f730e2_1))
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.pow2_plus (Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.pow2_plus@tok () Term)
(declare-fun label_4 () Bool)
(declare-fun label_3 () Bool)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (p: Prims.pure_post Prims.unit).
;   (forall (pure_result: Prims.unit).
;       Prims.pow2 n * Prims.pow2 m = Prims.pow2 (n + m) ==> p pure_result) ==>
;   (forall (k: Prims.pure_post Prims.unit).
;       (forall (x: Prims.unit). {:pattern Prims.guard_free (k x)} p x ==> k x) ==>
;       (n == 0 ==> (forall (any_result: Prims.unit). k any_result)) /\
;       (~(n = 0) ==>
;         (forall (b: Prims.int).
;             n == b ==>
;             n - 1 >= 0 /\
;             (forall (return_val: Prims.nat).
;                 return_val == n - 1 ==>
;                 n - 1 << n /\
;                 (forall (any_result: Prims.nat).
;                     m == any_result ==>
;                     (forall (pure_result: Prims.unit).
;                         Prims.pow2 (n - 1) * Prims.pow2 m = Prims.pow2 (n - 1 + m) ==> k pure_result
;                     ))))))
; Context: While encoding a query
; While typechecking the top-level declaration `let rec pow2_plus`
(push) ;; push{0
; <fuel='1' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel (SFuel ZFuel)) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   ;; def=FStar.Math.Lemmas.fst(178,2-180,28); use=FStar.Math.Lemmas.fst(178,2-180,28)
   (forall ((@x0 Term))
    (! (implies
      (and
       (HasType @x0 (Prims.pure_post Prims.unit))
       ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(178,2-180,28)
       (forall ((@x1 Term))
        (! (implies
          (and
           (or label_1 (HasType @x1 Prims.unit))
           ;; def=FStar.Math.Lemmas.fsti(156,11-156,43); use=FStar.Math.Lemmas.fst(178,2-180,28)
           (or
            label_2
            ;; def=FStar.Math.Lemmas.fsti(156,11-156,43); use=FStar.Math.Lemmas.fst(178,2-180,28)
            (=
             (Prims.op_Multiply
              (Prims.pow2 x_bb4e1c9af0265270f8e7a5f250f730e2_0)
              (Prims.pow2 x_bb4e1c9af0265270f8e7a5f250f730e2_1))
             (Prims.pow2
              (Prims.op_Addition
               x_bb4e1c9af0265270f8e7a5f250f730e2_0
               x_bb4e1c9af0265270f8e7a5f250f730e2_1)))))
          ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(178,2-180,28)
          (Valid
           ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(178,2-180,28)
           (ApplyTT @x0 @x1)))
         :pattern
          (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(178,2-180,28)
           (Valid
            ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(178,2-180,28)
            (ApplyTT @x0 @x1)))
         :qid @query.1)))
      ;; def=Prims.fst(410,2-410,97); use=FStar.Math.Lemmas.fst(178,2-180,28)
      (forall ((@x1 Term))
       (! (implies
         (and
          (HasType @x1 (Prims.pure_post Prims.unit))
          ;; def=Prims.fst(410,2-410,97); use=FStar.Math.Lemmas.fst(178,2-180,28)
          (forall ((@x2 Term))
           (! (implies
             ;; def=Prims.fst(410,73-410,79); use=FStar.Math.Lemmas.fst(178,2-180,28)
             (Valid
              ;; def=Prims.fst(410,73-410,79); use=FStar.Math.Lemmas.fst(178,2-180,28)
              (ApplyTT @x0 @x2))
             ;; def=Prims.fst(410,84-410,87); use=FStar.Math.Lemmas.fst(178,2-180,28)
             (Valid
              ;; def=Prims.fst(410,84-410,87); use=FStar.Math.Lemmas.fst(178,2-180,28)
              (ApplyTT @x1 @x2)))
            :weight 0
            :pattern ((ApplyTT @x1 @x2))
            :qid @query.3)))
         ;; def=Prims.fst(397,2-397,39); use=FStar.Math.Lemmas.fst(178,2-180,28)
         (and
          (implies
           ;; def=FStar.Math.Lemmas.fst(177,18-179,5); use=FStar.Math.Lemmas.fst(178,8-179,5)
           (= x_bb4e1c9af0265270f8e7a5f250f730e2_0 (BoxInt 0))
           ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(178,2-180,28)
           (forall ((@x2 Term))
            (! (implies
              (HasType @x2 Prims.unit)
              ;; def=Prims.fst(459,90-459,102); use=FStar.Math.Lemmas.fst(178,2-180,28)
              (Valid
               ;; def=Prims.fst(459,90-459,102); use=FStar.Math.Lemmas.fst(178,2-180,28)
               (ApplyTT @x1 @x2)))
             :qid @query.4)))
          (implies
           ;; def=Prims.fst(397,19-397,21); use=FStar.Math.Lemmas.fst(178,2-180,28)
           (not
            ;; def=FStar.Math.Lemmas.fst(177,18-179,5); use=FStar.Math.Lemmas.fst(178,8-179,5)
            (= x_bb4e1c9af0265270f8e7a5f250f730e2_0 (BoxInt 0)))
           ;; def=Prims.fst(421,99-421,120); use=FStar.Math.Lemmas.fst(178,2-180,28)
           (forall ((@x2 Term))
            (! (implies
              (and
               (HasType @x2 Prims.int)
               ;; def=FStar.Math.Lemmas.fst(177,18-180,5); use=FStar.Math.Lemmas.fst(178,8-180,5)
               (= x_bb4e1c9af0265270f8e7a5f250f730e2_0 @x2))
              ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(178,2-180,28)
              (and
               ;; def=Prims.fst(682,18-682,24); use=FStar.Math.Lemmas.fst(180,19-180,26)
               (or
                label_3
                ;; def=Prims.fst(682,18-682,24); use=FStar.Math.Lemmas.fst(180,19-180,26)
                (>=
                 (BoxInt_proj_0
                  (Prims.op_Subtraction x_bb4e1c9af0265270f8e7a5f250f730e2_0 (BoxInt 1)))
                 (BoxInt_proj_0 (BoxInt 0))))
               ;; def=Prims.fst(364,2-364,58); use=FStar.Math.Lemmas.fst(178,2-180,28)
               (forall ((@x3 Term))
                (! (implies
                  (and
                   (HasType @x3 Prims.nat)
                   ;; def=Prims.fst(364,26-364,41); use=FStar.Math.Lemmas.fst(178,2-180,28)
                   (= @x3 (Prims.op_Subtraction x_bb4e1c9af0265270f8e7a5f250f730e2_0 (BoxInt 1))))
                  ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(178,2-180,28)
                  (and
                   ;; def=FStar.Math.Lemmas.fst(178,2-180,28); use=FStar.Math.Lemmas.fst(180,27-180,28)
                   (or
                    label_4
                    ;; def=FStar.Math.Lemmas.fst(178,2-180,28); use=FStar.Math.Lemmas.fst(180,27-180,28)
                    (Valid
                     ;; def=FStar.Math.Lemmas.fst(178,2-180,28); use=FStar.Math.Lemmas.fst(180,27-180,28)
                     (Prims.precedes
                      Prims.nat
                      Prims.nat
                      (Prims.op_Subtraction x_bb4e1c9af0265270f8e7a5f250f730e2_0 (BoxInt 1))
                      x_bb4e1c9af0265270f8e7a5f250f730e2_0)))
                   ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(178,2-180,28)
                   (forall ((@x4 Term))
                    (! (implies
                      (and
                       (HasType @x4 Prims.nat)
                       ;; def=FStar.Math.Lemmas.fsti(155,24-155,25); use=FStar.Math.Lemmas.fst(178,2-180,28)
                       (= x_bb4e1c9af0265270f8e7a5f250f730e2_1 @x4))
                      ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(180,9-180,18)
                      (forall ((@x5 Term))
                       (! (implies
                         (and
                          (HasType @x5 Prims.unit)
                          ;; def=FStar.Math.Lemmas.fsti(156,11-156,43); use=FStar.Math.Lemmas.fst(180,9-180,18)
                          (=
                           (Prims.op_Multiply
                            (Prims.pow2
                             (Prims.op_Subtraction x_bb4e1c9af0265270f8e7a5f250f730e2_0 (BoxInt 1)))
                            (Prims.pow2 x_bb4e1c9af0265270f8e7a5f250f730e2_1))
                           (Prims.pow2
                            (Prims.op_Addition
                             (Prims.op_Subtraction x_bb4e1c9af0265270f8e7a5f250f730e2_0 (BoxInt 1))
                             x_bb4e1c9af0265270f8e7a5f250f730e2_1))))
                         ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(180,9-180,18)
                         (Valid
                          ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(180,9-180,18)
                          (ApplyTT @x1 @x5)))
                        :qid @query.8)))
                     :qid @query.7))))
                 :qid @query.6))))
             :qid @query.5)))))
        :qid @query.2)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_4")
(eval label_4)
(echo "label_3")
(eval label_3)
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.pow2_plus, 2)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(177,0-180,28)
(declare-fun label_1 () Bool)
(declare-fun Tm_refine_faf51d7ff4d7ad8e518a7e42edf223f1 (Term Term) Term)
; refinement kinding
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fst(178,2-180,28); use=FStar.Math.Lemmas.fst(178,2-180,28)
  (forall ((@x0 Term) (@x1 Term))
   (! (HasType (Tm_refine_faf51d7ff4d7ad8e518a7e42edf223f1 @x0 @x1) Tm_type)
    :pattern ((HasType (Tm_refine_faf51d7ff4d7ad8e518a7e42edf223f1 @x0 @x1) Tm_type))
    :qid refinement_kinding_Tm_refine_faf51d7ff4d7ad8e518a7e42edf223f1))
  :named refinement_kinding_Tm_refine_faf51d7ff4d7ad8e518a7e42edf223f1))
; refinement_interpretation
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fst(178,2-180,28); use=FStar.Math.Lemmas.fst(178,2-180,28)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
   (! (iff
     (HasTypeFuel @u0 @x1 (Tm_refine_faf51d7ff4d7ad8e518a7e42edf223f1 @x2 @x3))
     (and
      (HasTypeFuel @u0 @x1 Prims.nat)
      ;; def=FStar.Math.Lemmas.fst(178,2-180,28); use=FStar.Math.Lemmas.fst(178,2-180,28)
      ;; def=FStar.Math.Lemmas.fst(178,2-180,28); use=FStar.Math.Lemmas.fst(178,2-180,28)
      (Valid
       ;; def=FStar.Math.Lemmas.fst(178,2-180,28); use=FStar.Math.Lemmas.fst(178,2-180,28)
       (Prims.precedes Prims.nat Prims.nat @x2 @x3))))
    :pattern ((HasTypeFuel @u0 @x1 (Tm_refine_faf51d7ff4d7ad8e518a7e42edf223f1 @x2 @x3)))
    :qid refinement_interpretation_Tm_refine_faf51d7ff4d7ad8e518a7e42edf223f1))
  :named refinement_interpretation_Tm_refine_faf51d7ff4d7ad8e518a7e42edf223f1))
; haseq for Tm_refine_faf51d7ff4d7ad8e518a7e42edf223f1
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fst(178,2-180,28); use=FStar.Math.Lemmas.fst(178,2-180,28)
  (forall ((@x0 Term) (@x1 Term))
   (! (iff
     (Valid (Prims.hasEq (Tm_refine_faf51d7ff4d7ad8e518a7e42edf223f1 @x0 @x1)))
     (Valid (Prims.hasEq Prims.nat)))
    :pattern ((Valid (Prims.hasEq (Tm_refine_faf51d7ff4d7ad8e518a7e42edf223f1 @x0 @x1))))
    :qid haseqTm_refine_faf51d7ff4d7ad8e518a7e42edf223f1))
  :named haseqTm_refine_faf51d7ff4d7ad8e518a7e42edf223f1))
(declare-fun Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9 () Term)
; refinement kinding
;;; Fact-ids: 
(assert
 (! (HasType Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9 Tm_type)
  :named refinement_kinding_Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
; refinement_interpretation
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fsti(155,33-157,15); use=FStar.Math.Lemmas.fst(177,8-177,17)
  (forall ((@u0 Fuel) (@x1 Term))
   (! (iff
     (HasTypeFuel @u0 @x1 Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9)
     (HasTypeFuel @u0 @x1 Prims.unit))
    :pattern ((HasTypeFuel @u0 @x1 Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
    :qid refinement_interpretation_Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
  :named refinement_interpretation_Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
; haseq for Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9
;;; Fact-ids: 
(assert
 (! (iff
   (Valid (Prims.hasEq Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
   (Valid (Prims.hasEq Prims.unit)))
  :named haseqTm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
; Encoding query formula : forall (n: Prims.nat)
;   (m: Prims.nat)
;   (n: Prims.nat)
;   (m: Prims.nat{n << n})
;   (_: Prims.squash Prims.l_True).
;   (*  - Could not prove post-condition
; *) n + m >= 0
; Context: While encoding a query
; While typechecking the top-level declaration `let rec pow2_plus`
(push) ;; push{0
; <fuel='1' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel (SFuel ZFuel)) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(177,0-180,28)
   (forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
    (! (implies
      (and
       (HasType @x0 Prims.nat)
       (HasType @x1 Prims.nat)
       (HasType @x2 Prims.nat)
       (HasType @x3 (Tm_refine_faf51d7ff4d7ad8e518a7e42edf223f1 @x2 @x0))
       (HasType @x4 Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
      ;; def=Prims.fst(682,18-682,24); use=FStar.Math.Lemmas.fst(177,8-177,17)
      (or
       label_1
       ;; def=Prims.fst(682,18-682,24); use=FStar.Math.Lemmas.fst(177,8-177,17)
       (>= (BoxInt_proj_0 (Prims.op_Addition @x2 @x3)) (BoxInt_proj_0 (BoxInt 0)))))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.pow2_plus, 3)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let rec pow2_plus
; <Start encoding let rec pow2_plus>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.pow2_plus (Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.pow2_plus@tok () Term)
; </end encoding let rec pow2_plus>

; encoding sigelt #pop-options
; <Skipped #pop-options/>

; free var typing
;;; Fact-ids: Name Prims.nonzero; Namespace Prims
(assert
 (! (HasType Prims.nonzero Tm_type) :named typing_Prims.nonzero))
; function token typing
;;; Fact-ids: Name Prims.nonzero; Namespace Prims
(assert
 (! (HasType Prims.nonzero Tm_type) :named function_token_typing_Prims.nonzero))
; Equation for Prims.nonzero
;;; Fact-ids: Name Prims.nonzero; Namespace Prims
(assert
 (! (= Prims.nonzero Tm_refine_0766302b68bb44ab7aff8c4d8be0b46f) :named equation_Prims.nonzero))
(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fsti(160,0-161,38)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
(declare-fun Tm_refine_48ee302bf1eb4121a480c48fccc99a62 (Term) Term)
; refinement kinding
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fsti(160,25-160,40); use=FStar.Math.Lemmas.fsti(160,25-160,40)
  (forall ((@x0 Term))
   (! (HasType (Tm_refine_48ee302bf1eb4121a480c48fccc99a62 @x0) Tm_type)
    :pattern ((HasType (Tm_refine_48ee302bf1eb4121a480c48fccc99a62 @x0) Tm_type))
    :qid refinement_kinding_Tm_refine_48ee302bf1eb4121a480c48fccc99a62))
  :named refinement_kinding_Tm_refine_48ee302bf1eb4121a480c48fccc99a62))
; refinement_interpretation
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fsti(160,25-160,40); use=FStar.Math.Lemmas.fsti(160,25-160,40)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
   (! (iff
     (HasTypeFuel @u0 @x1 (Tm_refine_48ee302bf1eb4121a480c48fccc99a62 @x2))
     (and
      (HasTypeFuel @u0 @x1 Prims.nat)
      ;; def=FStar.Math.Lemmas.fsti(160,32-160,38); use=FStar.Math.Lemmas.fsti(160,32-160,38)
      (>= (BoxInt_proj_0 @x2) (BoxInt_proj_0 @x1))))
    :pattern ((HasTypeFuel @u0 @x1 (Tm_refine_48ee302bf1eb4121a480c48fccc99a62 @x2)))
    :qid refinement_interpretation_Tm_refine_48ee302bf1eb4121a480c48fccc99a62))
  :named refinement_interpretation_Tm_refine_48ee302bf1eb4121a480c48fccc99a62))
; haseq for Tm_refine_48ee302bf1eb4121a480c48fccc99a62
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fsti(160,25-160,40); use=FStar.Math.Lemmas.fsti(160,25-160,40)
  (forall ((@x0 Term))
   (! (iff
     (Valid (Prims.hasEq (Tm_refine_48ee302bf1eb4121a480c48fccc99a62 @x0)))
     (Valid (Prims.hasEq Prims.nat)))
    :pattern ((Valid (Prims.hasEq (Tm_refine_48ee302bf1eb4121a480c48fccc99a62 @x0))))
    :qid haseqTm_refine_48ee302bf1eb4121a480c48fccc99a62))
  :named haseqTm_refine_48ee302bf1eb4121a480c48fccc99a62))
(declare-fun Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9 () Term)
; refinement kinding
;;; Fact-ids: 
(assert
 (! (HasType Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9 Tm_type)
  :named refinement_kinding_Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
; refinement_interpretation
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fsti(160,44-161,38); use=FStar.Math.Lemmas.fsti(160,44-160,49)
  (forall ((@u0 Fuel) (@x1 Term))
   (! (iff
     (HasTypeFuel @u0 @x1 Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9)
     (HasTypeFuel @u0 @x1 Prims.unit))
    :pattern ((HasTypeFuel @u0 @x1 Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
    :qid refinement_interpretation_Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
  :named refinement_interpretation_Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
; haseq for Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9
;;; Fact-ids: 
(assert
 (! (iff
   (Valid (Prims.hasEq Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
   (Valid (Prims.hasEq Prims.unit)))
  :named haseqTm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
; Encoding query formula : forall (n: Prims.nat) (m: Prims.nat{n >= m}) (_: Prims.squash Prims.l_True).
;   (*  - Could not prove post-condition
; *)
;   (Prims.pow2 m > 0 ==> Prims.pow2 m <> 0) /\
;   (forall (return_val: Prims.nonzero).
;       return_val == Prims.pow2 m ==>
;       (forall (any_result: Prims.int). Prims.pow2 n / Prims.pow2 m == any_result ==> n - m >= 0))
; Context: While encoding a query
; While typechecking the top-level declaration `val FStar.Math.Lemmas.pow2_minus`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fsti(160,0-161,38)
   (forall ((@x0 Term) (@x1 Term) (@x2 Term))
    (! (implies
      (and
       (HasType @x0 Prims.nat)
       (HasType @x1 (Tm_refine_48ee302bf1eb4121a480c48fccc99a62 @x0))
       (HasType @x2 Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
      ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fsti(161,2-161,38)
      (and
       (implies
        ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fsti(161,14-161,22)
        (> (BoxInt_proj_0 (Prims.pow2 @x1)) (BoxInt_proj_0 (BoxInt 0)))
        ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fsti(161,14-161,22)
        (or
         label_1
         ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fsti(161,14-161,22)
         (not (= (Prims.pow2 @x1) (BoxInt 0)))))
       ;; def=Prims.fst(364,2-364,58); use=FStar.Math.Lemmas.fsti(161,2-161,38)
       (forall ((@x3 Term))
        (! (implies
          (and
           (HasType @x3 Prims.nonzero)
           ;; def=Prims.fst(364,26-364,41); use=FStar.Math.Lemmas.fsti(161,2-161,38)
           (= @x3 (Prims.pow2 @x1)))
          ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fsti(161,2-161,38)
          (forall ((@x4 Term))
           (! (implies
             (and
              (HasType @x4 Prims.int)
              ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fsti(161,2-161,38)
              (= (Prims.op_Division (Prims.pow2 @x0) (Prims.pow2 @x1)) @x4))
             ;; def=Prims.fst(682,18-682,24); use=FStar.Math.Lemmas.fsti(161,30-161,37)
             (or
              label_2
              ;; def=Prims.fst(682,18-682,24); use=FStar.Math.Lemmas.fsti(161,30-161,37)
              (>= (BoxInt_proj_0 (Prims.op_Subtraction @x0 @x1)) (BoxInt_proj_0 (BoxInt 0)))))
            :qid @query.2)))
         :qid @query.1))))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.pow2_minus, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt val FStar.Math.Lemmas.pow2_minus
; <Skipped val FStar.Math.Lemmas.pow2_minus/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(185,2-186,51)
(declare-fun label_7 () Bool)
(declare-fun label_6 () Bool)
(declare-fun label_5 () Bool)
(declare-fun label_4 () Bool)
(declare-fun label_3 () Bool)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
(declare-fun Tm_refine_48ee302bf1eb4121a480c48fccc99a62 (Term) Term)
; refinement kinding
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fsti(160,25-160,40); use=FStar.Math.Lemmas.fst(184,4-184,14)
  (forall ((@x0 Term))
   (! (HasType (Tm_refine_48ee302bf1eb4121a480c48fccc99a62 @x0) Tm_type)
    :pattern ((HasType (Tm_refine_48ee302bf1eb4121a480c48fccc99a62 @x0) Tm_type))
    :qid refinement_kinding_Tm_refine_48ee302bf1eb4121a480c48fccc99a62))
  :named refinement_kinding_Tm_refine_48ee302bf1eb4121a480c48fccc99a62))
; refinement_interpretation
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fsti(160,25-160,40); use=FStar.Math.Lemmas.fst(184,4-184,14)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
   (! (iff
     (HasTypeFuel @u0 @x1 (Tm_refine_48ee302bf1eb4121a480c48fccc99a62 @x2))
     (and
      (HasTypeFuel @u0 @x1 Prims.nat)
      ;; def=FStar.Math.Lemmas.fsti(160,32-160,38); use=FStar.Math.Lemmas.fst(184,4-184,14)
      (>= (BoxInt_proj_0 @x2) (BoxInt_proj_0 @x1))))
    :pattern ((HasTypeFuel @u0 @x1 (Tm_refine_48ee302bf1eb4121a480c48fccc99a62 @x2)))
    :qid refinement_interpretation_Tm_refine_48ee302bf1eb4121a480c48fccc99a62))
  :named refinement_interpretation_Tm_refine_48ee302bf1eb4121a480c48fccc99a62))
; haseq for Tm_refine_48ee302bf1eb4121a480c48fccc99a62
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fsti(160,25-160,40); use=FStar.Math.Lemmas.fst(184,4-184,14)
  (forall ((@x0 Term))
   (! (iff
     (Valid (Prims.hasEq (Tm_refine_48ee302bf1eb4121a480c48fccc99a62 @x0)))
     (Valid (Prims.hasEq Prims.nat)))
    :pattern ((Valid (Prims.hasEq (Tm_refine_48ee302bf1eb4121a480c48fccc99a62 @x0))))
    :qid haseqTm_refine_48ee302bf1eb4121a480c48fccc99a62))
  :named haseqTm_refine_48ee302bf1eb4121a480c48fccc99a62))
; Encoding query formula : forall (n: Prims.nat) (m: Prims.nat{n >= m}).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     (forall (pure_result: Prims.unit).
;         Prims.pow2 n / Prims.pow2 m = Prims.pow2 (n - m) ==> p pure_result) ==>
;     n - m >= 0 /\
;     (forall (return_val: Prims.nat).
;         return_val == n - m ==>
;         (forall (pure_result: Prims.unit).
;             Prims.pow2 (n - m) * Prims.pow2 m = Prims.pow2 (n - m + m) ==>
;             n - m >= 0 /\
;             (forall (return_val: Prims.nat).
;                 return_val == n - m ==>
;                 (forall (any_result: Prims.pos).
;                     Prims.pow2 (n - m) == any_result ==>
;                     (Prims.pow2 (n - m) > 0 ==> Prims.pow2 (n - m) >= 0) /\
;                     (forall (return_val: Prims.nat).
;                         return_val == Prims.pow2 (n - m) ==>
;                         Prims.pow2 (n - m) == return_val ==>
;                         (Prims.pow2 n > 0 ==> Prims.pow2 n >= 0) /\
;                         (forall (return_val: Prims.nat).
;                             return_val == Prims.pow2 n ==>
;                             Prims.pow2 (n - m) * Prims.pow2 m = Prims.pow2 n /\
;                             (forall (pure_result: Prims.unit).
;                                 Prims.pow2 (n - m) = Prims.pow2 n / Prims.pow2 m ==> p pure_result))
;                     )))))
; Context: While encoding a query
; While typechecking the top-level declaration `let pow2_minus`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term))
    (! (implies
      (and (HasType @x0 Prims.nat) (HasType @x1 (Tm_refine_48ee302bf1eb4121a480c48fccc99a62 @x0)))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x2 Term))
       (! (implies
         (and
          (HasType @x2 (Prims.pure_post Prims.unit))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(185,2-186,51)
          (forall ((@x3 Term))
           (! (implies
             (and
              (or label_1 (HasType @x3 Prims.unit))
              ;; def=FStar.Math.Lemmas.fsti(161,2-161,38); use=FStar.Math.Lemmas.fst(185,2-186,51)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fsti(161,2-161,38); use=FStar.Math.Lemmas.fst(185,2-186,51)
               (=
                (Prims.op_Division (Prims.pow2 @x0) (Prims.pow2 @x1))
                (Prims.pow2 (Prims.op_Subtraction @x0 @x1)))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(185,2-186,51)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(185,2-186,51)
              (ApplyTT @x2 @x3)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(185,2-186,51)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(185,2-186,51)
               (ApplyTT @x2 @x3)))
            :qid @query.2)))
         ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(185,2-186,51)
         (and
          ;; def=Prims.fst(682,18-682,24); use=FStar.Math.Lemmas.fst(185,12-185,19)
          (or
           label_3
           ;; def=Prims.fst(682,18-682,24); use=FStar.Math.Lemmas.fst(185,12-185,19)
           (>= (BoxInt_proj_0 (Prims.op_Subtraction @x0 @x1)) (BoxInt_proj_0 (BoxInt 0))))
          ;; def=Prims.fst(364,2-364,58); use=FStar.Math.Lemmas.fst(185,2-186,51)
          (forall ((@x3 Term))
           (! (implies
             (and
              (HasType @x3 Prims.nat)
              ;; def=Prims.fst(364,26-364,41); use=FStar.Math.Lemmas.fst(185,2-186,51)
              (= @x3 (Prims.op_Subtraction @x0 @x1)))
             ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(185,2-185,11)
             (forall ((@x4 Term))
              (! (implies
                (and
                 (HasType @x4 Prims.unit)
                 ;; def=FStar.Math.Lemmas.fsti(156,11-156,43); use=FStar.Math.Lemmas.fst(185,2-185,11)
                 (=
                  (Prims.op_Multiply (Prims.pow2 (Prims.op_Subtraction @x0 @x1)) (Prims.pow2 @x1))
                  (Prims.pow2 (Prims.op_Addition (Prims.op_Subtraction @x0 @x1) @x1))))
                ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(185,2-186,51)
                (and
                 ;; def=Prims.fst(682,18-682,24); use=FStar.Math.Lemmas.fst(186,25-186,32)
                 (or
                  label_4
                  ;; def=Prims.fst(682,18-682,24); use=FStar.Math.Lemmas.fst(186,25-186,32)
                  (>= (BoxInt_proj_0 (Prims.op_Subtraction @x0 @x1)) (BoxInt_proj_0 (BoxInt 0))))
                 ;; def=Prims.fst(364,2-364,58); use=FStar.Math.Lemmas.fst(185,2-186,51)
                 (forall ((@x5 Term))
                  (! (implies
                    (and
                     (HasType @x5 Prims.nat)
                     ;; def=Prims.fst(364,26-364,41); use=FStar.Math.Lemmas.fst(185,2-186,51)
                     (= @x5 (Prims.op_Subtraction @x0 @x1)))
                    ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(185,2-186,51)
                    (forall ((@x6 Term))
                     (! (implies
                       (and
                        (HasType @x6 Prims.pos)
                        ;; def=FStar.Math.Lib.fst(45,24-45,27); use=FStar.Math.Lemmas.fst(186,2-186,33)
                        (= (Prims.pow2 (Prims.op_Subtraction @x0 @x1)) @x6))
                       ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(185,2-186,51)
                       (and
                        (implies
                         ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(186,19-186,33)
                         (>
                          (BoxInt_proj_0 (Prims.pow2 (Prims.op_Subtraction @x0 @x1)))
                          (BoxInt_proj_0 (BoxInt 0)))
                         ;; def=Prims.fst(682,18-682,24); use=FStar.Math.Lemmas.fst(186,19-186,33)
                         (or
                          label_5
                          ;; def=Prims.fst(682,18-682,24); use=FStar.Math.Lemmas.fst(186,19-186,33)
                          (>=
                           (BoxInt_proj_0 (Prims.pow2 (Prims.op_Subtraction @x0 @x1)))
                           (BoxInt_proj_0 (BoxInt 0)))))
                        ;; def=Prims.fst(364,2-364,58); use=FStar.Math.Lemmas.fst(185,2-186,51)
                        (forall ((@x7 Term))
                         (! (implies
                           (and
                            (HasType @x7 Prims.nat)
                            ;; def=Prims.fst(364,26-364,41); use=FStar.Math.Lemmas.fst(185,2-186,51)
                            (= @x7 (Prims.pow2 (Prims.op_Subtraction @x0 @x1)))
                            ;; def=FStar.Math.Lib.fst(45,22-45,23); use=FStar.Math.Lemmas.fst(185,2-186,51)
                            (= (Prims.pow2 (Prims.op_Subtraction @x0 @x1)) @x7))
                           ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(185,2-186,51)
                           (and
                            (implies
                             ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(186,43-186,51)
                             (> (BoxInt_proj_0 (Prims.pow2 @x0)) (BoxInt_proj_0 (BoxInt 0)))
                             ;; def=Prims.fst(682,18-682,24); use=FStar.Math.Lemmas.fst(186,43-186,51)
                             (or
                              label_6
                              ;; def=Prims.fst(682,18-682,24); use=FStar.Math.Lemmas.fst(186,43-186,51)
                              (>= (BoxInt_proj_0 (Prims.pow2 @x0)) (BoxInt_proj_0 (BoxInt 0)))))
                            ;; def=Prims.fst(364,2-364,58); use=FStar.Math.Lemmas.fst(185,2-186,51)
                            (forall ((@x8 Term))
                             (! (implies
                               (and
                                (HasType @x8 Prims.nat)
                                ;; def=Prims.fst(364,26-364,41); use=FStar.Math.Lemmas.fst(185,2-186,51)
                                (= @x8 (Prims.pow2 @x0)))
                               ;; def=Prims.fst(449,29-449,97); use=FStar.Math.Lemmas.fst(186,2-186,18)
                               (and
                                ;; def=FStar.Math.Lib.fst(46,12-46,23); use=FStar.Math.Lemmas.fst(186,2-186,18)
                                (or
                                 label_7
                                 ;; def=FStar.Math.Lib.fst(46,12-46,23); use=FStar.Math.Lemmas.fst(186,2-186,18)
                                 (=
                                  (Prims.op_Multiply
                                   (Prims.pow2 (Prims.op_Subtraction @x0 @x1))
                                   (Prims.pow2 @x1))
                                  (Prims.pow2 @x0)))
                                ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(186,2-186,18)
                                (forall ((@x9 Term))
                                 (! (implies
                                   (and
                                    (HasType @x9 Prims.unit)
                                    ;; def=FStar.Math.Lib.fst(47,12-47,23); use=FStar.Math.Lemmas.fst(186,2-186,18)
                                    (=
                                     (Prims.pow2 (Prims.op_Subtraction @x0 @x1))
                                     (Prims.op_Division (Prims.pow2 @x0) (Prims.pow2 @x1))))
                                   ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(186,2-186,18)
                                   (Valid
                                    ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(186,2-186,18)
                                    (ApplyTT @x2 @x9)))
                                  :qid @query.9))))
                              :qid @query.8))))
                          :qid @query.7))))
                      :qid @query.6)))
                   :qid @query.5))))
               :qid @query.4)))
            :qid @query.3))))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_7")
(eval label_7)
(echo "label_6")
(eval label_6)
(echo "label_5")
(eval label_5)
(echo "label_4")
(eval label_4)
(echo "label_3")
(eval label_3)
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.pow2_minus, 2)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let pow2_minus
; <Start encoding let pow2_minus>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.pow2_minus (Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.pow2_minus@tok () Term)
; </end encoding let pow2_minus>

; encoding sigelt val FStar.Math.Lemmas.multiply_fractions
; <Skipped val FStar.Math.Lemmas.multiply_fractions/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(189,29-189,31)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (a: Prims.int) (n: Prims.nonzero).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     (forall (pure_result: Prims.unit). n * (a / n) <= a ==> p pure_result) ==>
;     (forall (any_result: Prims.unit). p any_result)
; Context: While encoding a query
; While typechecking the top-level declaration `let multiply_fractions`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term))
    (! (implies
      (and (HasType @x0 Prims.int) (HasType @x1 Prims.nonzero))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x2 Term))
       (! (implies
         (and
          (HasType @x2 (Prims.pure_post Prims.unit))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(189,29-189,31)
          (forall ((@x3 Term))
           (! (implies
             (and
              (or label_1 (HasType @x3 Prims.unit))
              ;; def=FStar.Math.Lemmas.fsti(164,51-164,71); use=FStar.Math.Lemmas.fst(189,29-189,31)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fsti(164,51-164,71); use=FStar.Math.Lemmas.fst(189,29-189,31)
               (<=
                (BoxInt_proj_0 (Prims.op_Multiply @x1 (Prims.op_Division @x0 @x1)))
                (BoxInt_proj_0 @x0))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(189,29-189,31)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(189,29-189,31)
              (ApplyTT @x2 @x3)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(189,29-189,31)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(189,29-189,31)
               (ApplyTT @x2 @x3)))
            :qid @query.2)))
         ;; def=Prims.fst(459,66-459,102); use=Prims.fst(462,31-462,44)
         (forall ((@x3 Term))
          (! (implies
            (HasType @x3 Prims.unit)
            ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
            (Valid
             ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
             (ApplyTT @x2 @x3)))
           :qid @query.3)))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.multiply_fractions, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let multiply_fractions
; <Start encoding let multiply_fractions>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.multiply_fractions (Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.multiply_fractions@tok () Term)
; </end encoding let multiply_fractions>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fsti(167,0-167,82)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (a: Prims.nat) (b: Prims.pos) (_: Prims.squash (a < b)).
;   (*  - Could not prove post-condition
; *) b > 0 ==> b <> 0
; Context: While encoding a query
; While typechecking the top-level declaration `val FStar.Math.Lemmas.modulo_lemma`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fsti(167,0-167,82)
   (forall ((@x0 Term) (@x1 Term) (@x2 Term))
    (! (implies
      (and
       (HasType @x0 Prims.nat)
       (HasType @x1 Prims.pos)
       (HasType @x2 (Prims.squash (Prims.b2t (Prims.op_LessThan @x0 @x1))))
       ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fsti(167,75-167,76)
       (> (BoxInt_proj_0 @x1) (BoxInt_proj_0 (BoxInt 0))))
      ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fsti(167,75-167,76)
      (or
       label_1
       ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fsti(167,75-167,76)
       (not (= @x1 (BoxInt 0)))))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.modulo_lemma, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt val FStar.Math.Lemmas.modulo_lemma
; <Skipped val FStar.Math.Lemmas.modulo_lemma/>

;;; Fact-ids: Name Prims.op_Modulus; Namespace Prims
(assert
 (! ;; def=Prims.fst(699,4-699,14); use=Prims.fst(699,4-699,14)
  (forall ((@x0 Term) (@x1 Term))
   (! (implies
     (not (= (BoxInt_proj_0 @x1) 0))
     (= (Prims.op_Modulus @x0 @x1) (BoxInt (mod (BoxInt_proj_0 @x0) (BoxInt_proj_0 @x1)))))
    :pattern ((Prims.op_Modulus @x0 @x1))
    :qid primitive_Prims.op_Modulus))
  :named primitive_Prims.op_Modulus))
(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(192,23-192,25)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (a: Prims.nat) (b: Prims.pos).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     a < b /\ (forall (pure_result: Prims.unit). a % b = a ==> p pure_result) ==>
;     (forall (any_result: Prims.unit). p any_result)
; Context: While encoding a query
; While typechecking the top-level declaration `let modulo_lemma`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term))
    (! (implies
      (and (HasType @x0 Prims.nat) (HasType @x1 Prims.pos))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x2 Term))
       (! (implies
         (and
          (HasType @x2 (Prims.pure_post Prims.unit))
          ;; def=FStar.Math.Lemmas.fsti(167,52-167,59); use=FStar.Math.Lemmas.fst(192,23-192,25)
          (< (BoxInt_proj_0 @x0) (BoxInt_proj_0 @x1))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(192,23-192,25)
          (forall ((@x3 Term))
           (! (implies
             (and
              (or label_1 (HasType @x3 Prims.unit))
              ;; def=FStar.Math.Lemmas.fsti(167,70-167,81); use=FStar.Math.Lemmas.fst(192,23-192,25)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fsti(167,70-167,81); use=FStar.Math.Lemmas.fst(192,23-192,25)
               (= (Prims.op_Modulus @x0 @x1) @x0)))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(192,23-192,25)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(192,23-192,25)
              (ApplyTT @x2 @x3)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(192,23-192,25)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(192,23-192,25)
               (ApplyTT @x2 @x3)))
            :qid @query.2)))
         ;; def=Prims.fst(459,66-459,102); use=Prims.fst(462,31-462,44)
         (forall ((@x3 Term))
          (! (implies
            (HasType @x3 Prims.unit)
            ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
            (Valid
             ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
             (ApplyTT @x2 @x3)))
           :qid @query.3)))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.modulo_lemma, 2)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let modulo_lemma
; <Start encoding let modulo_lemma>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.modulo_lemma (Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.modulo_lemma@tok () Term)
; </end encoding let modulo_lemma>

; encoding sigelt val FStar.Math.Lemmas.lemma_div_mod
; <Skipped val FStar.Math.Lemmas.lemma_div_mod/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(195,24-195,26)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (a: Prims.int) (p: Prims.nonzero).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     (forall (pure_result: Prims.unit). a = p * (a / p) + a % p ==> p pure_result) ==>
;     (forall (any_result: Prims.unit). p any_result)
; Context: While encoding a query
; While typechecking the top-level declaration `let lemma_div_mod`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term))
    (! (implies
      (and (HasType @x0 Prims.int) (HasType @x1 Prims.nonzero))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x2 Term))
       (! (implies
         (and
          (HasType @x2 (Prims.pure_post Prims.unit))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(195,24-195,26)
          (forall ((@x3 Term))
           (! (implies
             (and
              (or label_1 (HasType @x3 Prims.unit))
              ;; def=FStar.Math.Lemmas.fsti(170,47-170,72); use=FStar.Math.Lemmas.fst(195,24-195,26)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fsti(170,47-170,72); use=FStar.Math.Lemmas.fst(195,24-195,26)
               (=
                @x0
                (Prims.op_Addition
                 (Prims.op_Multiply @x1 (Prims.op_Division @x0 @x1))
                 (Prims.op_Modulus @x0 @x1)))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(195,24-195,26)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(195,24-195,26)
              (ApplyTT @x2 @x3)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(195,24-195,26)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(195,24-195,26)
               (ApplyTT @x2 @x3)))
            :qid @query.2)))
         ;; def=Prims.fst(459,66-459,102); use=Prims.fst(462,31-462,44)
         (forall ((@x3 Term))
          (! (implies
            (HasType @x3 Prims.unit)
            ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
            (Valid
             ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
             (ApplyTT @x2 @x3)))
           :qid @query.3)))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.lemma_div_mod, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let lemma_div_mod
; <Start encoding let lemma_div_mod>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.lemma_div_mod (Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.lemma_div_mod@tok () Term)
; </end encoding let lemma_div_mod>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fsti(172,0-172,94)
(declare-fun label_3 () Bool)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
(declare-fun Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9 () Term)
; refinement kinding
;;; Fact-ids: 
(assert
 (! (HasType Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9 Tm_type)
  :named refinement_kinding_Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
; refinement_interpretation
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fsti(172,36-172,94); use=FStar.Math.Lemmas.fsti(172,36-172,41)
  (forall ((@u0 Fuel) (@x1 Term))
   (! (iff
     (HasTypeFuel @u0 @x1 Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9)
     (HasTypeFuel @u0 @x1 Prims.unit))
    :pattern ((HasTypeFuel @u0 @x1 Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
    :qid refinement_interpretation_Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
  :named refinement_interpretation_Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
; haseq for Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9
;;; Fact-ids: 
(assert
 (! (iff
   (Valid (Prims.hasEq Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
   (Valid (Prims.hasEq Prims.unit)))
  :named haseqTm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
; Encoding query formula : forall (a: Prims.int) (p: Prims.pos) (_: Prims.squash Prims.l_True).
;   (*  - Could not prove post-condition
; *)
;   (p > 0 ==> p <> 0) /\ (0 <= a % p ==> p > 0 ==> p <> 0) /\
;   (0 <= a % p /\ a % p < p ==> a >= 0 ==> p > 0 ==> p <> 0)
; Context: While encoding a query
; While typechecking the top-level declaration `val FStar.Math.Lemmas.lemma_mod_lt`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fsti(172,0-172,94)
   (forall ((@x0 Term) (@x1 Term) (@x2 Term))
    (! (implies
      (and
       (HasType @x0 Prims.int)
       (HasType @x1 Prims.pos)
       (HasType @x2 Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
      ;; def=FStar.Math.Lemmas.fsti(172,27-172,77); use=FStar.Math.Lemmas.fsti(172,43-172,87)
      (and
       (implies
        ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fsti(172,52-172,53)
        (> (BoxInt_proj_0 @x1) (BoxInt_proj_0 (BoxInt 0)))
        ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fsti(172,52-172,53)
        (or
         label_1
         ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fsti(172,52-172,53)
         (not (= @x1 (BoxInt 0)))))
       (implies
        (and
         ;; def=FStar.Math.Lemmas.fsti(172,43-172,53); use=FStar.Math.Lemmas.fsti(172,43-172,53)
         (<= (BoxInt_proj_0 (BoxInt 0)) (BoxInt_proj_0 (Prims.op_Modulus @x0 @x1)))
         ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fsti(172,61-172,62)
         (> (BoxInt_proj_0 @x1) (BoxInt_proj_0 (BoxInt 0))))
        ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fsti(172,61-172,62)
        (or
         label_2
         ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fsti(172,61-172,62)
         (not (= @x1 (BoxInt 0)))))
       (implies
        (and
         ;; def=FStar.Math.Lemmas.fsti(172,43-172,53); use=FStar.Math.Lemmas.fsti(172,43-172,53)
         (<= (BoxInt_proj_0 (BoxInt 0)) (BoxInt_proj_0 (Prims.op_Modulus @x0 @x1)))
         ;; def=FStar.Math.Lemmas.fsti(172,57-172,66); use=FStar.Math.Lemmas.fsti(172,57-172,66)
         (< (BoxInt_proj_0 (Prims.op_Modulus @x0 @x1)) (BoxInt_proj_0 @x1))
         ;; def=FStar.Math.Lemmas.fsti(172,71-172,77); use=FStar.Math.Lemmas.fsti(172,71-172,77)
         (>= (BoxInt_proj_0 @x0) (BoxInt_proj_0 (BoxInt 0)))
         ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fsti(172,86-172,87)
         (> (BoxInt_proj_0 @x1) (BoxInt_proj_0 (BoxInt 0))))
        ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fsti(172,86-172,87)
        (or
         label_3
         ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fsti(172,86-172,87)
         (not (= @x1 (BoxInt 0)))))))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_3")
(eval label_3)
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.lemma_mod_lt, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt val FStar.Math.Lemmas.lemma_mod_lt
; <Skipped val FStar.Math.Lemmas.lemma_mod_lt/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(197,23-197,25)
(declare-fun label_4 () Bool)
(declare-fun label_3 () Bool)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (a: Prims.int) (p: Prims.pos).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     (forall (pure_result: Prims.unit).
;         0 <= a % p /\ a % p < p /\ (a >= 0 ==> a % p <= a) ==> p pure_result) ==>
;     (forall (any_result: Prims.unit). p any_result)
; Context: While encoding a query
; While typechecking the top-level declaration `let lemma_mod_lt`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term))
    (! (implies
      (and (HasType @x0 Prims.int) (HasType @x1 Prims.pos))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x2 Term))
       (! (implies
         (and
          (HasType @x2 (Prims.pure_post Prims.unit))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(197,23-197,25)
          (forall ((@x3 Term))
           (! (implies
             (and
              (or label_1 (HasType @x3 Prims.unit))
              ;; def=FStar.Math.Lemmas.fsti(172,43-172,53); use=FStar.Math.Lemmas.fst(197,23-197,25)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fsti(172,43-172,53); use=FStar.Math.Lemmas.fst(197,23-197,25)
               (<= (BoxInt_proj_0 (BoxInt 0)) (BoxInt_proj_0 (Prims.op_Modulus @x0 @x1))))
              ;; def=FStar.Math.Lemmas.fsti(172,57-172,66); use=FStar.Math.Lemmas.fst(197,23-197,25)
              (or
               label_3
               ;; def=FStar.Math.Lemmas.fsti(172,57-172,66); use=FStar.Math.Lemmas.fst(197,23-197,25)
               (< (BoxInt_proj_0 (Prims.op_Modulus @x0 @x1)) (BoxInt_proj_0 @x1)))
              (implies
               ;; def=FStar.Math.Lemmas.fsti(172,71-172,77); use=FStar.Math.Lemmas.fst(197,23-197,25)
               (>= (BoxInt_proj_0 @x0) (BoxInt_proj_0 (BoxInt 0)))
               ;; def=FStar.Math.Lemmas.fsti(172,82-172,92); use=FStar.Math.Lemmas.fst(197,23-197,25)
               (or
                label_4
                ;; def=FStar.Math.Lemmas.fsti(172,82-172,92); use=FStar.Math.Lemmas.fst(197,23-197,25)
                (<= (BoxInt_proj_0 (Prims.op_Modulus @x0 @x1)) (BoxInt_proj_0 @x0)))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(197,23-197,25)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(197,23-197,25)
              (ApplyTT @x2 @x3)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(197,23-197,25)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(197,23-197,25)
               (ApplyTT @x2 @x3)))
            :qid @query.2)))
         ;; def=Prims.fst(459,66-459,102); use=Prims.fst(462,31-462,44)
         (forall ((@x3 Term))
          (! (implies
            (HasType @x3 Prims.unit)
            ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
            (Valid
             ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
             (ApplyTT @x2 @x3)))
           :qid @query.3)))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_4")
(eval label_4)
(echo "label_3")
(eval label_3)
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.lemma_mod_lt, 2)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let lemma_mod_lt
; <Start encoding let lemma_mod_lt>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.lemma_mod_lt (Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.lemma_mod_lt@tok () Term)
; </end encoding let lemma_mod_lt>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fsti(174,0-176,44)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
(declare-fun Tm_refine_7e0b9b2dbca36eab00de093c1b701c6d (Term) Term)
; refinement kinding
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fsti(174,40-174,53); use=FStar.Math.Lemmas.fsti(174,40-174,53)
  (forall ((@x0 Term))
   (! (HasType (Tm_refine_7e0b9b2dbca36eab00de093c1b701c6d @x0) Tm_type)
    :pattern ((HasType (Tm_refine_7e0b9b2dbca36eab00de093c1b701c6d @x0) Tm_type))
    :qid refinement_kinding_Tm_refine_7e0b9b2dbca36eab00de093c1b701c6d))
  :named refinement_kinding_Tm_refine_7e0b9b2dbca36eab00de093c1b701c6d))
; refinement_interpretation
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fsti(174,40-174,53); use=FStar.Math.Lemmas.fsti(174,40-174,53)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
   (! (iff
     (HasTypeFuel @u0 @x1 (Tm_refine_7e0b9b2dbca36eab00de093c1b701c6d @x2))
     (and
      (HasTypeFuel @u0 @x1 Prims.nat)
      ;; def=FStar.Math.Lemmas.fsti(174,46-174,52); use=FStar.Math.Lemmas.fsti(174,46-174,52)
      (<= (BoxInt_proj_0 @x1) (BoxInt_proj_0 @x2))))
    :pattern ((HasTypeFuel @u0 @x1 (Tm_refine_7e0b9b2dbca36eab00de093c1b701c6d @x2)))
    :qid refinement_interpretation_Tm_refine_7e0b9b2dbca36eab00de093c1b701c6d))
  :named refinement_interpretation_Tm_refine_7e0b9b2dbca36eab00de093c1b701c6d))
; haseq for Tm_refine_7e0b9b2dbca36eab00de093c1b701c6d
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fsti(174,40-174,53); use=FStar.Math.Lemmas.fsti(174,40-174,53)
  (forall ((@x0 Term))
   (! (iff
     (Valid (Prims.hasEq (Tm_refine_7e0b9b2dbca36eab00de093c1b701c6d @x0)))
     (Valid (Prims.hasEq Prims.nat)))
    :pattern ((Valid (Prims.hasEq (Tm_refine_7e0b9b2dbca36eab00de093c1b701c6d @x0))))
    :qid haseqTm_refine_7e0b9b2dbca36eab00de093c1b701c6d))
  :named haseqTm_refine_7e0b9b2dbca36eab00de093c1b701c6d))
; Encoding query formula : forall (a: Prims.int) (n: Prims.nat) (m: Prims.nat{m <= n}) (_: Prims.squash (a < Prims.pow2 n)).
;   (*  - Could not prove post-condition
; *)
;   (Prims.pow2 m > 0 ==> Prims.pow2 m <> 0) /\
;   (forall (return_val: Prims.nonzero).
;       return_val == Prims.pow2 m ==>
;       (forall (any_result: Prims.int). a / Prims.pow2 m == any_result ==> n - m >= 0))
; Context: While encoding a query
; While typechecking the top-level declaration `val FStar.Math.Lemmas.lemma_div_lt_nat`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fsti(174,0-176,44)
   (forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
    (! (implies
      (and
       (HasType @x0 Prims.int)
       (HasType @x1 Prims.nat)
       (HasType @x2 (Tm_refine_7e0b9b2dbca36eab00de093c1b701c6d @x1))
       (HasType @x3 (Prims.squash (Prims.b2t (Prims.op_LessThan @x0 (Prims.pow2 @x1))))))
      ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fsti(176,18-176,43)
      (and
       (implies
        ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fsti(176,23-176,29)
        (> (BoxInt_proj_0 (Prims.pow2 @x2)) (BoxInt_proj_0 (BoxInt 0)))
        ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fsti(176,23-176,29)
        (or
         label_1
         ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fsti(176,23-176,29)
         (not (= (Prims.pow2 @x2) (BoxInt 0)))))
       ;; def=Prims.fst(364,2-364,58); use=FStar.Math.Lemmas.fsti(176,18-176,43)
       (forall ((@x4 Term))
        (! (implies
          (and
           (HasType @x4 Prims.nonzero)
           ;; def=Prims.fst(364,26-364,41); use=FStar.Math.Lemmas.fsti(176,18-176,43)
           (= @x4 (Prims.pow2 @x2)))
          ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fsti(176,18-176,43)
          (forall ((@x5 Term))
           (! (implies
             (and
              (HasType @x5 Prims.int)
              ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fsti(176,18-176,43)
              (= (Prims.op_Division @x0 (Prims.pow2 @x2)) @x5))
             ;; def=Prims.fst(682,18-682,24); use=FStar.Math.Lemmas.fsti(176,37-176,42)
             (or
              label_2
              ;; def=Prims.fst(682,18-682,24); use=FStar.Math.Lemmas.fsti(176,37-176,42)
              (>= (BoxInt_proj_0 (Prims.op_Subtraction @x1 @x2)) (BoxInt_proj_0 (BoxInt 0)))))
            :qid @query.2)))
         :qid @query.1))))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.lemma_div_lt_nat, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt val FStar.Math.Lemmas.lemma_div_lt_nat
; <Skipped val FStar.Math.Lemmas.lemma_div_lt_nat/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(200,2-203,40)
(declare-fun label_9 () Bool)
(declare-fun label_8 () Bool)
(declare-fun label_7 () Bool)
(declare-fun label_6 () Bool)
(declare-fun label_5 () Bool)
(declare-fun label_4 () Bool)
(declare-fun label_3 () Bool)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
(declare-fun Tm_refine_7e0b9b2dbca36eab00de093c1b701c6d (Term) Term)
; refinement kinding
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fsti(174,40-174,53); use=FStar.Math.Lemmas.fst(199,4-199,20)
  (forall ((@x0 Term))
   (! (HasType (Tm_refine_7e0b9b2dbca36eab00de093c1b701c6d @x0) Tm_type)
    :pattern ((HasType (Tm_refine_7e0b9b2dbca36eab00de093c1b701c6d @x0) Tm_type))
    :qid refinement_kinding_Tm_refine_7e0b9b2dbca36eab00de093c1b701c6d))
  :named refinement_kinding_Tm_refine_7e0b9b2dbca36eab00de093c1b701c6d))
; refinement_interpretation
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fsti(174,40-174,53); use=FStar.Math.Lemmas.fst(199,4-199,20)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
   (! (iff
     (HasTypeFuel @u0 @x1 (Tm_refine_7e0b9b2dbca36eab00de093c1b701c6d @x2))
     (and
      (HasTypeFuel @u0 @x1 Prims.nat)
      ;; def=FStar.Math.Lemmas.fsti(174,46-174,52); use=FStar.Math.Lemmas.fst(199,4-199,20)
      (<= (BoxInt_proj_0 @x1) (BoxInt_proj_0 @x2))))
    :pattern ((HasTypeFuel @u0 @x1 (Tm_refine_7e0b9b2dbca36eab00de093c1b701c6d @x2)))
    :qid refinement_interpretation_Tm_refine_7e0b9b2dbca36eab00de093c1b701c6d))
  :named refinement_interpretation_Tm_refine_7e0b9b2dbca36eab00de093c1b701c6d))
; haseq for Tm_refine_7e0b9b2dbca36eab00de093c1b701c6d
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fsti(174,40-174,53); use=FStar.Math.Lemmas.fst(199,4-199,20)
  (forall ((@x0 Term))
   (! (iff
     (Valid (Prims.hasEq (Tm_refine_7e0b9b2dbca36eab00de093c1b701c6d @x0)))
     (Valid (Prims.hasEq Prims.nat)))
    :pattern ((Valid (Prims.hasEq (Tm_refine_7e0b9b2dbca36eab00de093c1b701c6d @x0))))
    :qid haseqTm_refine_7e0b9b2dbca36eab00de093c1b701c6d))
  :named haseqTm_refine_7e0b9b2dbca36eab00de093c1b701c6d))
; Encoding query formula : forall (a: Prims.int) (n: Prims.nat) (m: Prims.nat{m <= n}).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     a < Prims.pow2 n /\
;     (forall (pure_result: Prims.unit). a / Prims.pow2 m < Prims.pow2 (n - m) ==> p pure_result) ==>
;     (Prims.pow2 m > 0 ==> Prims.pow2 m <> 0) /\
;     (forall (return_val: Prims.nonzero).
;         return_val == Prims.pow2 m ==>
;         (forall (pure_result: Prims.unit).
;             a = Prims.pow2 m * (a / Prims.pow2 m) + a % Prims.pow2 m ==>
;             (Prims.pow2 m > 0 ==> Prims.pow2 m <> 0) /\
;             (forall (return_val: Prims.nonzero).
;                 return_val == Prims.pow2 m ==>
;                 (forall (any_result: Prims.int).
;                     a / Prims.pow2 m == any_result ==>
;                     (forall (any_result: Prims.int).
;                         Prims.pow2 m * (a / Prims.pow2 m) == any_result ==>
;                         (Prims.pow2 m > 0 ==> Prims.pow2 m <> 0) /\
;                         (forall (return_val: Prims.nonzero).
;                             return_val == Prims.pow2 m ==>
;                             (forall (any_result: Prims.int).
;                                 a % Prims.pow2 m == any_result ==>
;                                 (forall (any_result: Prims.int).
;                                     Prims.pow2 m * (a / Prims.pow2 m) + a % Prims.pow2 m ==
;                                     any_result ==>
;                                     (forall (any_result: Prims.bool).
;                                         a = Prims.pow2 m * (a / Prims.pow2 m) + a % Prims.pow2 m ==
;                                         any_result ==>
;                                         (forall (any_result: Prims.logical).
;                                             a = Prims.pow2 m * (a / Prims.pow2 m) + a % Prims.pow2 m ==
;                                             any_result ==>
;                                             a = Prims.pow2 m * (a / Prims.pow2 m) + a % Prims.pow2 m /\
;                                             (forall (pure_result: Prims.unit).
;                                                 a =
;                                                 Prims.pow2 m * (a / Prims.pow2 m) + a % Prims.pow2 m ==>
;                                                 n - m >= 0 /\
;                                                 (forall (return_val: Prims.nat).
;                                                     return_val == n - m ==>
;                                                     (forall (pure_result: Prims.unit).
;                                                         Prims.pow2 m * Prims.pow2 (n - m) =
;                                                         Prims.pow2 (m + (n - m)) ==>
;                                                         n - m >= 0 /\
;                                                         (forall (return_val: Prims.nat).
;                                                             return_val == n - m ==>
;                                                             (forall (any_result: Prims.pos).
;                                                                 Prims.pow2 (n - m) == any_result ==>
;                                                                 (forall (return_val: Prims.pos).
;                                                                     return_val == Prims.pow2 (n - m) ==>
;                                                                     Prims.pow2 (n - m) == return_val ==>
;                                                                     (forall (any_result: Prims.int).
;                                                                         Prims.pow2 m *
;                                                                         Prims.pow2 (n - m) ==
;                                                                         any_result ==>
;                                                                         (forall (any_result:
;                                                                             Prims.bool).
;                                                                             Prims.pow2 n =
;                                                                             Prims.pow2 m *
;                                                                             Prims.pow2 (n - m) ==
;                                                                             any_result ==>
;                                                                             (forall (any_result:
;                                                                                 Prims.logical).
;                                                                                 Prims.pow2 n =
;                                                                                 Prims.pow2 m *
;                                                                                 Prims.pow2 (n - m) ==
;                                                                                 any_result ==>
;                                                                                 Prims.pow2 n =
;                                                                                 Prims.pow2 m *
;                                                                                 Prims.pow2 (n - m) /\
;                                                                                 (forall (pure_result:
;                                                                                     Prims.unit).
;                                                                                     Prims.pow2 n =
;                                                                                     Prims.pow2 m *
;                                                                                     Prims.pow2 (n -
;                                                                                         m) ==>
;                                                                                     p pure_result)))
;                                                                     )))))))))))))))))
; Context: While encoding a query
; While typechecking the top-level declaration `let lemma_div_lt_nat`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term) (@x2 Term))
    (! (implies
      (and
       (HasType @x0 Prims.int)
       (HasType @x1 Prims.nat)
       (HasType @x2 (Tm_refine_7e0b9b2dbca36eab00de093c1b701c6d @x1)))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x3 Term))
       (! (implies
         (and
          (HasType @x3 (Prims.pure_post Prims.unit))
          ;; def=FStar.Math.Lemmas.fsti(175,18-175,30); use=FStar.Math.Lemmas.fst(200,2-203,40)
          (< (BoxInt_proj_0 @x0) (BoxInt_proj_0 (Prims.pow2 @x1)))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(200,2-203,40)
          (forall ((@x4 Term))
           (! (implies
             (and
              (or label_1 (HasType @x4 Prims.unit))
              ;; def=FStar.Math.Lemmas.fsti(176,18-176,43); use=FStar.Math.Lemmas.fst(200,2-203,40)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fsti(176,18-176,43); use=FStar.Math.Lemmas.fst(200,2-203,40)
               (<
                (BoxInt_proj_0 (Prims.op_Division @x0 (Prims.pow2 @x2)))
                (BoxInt_proj_0 (Prims.pow2 (Prims.op_Subtraction @x1 @x2))))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(200,2-203,40)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(200,2-203,40)
              (ApplyTT @x3 @x4)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(200,2-203,40)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(200,2-203,40)
               (ApplyTT @x3 @x4)))
            :qid @query.2)))
         ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(200,2-203,40)
         (and
          (implies
           ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(200,18-200,26)
           (> (BoxInt_proj_0 (Prims.pow2 @x2)) (BoxInt_proj_0 (BoxInt 0)))
           ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(200,18-200,26)
           (or
            label_3
            ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(200,18-200,26)
            (not (= (Prims.pow2 @x2) (BoxInt 0)))))
          ;; def=Prims.fst(364,2-364,58); use=FStar.Math.Lemmas.fst(200,2-203,40)
          (forall ((@x4 Term))
           (! (implies
             (and
              (HasType @x4 Prims.nonzero)
              ;; def=Prims.fst(364,26-364,41); use=FStar.Math.Lemmas.fst(200,2-203,40)
              (= @x4 (Prims.pow2 @x2)))
             ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(200,2-200,15)
             (forall ((@x5 Term))
              (! (implies
                (and
                 (HasType @x5 Prims.unit)
                 ;; def=FStar.Math.Lemmas.fsti(170,47-170,72); use=FStar.Math.Lemmas.fst(200,2-200,15)
                 (=
                  @x0
                  (Prims.op_Addition
                   (Prims.op_Multiply (Prims.pow2 @x2) (Prims.op_Division @x0 (Prims.pow2 @x2)))
                   (Prims.op_Modulus @x0 (Prims.pow2 @x2)))))
                ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(200,2-203,40)
                (and
                 (implies
                  ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(201,27-201,33)
                  (> (BoxInt_proj_0 (Prims.pow2 @x2)) (BoxInt_proj_0 (BoxInt 0)))
                  ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(201,27-201,33)
                  (or
                   label_4
                   ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(201,27-201,33)
                   (not (= (Prims.pow2 @x2) (BoxInt 0)))))
                 ;; def=Prims.fst(364,2-364,58); use=FStar.Math.Lemmas.fst(200,2-203,40)
                 (forall ((@x6 Term))
                  (! (implies
                    (and
                     (HasType @x6 Prims.nonzero)
                     ;; def=Prims.fst(364,26-364,41); use=FStar.Math.Lemmas.fst(200,2-203,40)
                     (= @x6 (Prims.pow2 @x2)))
                    ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(200,2-203,40)
                    (forall ((@x7 Term))
                     (! (implies
                       (and
                        (HasType @x7 Prims.int)
                        ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(200,2-203,40)
                        (= (Prims.op_Division @x0 (Prims.pow2 @x2)) @x7))
                       ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(200,2-203,40)
                       (forall ((@x8 Term))
                        (! (implies
                          (and
                           (HasType @x8 Prims.int)
                           ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(200,2-203,40)
                           (=
                            (Prims.op_Multiply
                             (Prims.pow2 @x2)
                             (Prims.op_Division @x0 (Prims.pow2 @x2)))
                            @x8))
                          ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(200,2-203,40)
                          (and
                           (implies
                            ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(201,41-201,47)
                            (> (BoxInt_proj_0 (Prims.pow2 @x2)) (BoxInt_proj_0 (BoxInt 0)))
                            ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(201,41-201,47)
                            (or
                             label_5
                             ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(201,41-201,47)
                             (not (= (Prims.pow2 @x2) (BoxInt 0)))))
                           ;; def=Prims.fst(364,2-364,58); use=FStar.Math.Lemmas.fst(200,2-203,40)
                           (forall ((@x9 Term))
                            (! (implies
                              (and
                               (HasType @x9 Prims.nonzero)
                               ;; def=Prims.fst(364,26-364,41); use=FStar.Math.Lemmas.fst(200,2-203,40)
                               (= @x9 (Prims.pow2 @x2)))
                              ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(200,2-203,40)
                              (forall ((@x10 Term))
                               (! (implies
                                 (and
                                  (HasType @x10 Prims.int)
                                  ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(200,2-203,40)
                                  (= (Prims.op_Modulus @x0 (Prims.pow2 @x2)) @x10))
                                 ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(200,2-203,40)
                                 (forall ((@x11 Term))
                                  (! (implies
                                    (and
                                     (HasType @x11 Prims.int)
                                     ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(200,2-203,40)
                                     (=
                                      (Prims.op_Addition
                                       (Prims.op_Multiply
                                        (Prims.pow2 @x2)
                                        (Prims.op_Division @x0 (Prims.pow2 @x2)))
                                       (Prims.op_Modulus @x0 (Prims.pow2 @x2)))
                                      @x11))
                                    ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(200,2-203,40)
                                    (forall ((@x12 Term))
                                     (! (implies
                                       (and
                                        (HasType @x12 Prims.bool)
                                        ;; def=Prims.fst(188,10-188,11); use=FStar.Math.Lemmas.fst(200,2-203,40)
                                        (=
                                         (Prims.op_Equality
                                          Prims.int
                                          @x0
                                          (Prims.op_Addition
                                           (Prims.op_Multiply
                                            (Prims.pow2 @x2)
                                            (Prims.op_Division @x0 (Prims.pow2 @x2)))
                                           (Prims.op_Modulus @x0 (Prims.pow2 @x2))))
                                         @x12))
                                       ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(200,2-203,40)
                                       (forall ((@x13 Term))
                                        (! (implies
                                          (and
                                           (HasType @x13 Prims.logical)
                                           ;; def=Prims.fst(674,13-674,14); use=FStar.Math.Lemmas.fst(200,2-203,40)
                                           (=
                                            (Prims.b2t
                                             (Prims.op_Equality
                                              Prims.int
                                              @x0
                                              (Prims.op_Addition
                                               (Prims.op_Multiply
                                                (Prims.pow2 @x2)
                                                (Prims.op_Division @x0 (Prims.pow2 @x2)))
                                               (Prims.op_Modulus @x0 (Prims.pow2 @x2)))))
                                            @x13))
                                          ;; def=Prims.fst(449,29-449,97); use=FStar.Math.Lemmas.fst(201,2-201,8)
                                          (and
                                           ;; def=FStar.Math.Lemmas.fst(201,8-201,48); use=FStar.Math.Lemmas.fst(201,2-201,8)
                                           (or
                                            label_6
                                            ;; def=FStar.Math.Lemmas.fst(201,8-201,48); use=FStar.Math.Lemmas.fst(201,2-201,8)
                                            (=
                                             @x0
                                             (Prims.op_Addition
                                              (Prims.op_Multiply
                                               (Prims.pow2 @x2)
                                               (Prims.op_Division @x0 (Prims.pow2 @x2)))
                                              (Prims.op_Modulus @x0 (Prims.pow2 @x2)))))
                                           ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(201,2-201,8)
                                           (forall ((@x14 Term))
                                            (! (implies
                                              (and
                                               (HasType @x14 Prims.unit)
                                               ;; def=FStar.Math.Lemmas.fst(201,8-201,48); use=FStar.Math.Lemmas.fst(201,2-201,8)
                                               (=
                                                @x0
                                                (Prims.op_Addition
                                                 (Prims.op_Multiply
                                                  (Prims.pow2 @x2)
                                                  (Prims.op_Division @x0 (Prims.pow2 @x2)))
                                                 (Prims.op_Modulus @x0 (Prims.pow2 @x2)))))
                                              ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(200,2-203,40)
                                              (and
                                               ;; def=Prims.fst(682,18-682,24); use=FStar.Math.Lemmas.fst(202,14-202,19)
                                               (or
                                                label_7
                                                ;; def=Prims.fst(682,18-682,24); use=FStar.Math.Lemmas.fst(202,14-202,19)
                                                (>=
                                                 (BoxInt_proj_0 (Prims.op_Subtraction @x1 @x2))
                                                 (BoxInt_proj_0 (BoxInt 0))))
                                               ;; def=Prims.fst(364,2-364,58); use=FStar.Math.Lemmas.fst(200,2-203,40)
                                               (forall ((@x15 Term))
                                                (! (implies
                                                  (and
                                                   (HasType @x15 Prims.nat)
                                                   ;; def=Prims.fst(364,26-364,41); use=FStar.Math.Lemmas.fst(200,2-203,40)
                                                   (= @x15 (Prims.op_Subtraction @x1 @x2)))
                                                  ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(202,2-202,11)
                                                  (forall ((@x16 Term))
                                                   (! (implies
                                                     (and
                                                      (HasType @x16 Prims.unit)
                                                      ;; def=FStar.Math.Lemmas.fsti(156,11-156,43); use=FStar.Math.Lemmas.fst(202,2-202,11)
                                                      (=
                                                       (Prims.op_Multiply
                                                        (Prims.pow2 @x2)
                                                        (Prims.pow2 (Prims.op_Subtraction @x1 @x2)))
                                                       (Prims.pow2
                                                        (Prims.op_Addition
                                                         @x2
                                                         (Prims.op_Subtraction @x1 @x2)))))
                                                     ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(200,2-203,40)
                                                     (and
                                                      ;; def=Prims.fst(682,18-682,24); use=FStar.Math.Lemmas.fst(203,32-203,39)
                                                      (or
                                                       label_8
                                                       ;; def=Prims.fst(682,18-682,24); use=FStar.Math.Lemmas.fst(203,32-203,39)
                                                       (>=
                                                        (BoxInt_proj_0
                                                         (Prims.op_Subtraction @x1 @x2))
                                                        (BoxInt_proj_0 (BoxInt 0))))
                                                      ;; def=Prims.fst(364,2-364,58); use=FStar.Math.Lemmas.fst(200,2-203,40)
                                                      (forall ((@x17 Term))
                                                       (! (implies
                                                         (and
                                                          (HasType @x17 Prims.nat)
                                                          ;; def=Prims.fst(364,26-364,41); use=FStar.Math.Lemmas.fst(200,2-203,40)
                                                          (= @x17 (Prims.op_Subtraction @x1 @x2)))
                                                         ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(200,2-203,40)
                                                         (forall ((@x18 Term))
                                                          (! (implies
                                                            (and
                                                             (HasType @x18 Prims.pos)
                                                             ;; def=Prims.fst(710,28-710,31); use=FStar.Math.Lemmas.fst(203,27-203,39)
                                                             (=
                                                              (Prims.pow2
                                                               (Prims.op_Subtraction @x1 @x2))
                                                              @x18))
                                                            ;; def=Prims.fst(364,2-364,58); use=FStar.Math.Lemmas.fst(200,2-203,40)
                                                            (forall ((@x19 Term))
                                                             (! (implies
                                                               (and
                                                                (HasType @x19 Prims.pos)
                                                                ;; def=Prims.fst(364,26-364,41); use=FStar.Math.Lemmas.fst(200,2-203,40)
                                                                (=
                                                                 @x19
                                                                 (Prims.pow2
                                                                  (Prims.op_Subtraction @x1 @x2)))
                                                                ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(200,2-203,40)
                                                                (=
                                                                 (Prims.pow2
                                                                  (Prims.op_Subtraction @x1 @x2))
                                                                 @x19))
                                                               ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(200,2-203,40)
                                                               (forall ((@x20 Term))
                                                                (! (implies
                                                                  (and
                                                                   (HasType @x20 Prims.int)
                                                                   ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(200,2-203,40)
                                                                   (=
                                                                    (Prims.op_Multiply
                                                                     (Prims.pow2 @x2)
                                                                     (Prims.pow2
                                                                      (Prims.op_Subtraction @x1 @x2)))
                                                                    @x20))
                                                                  ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(200,2-203,40)
                                                                  (forall ((@x21 Term))
                                                                   (! (implies
                                                                     (and
                                                                      (HasType @x21 Prims.bool)
                                                                      ;; def=Prims.fst(188,10-188,11); use=FStar.Math.Lemmas.fst(200,2-203,40)
                                                                      (=
                                                                       (Prims.op_Equality
                                                                        Prims.int
                                                                        (Prims.pow2 @x1)
                                                                        (Prims.op_Multiply
                                                                         (Prims.pow2 @x2)
                                                                         (Prims.pow2
                                                                          (Prims.op_Subtraction
                                                                           @x1
                                                                           @x2))))
                                                                       @x21))
                                                                     ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(200,2-203,40)
                                                                     (forall ((@x22 Term))
                                                                      (! (implies
                                                                        (and
                                                                         (HasType @x22 Prims.logical)
                                                                         ;; def=Prims.fst(674,13-674,14); use=FStar.Math.Lemmas.fst(200,2-203,40)
                                                                         (=
                                                                          (Prims.b2t
                                                                           (Prims.op_Equality
                                                                            Prims.int
                                                                            (Prims.pow2 @x1)
                                                                            (Prims.op_Multiply
                                                                             (Prims.pow2 @x2)
                                                                             (Prims.pow2
                                                                              (Prims.op_Subtraction
                                                                               @x1
                                                                               @x2)))))
                                                                          @x22))
                                                                        ;; def=Prims.fst(449,29-449,97); use=FStar.Math.Lemmas.fst(203,2-203,8)
                                                                        (and
                                                                         ;; def=FStar.Math.Lemmas.fst(203,8-203,40); use=FStar.Math.Lemmas.fst(203,2-203,8)
                                                                         (or
                                                                          label_9
                                                                          ;; def=FStar.Math.Lemmas.fst(203,8-203,40); use=FStar.Math.Lemmas.fst(203,2-203,8)
                                                                          (=
                                                                           (Prims.pow2 @x1)
                                                                           (Prims.op_Multiply
                                                                            (Prims.pow2 @x2)
                                                                            (Prims.pow2
                                                                             (Prims.op_Subtraction
                                                                              @x1
                                                                              @x2)))))
                                                                         ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(203,2-203,8)
                                                                         (forall ((@x23 Term))
                                                                          (! (implies
                                                                            (and
                                                                             (HasType
                                                                              @x23
                                                                              Prims.unit)
                                                                             ;; def=FStar.Math.Lemmas.fst(203,8-203,40); use=FStar.Math.Lemmas.fst(203,2-203,8)
                                                                             (=
                                                                              (Prims.pow2 @x1)
                                                                              (Prims.op_Multiply
                                                                               (Prims.pow2 @x2)
                                                                               (Prims.pow2
                                                                                (Prims.op_Subtraction
                                                                                 @x1
                                                                                 @x2)))))
                                                                            ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(203,2-203,8)
                                                                            (Valid
                                                                             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(203,2-203,8)
                                                                             (ApplyTT @x3 @x23)))
                                                                           :qid @query.22))))
                                                                       :qid @query.21)))
                                                                    :qid @query.20)))
                                                                 :qid @query.19)))
                                                              :qid @query.18)))
                                                           :qid @query.17)))
                                                        :qid @query.16))))
                                                    :qid @query.15)))
                                                 :qid @query.14))))
                                             :qid @query.13))))
                                         :qid @query.12)))
                                      :qid @query.11)))
                                   :qid @query.10)))
                                :qid @query.9)))
                             :qid @query.8))))
                         :qid @query.7)))
                      :qid @query.6)))
                   :qid @query.5))))
               :qid @query.4)))
            :qid @query.3))))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_9")
(eval label_9)
(echo "label_8")
(eval label_8)
(echo "label_7")
(eval label_7)
(echo "label_6")
(eval label_6)
(echo "label_5")
(eval label_5)
(echo "label_4")
(eval label_4)
(echo "label_3")
(eval label_3)
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.lemma_div_lt_nat, 2)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let lemma_div_lt_nat
; <Start encoding let lemma_div_lt_nat>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.lemma_div_lt_nat (Term Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.lemma_div_lt_nat@tok () Term)
; </end encoding let lemma_div_lt_nat>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fsti(178,0-180,35)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
(declare-fun Tm_refine_ef2e09dbb34375eb604aeb2ad341efb2 (Term Term Term) Term)
; refinement kinding
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fsti(179,12-179,32); use=FStar.Math.Lemmas.fsti(178,43-178,48)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term))
   (! (HasType (Tm_refine_ef2e09dbb34375eb604aeb2ad341efb2 @x0 @x1 @x2) Tm_type)
    :pattern ((HasType (Tm_refine_ef2e09dbb34375eb604aeb2ad341efb2 @x0 @x1 @x2) Tm_type))
    :qid refinement_kinding_Tm_refine_ef2e09dbb34375eb604aeb2ad341efb2))
  :named refinement_kinding_Tm_refine_ef2e09dbb34375eb604aeb2ad341efb2))
; refinement_interpretation
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fsti(179,12-179,32); use=FStar.Math.Lemmas.fsti(178,43-178,48)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
   (! (iff
     (HasTypeFuel @u0 @x1 (Tm_refine_ef2e09dbb34375eb604aeb2ad341efb2 @x2 @x3 @x4))
     (and
      (HasTypeFuel @u0 @x1 Prims.unit)
      ;; def=FStar.Math.Lemmas.fsti(179,12-179,18); use=FStar.Math.Lemmas.fsti(178,43-178,48)
      (<= (BoxInt_proj_0 @x2) (BoxInt_proj_0 @x3))
      ;; def=FStar.Math.Lemmas.fsti(179,22-179,32); use=FStar.Math.Lemmas.fsti(178,43-178,48)
      (< (BoxInt_proj_0 @x4) (BoxInt_proj_0 (Prims.pow2 @x3)))))
    :pattern ((HasTypeFuel @u0 @x1 (Tm_refine_ef2e09dbb34375eb604aeb2ad341efb2 @x2 @x3 @x4)))
    :qid refinement_interpretation_Tm_refine_ef2e09dbb34375eb604aeb2ad341efb2))
  :named refinement_interpretation_Tm_refine_ef2e09dbb34375eb604aeb2ad341efb2))
; haseq for Tm_refine_ef2e09dbb34375eb604aeb2ad341efb2
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fsti(179,12-179,32); use=FStar.Math.Lemmas.fsti(178,43-178,48)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term))
   (! (iff
     (Valid (Prims.hasEq (Tm_refine_ef2e09dbb34375eb604aeb2ad341efb2 @x0 @x1 @x2)))
     (Valid (Prims.hasEq Prims.unit)))
    :pattern ((Valid (Prims.hasEq (Tm_refine_ef2e09dbb34375eb604aeb2ad341efb2 @x0 @x1 @x2))))
    :qid haseqTm_refine_ef2e09dbb34375eb604aeb2ad341efb2))
  :named haseqTm_refine_ef2e09dbb34375eb604aeb2ad341efb2))
; Encoding query formula : forall (a: Prims.int) (n: Prims.nat) (m: Prims.nat) (_: Prims.squash (m <= n /\ a < Prims.pow2 n)).
;   (*  - Could not prove post-condition
; *)
;   (Prims.pow2 m > 0 ==> Prims.pow2 m <> 0) /\
;   (forall (return_val: Prims.nonzero).
;       return_val == Prims.pow2 m ==>
;       (forall (any_result: Prims.int). a / Prims.pow2 m == any_result ==> n - m >= 0))
; Context: While encoding a query
; While typechecking the top-level declaration `val FStar.Math.Lemmas.lemma_div_lt`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fsti(178,0-180,35)
   (forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
    (! (implies
      (and
       (HasType @x0 Prims.int)
       (HasType @x1 Prims.nat)
       (HasType @x2 Prims.nat)
       (HasType @x3 (Tm_refine_ef2e09dbb34375eb604aeb2ad341efb2 @x2 @x1 @x0)))
      ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fsti(180,11-180,34)
      (and
       (implies
        ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fsti(180,15-180,21)
        (> (BoxInt_proj_0 (Prims.pow2 @x2)) (BoxInt_proj_0 (BoxInt 0)))
        ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fsti(180,15-180,21)
        (or
         label_1
         ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fsti(180,15-180,21)
         (not (= (Prims.pow2 @x2) (BoxInt 0)))))
       ;; def=Prims.fst(364,2-364,58); use=FStar.Math.Lemmas.fsti(180,11-180,34)
       (forall ((@x4 Term))
        (! (implies
          (and
           (HasType @x4 Prims.nonzero)
           ;; def=Prims.fst(364,26-364,41); use=FStar.Math.Lemmas.fsti(180,11-180,34)
           (= @x4 (Prims.pow2 @x2)))
          ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fsti(180,11-180,34)
          (forall ((@x5 Term))
           (! (implies
             (and
              (HasType @x5 Prims.int)
              ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fsti(180,11-180,34)
              (= (Prims.op_Division @x0 (Prims.pow2 @x2)) @x5))
             ;; def=Prims.fst(682,18-682,24); use=FStar.Math.Lemmas.fsti(180,29-180,34)
             (or
              label_2
              ;; def=Prims.fst(682,18-682,24); use=FStar.Math.Lemmas.fsti(180,29-180,34)
              (>= (BoxInt_proj_0 (Prims.op_Subtraction @x1 @x2)) (BoxInt_proj_0 (BoxInt 0)))))
            :qid @query.2)))
         :qid @query.1))))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.lemma_div_lt, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt val FStar.Math.Lemmas.lemma_div_lt
; <Skipped val FStar.Math.Lemmas.lemma_div_lt/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(206,2-206,39)
(declare-fun label_4 () Bool)
(declare-fun label_3 () Bool)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (a: Prims.int) (n: Prims.nat) (m: Prims.nat).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     m <= n /\ a < Prims.pow2 n /\
;     (forall (pure_result: Prims.unit). a / Prims.pow2 m < Prims.pow2 (n - m) ==> p pure_result) ==>
;     (forall (k: Prims.pure_post Prims.unit).
;         (forall (x: Prims.unit). {:pattern Prims.guard_free (k x)} p x ==> k x) ==>
;         (a >= 0 == true ==>
;           m <= n /\
;           (forall (any_result: Prims.nat).
;               m == any_result ==>
;               a < Prims.pow2 n /\
;               (forall (pure_result: Prims.unit).
;                   a / Prims.pow2 m < Prims.pow2 (n - m) ==> k pure_result))) /\
;         (~(a >= 0 = true) ==>
;           (forall (b: Prims.bool). a >= 0 == b ==> (forall (any_result: Prims.unit). k any_result)))
;     )
; Context: While encoding a query
; While typechecking the top-level declaration `let lemma_div_lt`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term) (@x2 Term))
    (! (implies
      (and (HasType @x0 Prims.int) (HasType @x1 Prims.nat) (HasType @x2 Prims.nat))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x3 Term))
       (! (implies
         (and
          (HasType @x3 (Prims.pure_post Prims.unit))
          ;; def=FStar.Math.Lemmas.fsti(179,12-179,18); use=FStar.Math.Lemmas.fst(206,2-206,39)
          (<= (BoxInt_proj_0 @x2) (BoxInt_proj_0 @x1))
          ;; def=FStar.Math.Lemmas.fsti(179,22-179,32); use=FStar.Math.Lemmas.fst(206,2-206,39)
          (< (BoxInt_proj_0 @x0) (BoxInt_proj_0 (Prims.pow2 @x1)))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(206,2-206,39)
          (forall ((@x4 Term))
           (! (implies
             (and
              (or label_1 (HasType @x4 Prims.unit))
              ;; def=FStar.Math.Lemmas.fsti(180,11-180,34); use=FStar.Math.Lemmas.fst(206,2-206,39)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fsti(180,11-180,34); use=FStar.Math.Lemmas.fst(206,2-206,39)
               (<
                (BoxInt_proj_0 (Prims.op_Division @x0 (Prims.pow2 @x2)))
                (BoxInt_proj_0 (Prims.pow2 (Prims.op_Subtraction @x1 @x2))))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(206,2-206,39)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(206,2-206,39)
              (ApplyTT @x3 @x4)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(206,2-206,39)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(206,2-206,39)
               (ApplyTT @x3 @x4)))
            :qid @query.2)))
         ;; def=Prims.fst(410,2-410,97); use=FStar.Math.Lemmas.fst(206,2-206,39)
         (forall ((@x4 Term))
          (! (implies
            (and
             (HasType @x4 (Prims.pure_post Prims.unit))
             ;; def=Prims.fst(410,2-410,97); use=FStar.Math.Lemmas.fst(206,2-206,39)
             (forall ((@x5 Term))
              (! (implies
                ;; def=Prims.fst(410,73-410,79); use=FStar.Math.Lemmas.fst(206,2-206,39)
                (Valid
                 ;; def=Prims.fst(410,73-410,79); use=FStar.Math.Lemmas.fst(206,2-206,39)
                 (ApplyTT @x3 @x5))
                ;; def=Prims.fst(410,84-410,87); use=FStar.Math.Lemmas.fst(206,2-206,39)
                (Valid
                 ;; def=Prims.fst(410,84-410,87); use=FStar.Math.Lemmas.fst(206,2-206,39)
                 (ApplyTT @x4 @x5)))
               :weight 0
               :pattern ((ApplyTT @x4 @x5))
               :qid @query.4)))
            ;; def=Prims.fst(397,2-397,39); use=FStar.Math.Lemmas.fst(206,2-206,39)
            (and
             (implies
              ;; def=FStar.Math.Lemmas.fst(206,5-206,11); use=FStar.Math.Lemmas.fst(206,5-206,11)
              (= (Prims.op_GreaterThanOrEqual @x0 (BoxInt 0)) (BoxBool true))
              ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(206,2-206,39)
              (and
               ;; def=FStar.Math.Lemmas.fsti(174,46-174,52); use=FStar.Math.Lemmas.fst(206,38-206,39)
               (or
                label_3
                ;; def=FStar.Math.Lemmas.fsti(174,46-174,52); use=FStar.Math.Lemmas.fst(206,38-206,39)
                (<= (BoxInt_proj_0 @x2) (BoxInt_proj_0 @x1)))
               ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(206,2-206,39)
               (forall ((@x5 Term))
                (! (implies
                  (and
                   (HasType @x5 Prims.nat)
                   ;; def=FStar.Math.Lemmas.fsti(174,40-174,41); use=FStar.Math.Lemmas.fst(206,2-206,39)
                   (= @x2 @x5))
                  ;; def=Prims.fst(449,29-449,97); use=FStar.Math.Lemmas.fst(206,17-206,33)
                  (and
                   ;; def=FStar.Math.Lemmas.fsti(175,18-175,30); use=FStar.Math.Lemmas.fst(206,17-206,33)
                   (or
                    label_4
                    ;; def=FStar.Math.Lemmas.fsti(175,18-175,30); use=FStar.Math.Lemmas.fst(206,17-206,33)
                    (< (BoxInt_proj_0 @x0) (BoxInt_proj_0 (Prims.pow2 @x1))))
                   ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(206,17-206,33)
                   (forall ((@x6 Term))
                    (! (implies
                      (and
                       (HasType @x6 Prims.unit)
                       ;; def=FStar.Math.Lemmas.fsti(176,18-176,43); use=FStar.Math.Lemmas.fst(206,17-206,33)
                       (<
                        (BoxInt_proj_0 (Prims.op_Division @x0 (Prims.pow2 @x2)))
                        (BoxInt_proj_0 (Prims.pow2 (Prims.op_Subtraction @x1 @x2)))))
                      ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(206,17-206,33)
                      (Valid
                       ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(206,17-206,33)
                       (ApplyTT @x4 @x6)))
                     :qid @query.6))))
                 :qid @query.5))))
             (implies
              ;; def=Prims.fst(397,19-397,21); use=FStar.Math.Lemmas.fst(206,2-206,39)
              (not
               ;; def=FStar.Math.Lemmas.fst(206,5-206,11); use=FStar.Math.Lemmas.fst(206,5-206,11)
               (= (Prims.op_GreaterThanOrEqual @x0 (BoxInt 0)) (BoxBool true)))
              ;; def=Prims.fst(421,99-421,120); use=FStar.Math.Lemmas.fst(206,2-206,39)
              (forall ((@x5 Term))
               (! (implies
                 (and
                  (HasType @x5 Prims.bool)
                  ;; def=FStar.Math.Lemmas.fst(206,2-206,39); use=FStar.Math.Lemmas.fst(206,2-206,39)
                  (= (Prims.op_GreaterThanOrEqual @x0 (BoxInt 0)) @x5))
                 ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(206,2-206,39)
                 (forall ((@x6 Term))
                  (! (implies
                    (HasType @x6 Prims.unit)
                    ;; def=Prims.fst(459,90-459,102); use=FStar.Math.Lemmas.fst(206,2-206,39)
                    (Valid
                     ;; def=Prims.fst(459,90-459,102); use=FStar.Math.Lemmas.fst(206,2-206,39)
                     (ApplyTT @x4 @x6)))
                   :qid @query.8)))
                :qid @query.7)))))
           :qid @query.3)))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_4")
(eval label_4)
(echo "label_3")
(eval label_3)
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.lemma_div_lt, 2)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let lemma_div_lt
; <Start encoding let lemma_div_lt>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.lemma_div_lt (Term Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.lemma_div_lt@tok () Term)
; </end encoding let lemma_div_lt>

; encoding sigelt val FStar.Math.Lemmas.bounded_multiple_is_zero
; <Skipped val FStar.Math.Lemmas.bounded_multiple_is_zero/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(208,47-208,49)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (x: Prims.int) (n: Prims.pos).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     - n < x * n /\ x * n < n /\ (forall (pure_result: Prims.unit). x == 0 ==> p pure_result) ==>
;     (forall (any_result: Prims.unit). p any_result)
; Context: While encoding a query
; While typechecking the top-level declaration `let bounded_multiple_is_zero`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term))
    (! (implies
      (and (HasType @x0 Prims.int) (HasType @x1 Prims.pos))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x2 Term))
       (! (implies
         (and
          (HasType @x2 (Prims.pure_post Prims.unit))
          ;; def=FStar.Math.Lemmas.fsti(183,12-183,22); use=FStar.Math.Lemmas.fst(208,47-208,49)
          (< (BoxInt_proj_0 (Prims.op_Minus @x1)) (BoxInt_proj_0 (Prims.op_Multiply @x0 @x1)))
          ;; def=FStar.Math.Lemmas.fsti(183,26-183,35); use=FStar.Math.Lemmas.fst(208,47-208,49)
          (< (BoxInt_proj_0 (Prims.op_Multiply @x0 @x1)) (BoxInt_proj_0 @x1))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(208,47-208,49)
          (forall ((@x3 Term))
           (! (implies
             (and
              (or label_1 (HasType @x3 Prims.unit))
              ;; def=FStar.Math.Lemmas.fsti(184,11-184,17); use=FStar.Math.Lemmas.fst(208,47-208,49)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fsti(184,11-184,17); use=FStar.Math.Lemmas.fst(208,47-208,49)
               (= @x0 (BoxInt 0))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(208,47-208,49)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(208,47-208,49)
              (ApplyTT @x2 @x3)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(208,47-208,49)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(208,47-208,49)
               (ApplyTT @x2 @x3)))
            :qid @query.2)))
         ;; def=Prims.fst(459,66-459,102); use=Prims.fst(462,31-462,44)
         (forall ((@x3 Term))
          (! (implies
            (HasType @x3 Prims.unit)
            ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
            (Valid
             ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
             (ApplyTT @x2 @x3)))
           :qid @query.3)))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.bounded_multiple_is_zero, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let bounded_multiple_is_zero
; <Start encoding let bounded_multiple_is_zero>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.bounded_multiple_is_zero (Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.bounded_multiple_is_zero@tok () Term)
; </end encoding let bounded_multiple_is_zero>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fsti(186,0-186,75)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (a: Prims.nat) (n: Prims.pos) (_: Prims.squash (a < n)).
;   (*  - Could not prove post-condition
; *) n > 0 ==> n <> 0
; Context: While encoding a query
; While typechecking the top-level declaration `val FStar.Math.Lemmas.small_div`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fsti(186,0-186,75)
   (forall ((@x0 Term) (@x1 Term) (@x2 Term))
    (! (implies
      (and
       (HasType @x0 Prims.nat)
       (HasType @x1 Prims.pos)
       (HasType @x2 (Prims.squash (Prims.b2t (Prims.op_LessThan @x0 @x1))))
       ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fsti(186,68-186,69)
       (> (BoxInt_proj_0 @x1) (BoxInt_proj_0 (BoxInt 0))))
      ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fsti(186,68-186,69)
      (or
       label_1
       ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fsti(186,68-186,69)
       (not (= @x1 (BoxInt 0)))))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.small_div, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt val FStar.Math.Lemmas.small_div
; <Skipped val FStar.Math.Lemmas.small_div/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(210,78-210,80)
(declare-fun label_3 () Bool)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (a: Prims.nat) (n: Prims.pos).
;   (forall (_: Prims.squash (a < n)). (*  - Could not prove post-condition
; *) n > 0 ==> n <> 0) /\
;   (forall (p: Prims.pure_post Prims.unit).
;       a < n /\ (forall (pure_result: Prims.unit). a / n == 0 ==> p pure_result) ==>
;       (forall (any_result: Prims.unit). p any_result))
; Context: While encoding a query
; While typechecking the top-level declaration `let small_div`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term))
    (! (implies
      (and (HasType @x0 Prims.nat) (HasType @x1 Prims.pos))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (and
       ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(210,78-210,80)
       (forall ((@x2 Term))
        (! (implies
          (and
           (HasType @x2 (Prims.squash (Prims.b2t (Prims.op_LessThan @x0 @x1))))
           ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(210,78-210,80)
           (> (BoxInt_proj_0 @x1) (BoxInt_proj_0 (BoxInt 0))))
          ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(210,68-210,69)
          (or
           label_1
           ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(210,78-210,80)
           (not (= @x1 (BoxInt 0)))))
         :qid @query.1))
       ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
       (forall ((@x2 Term))
        (! (implies
          (and
           (HasType @x2 (Prims.pure_post Prims.unit))
           ;; def=FStar.Math.Lemmas.fst(210,48-210,53); use=FStar.Math.Lemmas.fst(210,78-210,80)
           (< (BoxInt_proj_0 @x0) (BoxInt_proj_0 @x1))
           ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(210,78-210,80)
           (forall ((@x3 Term))
            (! (implies
              (and
               (or label_2 (HasType @x3 Prims.unit))
               ;; def=FStar.Math.Lemmas.fst(210,64-210,74); use=FStar.Math.Lemmas.fst(210,78-210,80)
               (or
                label_3
                ;; def=FStar.Math.Lemmas.fst(210,64-210,74); use=FStar.Math.Lemmas.fst(210,78-210,80)
                (= (Prims.op_Division @x0 @x1) (BoxInt 0))))
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(210,78-210,80)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(210,78-210,80)
               (ApplyTT @x2 @x3)))
             :pattern
              (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(210,78-210,80)
               (Valid
                ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(210,78-210,80)
                (ApplyTT @x2 @x3)))
             :qid @query.3)))
          ;; def=Prims.fst(459,66-459,102); use=Prims.fst(462,31-462,44)
          (forall ((@x3 Term))
           (! (implies
             (HasType @x3 Prims.unit)
             ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
             (Valid
              ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
              (ApplyTT @x2 @x3)))
            :qid @query.4)))
         :qid @query.2))))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_3")
(eval label_3)
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.small_div, 2)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let small_div
; <Start encoding let small_div>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.small_div (Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.small_div@tok () Term)
; </end encoding let small_div>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fsti(188,0-188,75)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (a: Prims.nat) (n: Prims.pos) (_: Prims.squash (a < n)).
;   (*  - Could not prove post-condition
; *) n > 0 ==> n <> 0
; Context: While encoding a query
; While typechecking the top-level declaration `val FStar.Math.Lemmas.small_mod`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fsti(188,0-188,75)
   (forall ((@x0 Term) (@x1 Term) (@x2 Term))
    (! (implies
      (and
       (HasType @x0 Prims.nat)
       (HasType @x1 Prims.pos)
       (HasType @x2 (Prims.squash (Prims.b2t (Prims.op_LessThan @x0 @x1))))
       ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fsti(188,68-188,69)
       (> (BoxInt_proj_0 @x1) (BoxInt_proj_0 (BoxInt 0))))
      ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fsti(188,68-188,69)
      (or
       label_1
       ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fsti(188,68-188,69)
       (not (= @x1 (BoxInt 0)))))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.small_mod, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt val FStar.Math.Lemmas.small_mod
; <Skipped val FStar.Math.Lemmas.small_mod/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(212,78-212,80)
(declare-fun label_3 () Bool)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (a: Prims.nat) (n: Prims.pos).
;   (forall (_: Prims.squash (a < n)). (*  - Could not prove post-condition
; *) n > 0 ==> n <> 0) /\
;   (forall (p: Prims.pure_post Prims.unit).
;       a < n /\ (forall (pure_result: Prims.unit). a % n == a ==> p pure_result) ==>
;       (forall (any_result: Prims.unit). p any_result))
; Context: While encoding a query
; While typechecking the top-level declaration `let small_mod`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term))
    (! (implies
      (and (HasType @x0 Prims.nat) (HasType @x1 Prims.pos))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (and
       ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(212,78-212,80)
       (forall ((@x2 Term))
        (! (implies
          (and
           (HasType @x2 (Prims.squash (Prims.b2t (Prims.op_LessThan @x0 @x1))))
           ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(212,78-212,80)
           (> (BoxInt_proj_0 @x1) (BoxInt_proj_0 (BoxInt 0))))
          ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(212,68-212,69)
          (or
           label_1
           ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(212,78-212,80)
           (not (= @x1 (BoxInt 0)))))
         :qid @query.1))
       ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
       (forall ((@x2 Term))
        (! (implies
          (and
           (HasType @x2 (Prims.pure_post Prims.unit))
           ;; def=FStar.Math.Lemmas.fst(212,48-212,53); use=FStar.Math.Lemmas.fst(212,78-212,80)
           (< (BoxInt_proj_0 @x0) (BoxInt_proj_0 @x1))
           ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(212,78-212,80)
           (forall ((@x3 Term))
            (! (implies
              (and
               (or label_2 (HasType @x3 Prims.unit))
               ;; def=FStar.Math.Lemmas.fst(212,64-212,74); use=FStar.Math.Lemmas.fst(212,78-212,80)
               (or
                label_3
                ;; def=FStar.Math.Lemmas.fst(212,64-212,74); use=FStar.Math.Lemmas.fst(212,78-212,80)
                (= (Prims.op_Modulus @x0 @x1) @x0)))
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(212,78-212,80)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(212,78-212,80)
               (ApplyTT @x2 @x3)))
             :pattern
              (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(212,78-212,80)
               (Valid
                ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(212,78-212,80)
                (ApplyTT @x2 @x3)))
             :qid @query.3)))
          ;; def=Prims.fst(459,66-459,102); use=Prims.fst(462,31-462,44)
          (forall ((@x3 Term))
           (! (implies
             (HasType @x3 Prims.unit)
             ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
             (Valid
              ;; def=Prims.fst(459,90-459,102); use=Prims.fst(462,31-462,44)
              (ApplyTT @x2 @x3)))
            :qid @query.4)))
         :qid @query.2))))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_3")
(eval label_3)
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.small_mod, 2)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let small_mod
; <Start encoding let small_mod>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.small_mod (Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.small_mod@tok () Term)
; </end encoding let small_mod>

; encoding sigelt val FStar.Math.Lemmas.lt_multiple_is_equal
; <Skipped val FStar.Math.Lemmas.lt_multiple_is_equal/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(215,2-216,30)
(declare-fun label_7 () Bool)
(declare-fun label_6 () Bool)
(declare-fun label_5 () Bool)
(declare-fun label_4 () Bool)
(declare-fun label_3 () Bool)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; Encoding query formula : forall (a: Prims.nat) (b: Prims.nat) (x: Prims.int) (n: Prims.nonzero).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     a < n /\ b < n /\ a == b + x * n /\
;     (forall (pure_result: Prims.unit). a == b /\ x == 0 ==> p pure_result) ==>
;     0 * n == 0 /\
;     (forall (pure_result: Prims.unit).
;         0 * n == 0 ==>
;         (n <> 0 ==> n > 0) /\
;         (forall (any_result: Prims.nonzero).
;             n == any_result ==>
;             - n < x * n /\ x * n < n /\ (forall (pure_result: Prims.unit). x == 0 ==> p pure_result)
;         ))
; Context: While encoding a query
; While typechecking the top-level declaration `let lt_multiple_is_equal`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
    (! (implies
      (and
       (HasType @x0 Prims.nat)
       (HasType @x1 Prims.nat)
       (HasType @x2 Prims.int)
       (HasType @x3 Prims.nonzero))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x4 Term))
       (! (implies
         (and
          (HasType @x4 (Prims.pure_post Prims.unit))
          ;; def=FStar.Math.Lemmas.fsti(191,12-191,17); use=FStar.Math.Lemmas.fst(215,2-216,30)
          (< (BoxInt_proj_0 @x0) (BoxInt_proj_0 @x3))
          ;; def=FStar.Math.Lemmas.fsti(191,21-191,26); use=FStar.Math.Lemmas.fst(215,2-216,30)
          (< (BoxInt_proj_0 @x1) (BoxInt_proj_0 @x3))
          ;; def=FStar.Math.Lemmas.fsti(191,30-191,44); use=FStar.Math.Lemmas.fst(215,2-216,30)
          (= @x0 (Prims.op_Addition @x1 (Prims.op_Multiply @x2 @x3)))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(215,2-216,30)
          (forall ((@x5 Term))
           (! (implies
             (and
              (or label_1 (HasType @x5 Prims.unit))
              ;; def=FStar.Math.Lemmas.fsti(192,11-192,17); use=FStar.Math.Lemmas.fst(215,2-216,30)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fsti(192,11-192,17); use=FStar.Math.Lemmas.fst(215,2-216,30)
               (= @x0 @x1))
              ;; def=FStar.Math.Lemmas.fsti(192,21-192,27); use=FStar.Math.Lemmas.fst(215,2-216,30)
              (or
               label_3
               ;; def=FStar.Math.Lemmas.fsti(192,21-192,27); use=FStar.Math.Lemmas.fst(215,2-216,30)
               (= @x2 (BoxInt 0))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(215,2-216,30)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(215,2-216,30)
              (ApplyTT @x4 @x5)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(215,2-216,30)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(215,2-216,30)
               (ApplyTT @x4 @x5)))
            :qid @query.2)))
         ;; def=Prims.fst(449,29-449,97); use=FStar.Math.Lemmas.fst(215,2-215,8)
         (and
          ;; def=FStar.Math.Lemmas.fst(215,9-215,21); use=FStar.Math.Lemmas.fst(215,2-215,8)
          (or
           label_4
           ;; def=FStar.Math.Lemmas.fst(215,9-215,21); use=FStar.Math.Lemmas.fst(215,2-215,8)
           (= (Prims.op_Multiply (BoxInt 0) @x3) (BoxInt 0)))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(215,2-215,8)
          (forall ((@x5 Term))
           (! (implies
             (and
              (HasType @x5 Prims.unit)
              ;; def=FStar.Math.Lemmas.fst(215,9-215,21); use=FStar.Math.Lemmas.fst(215,2-215,8)
              (= (Prims.op_Multiply (BoxInt 0) @x3) (BoxInt 0)))
             ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(215,2-216,30)
             (and
              (implies
               ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(216,29-216,30)
               (not (= @x3 (BoxInt 0)))
               ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(216,29-216,30)
               (or
                label_5
                ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(216,29-216,30)
                (> (BoxInt_proj_0 @x3) (BoxInt_proj_0 (BoxInt 0)))))
              ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(215,2-216,30)
              (forall ((@x6 Term))
               (! (implies
                 (and
                  (HasType @x6 Prims.nonzero)
                  ;; def=FStar.Math.Lemmas.fsti(182,38-182,39); use=FStar.Math.Lemmas.fst(215,2-216,30)
                  (= @x3 @x6))
                 ;; def=Prims.fst(449,29-449,97); use=FStar.Math.Lemmas.fst(216,2-216,26)
                 (and
                  ;; def=FStar.Math.Lemmas.fsti(183,12-183,22); use=FStar.Math.Lemmas.fst(216,2-216,26)
                  (or
                   label_6
                   ;; def=FStar.Math.Lemmas.fsti(183,12-183,22); use=FStar.Math.Lemmas.fst(216,2-216,26)
                   (<
                    (BoxInt_proj_0 (Prims.op_Minus @x3))
                    (BoxInt_proj_0 (Prims.op_Multiply @x2 @x3))))
                  ;; def=FStar.Math.Lemmas.fsti(183,26-183,35); use=FStar.Math.Lemmas.fst(216,2-216,26)
                  (or
                   label_7
                   ;; def=FStar.Math.Lemmas.fsti(183,26-183,35); use=FStar.Math.Lemmas.fst(216,2-216,26)
                   (< (BoxInt_proj_0 (Prims.op_Multiply @x2 @x3)) (BoxInt_proj_0 @x3)))
                  ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(216,2-216,26)
                  (forall ((@x7 Term))
                   (! (implies
                     (and
                      (HasType @x7 Prims.unit)
                      ;; def=FStar.Math.Lemmas.fsti(184,11-184,17); use=FStar.Math.Lemmas.fst(216,2-216,26)
                      (= @x2 (BoxInt 0)))
                     ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(216,2-216,26)
                     (Valid
                      ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(216,2-216,26)
                      (ApplyTT @x4 @x7)))
                    :qid @query.5))))
                :qid @query.4))))
            :qid @query.3))))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_7")
(eval label_7)
(echo "label_6")
(eval label_6)
(echo "label_5")
(eval label_5)
(echo "label_4")
(eval label_4)
(echo "label_3")
(eval label_3)
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.lt_multiple_is_equal, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let lt_multiple_is_equal
; <Start encoding let lt_multiple_is_equal>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.lt_multiple_is_equal (Term Term Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.lt_multiple_is_equal@tok () Term)
; </end encoding let lt_multiple_is_equal>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fsti(194,0-194,76)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
(declare-fun Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9 () Term)
; refinement kinding
;;; Fact-ids: 
(assert
 (! (HasType Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9 Tm_type)
  :named refinement_kinding_Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
; refinement_interpretation
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fsti(194,45-194,76); use=FStar.Math.Lemmas.fsti(194,45-194,50)
  (forall ((@u0 Fuel) (@x1 Term))
   (! (iff
     (HasTypeFuel @u0 @x1 Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9)
     (HasTypeFuel @u0 @x1 Prims.unit))
    :pattern ((HasTypeFuel @u0 @x1 Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
    :qid refinement_interpretation_Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
  :named refinement_interpretation_Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
; haseq for Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9
;;; Fact-ids: 
(assert
 (! (iff
   (Valid (Prims.hasEq Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
   (Valid (Prims.hasEq Prims.unit)))
  :named haseqTm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
; Encoding query formula : forall (a: Prims.int) (k: Prims.int) (n: Prims.pos) (_: Prims.squash Prims.l_True).
;   (*  - Could not prove post-condition
; *)
;   (n > 0 ==> n <> 0) /\
;   (forall (any_result: Prims.pos).
;       n == any_result ==>
;       (forall (any_result: Prims.int). (a + k * n) % n == any_result ==> n > 0 ==> n <> 0))
; Context: While encoding a query
; While typechecking the top-level declaration `val FStar.Math.Lemmas.lemma_mod_plus`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fsti(194,0-194,76)
   (forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
    (! (implies
      (and
       (HasType @x0 Prims.int)
       (HasType @x1 Prims.int)
       (HasType @x2 Prims.pos)
       (HasType @x3 Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
      ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fsti(194,51-194,76)
      (and
       (implies
        ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fsti(194,66-194,67)
        (> (BoxInt_proj_0 @x2) (BoxInt_proj_0 (BoxInt 0)))
        ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fsti(194,66-194,67)
        (or
         label_1
         ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fsti(194,66-194,67)
         (not (= @x2 (BoxInt 0)))))
       ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fsti(194,51-194,76)
       (forall ((@x4 Term))
        (! (implies
          (and
           (HasType @x4 Prims.pos)
           ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fsti(194,51-194,76)
           (= @x2 @x4))
          ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fsti(194,51-194,76)
          (forall ((@x5 Term))
           (! (implies
             (and
              (HasType @x5 Prims.int)
              ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fsti(194,51-194,76)
              (= (Prims.op_Modulus (Prims.op_Addition @x0 (Prims.op_Multiply @x1 @x2)) @x2) @x5)
              ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fsti(194,74-194,75)
              (> (BoxInt_proj_0 @x2) (BoxInt_proj_0 (BoxInt 0))))
             ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fsti(194,74-194,75)
             (or
              label_2
              ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fsti(194,74-194,75)
              (not (= @x2 (BoxInt 0)))))
            :qid @query.2)))
         :qid @query.1))))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.lemma_mod_plus, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt val FStar.Math.Lemmas.lemma_mod_plus
; <Skipped val FStar.Math.Lemmas.lemma_mod_plus/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(219,2-230,4)
(declare-fun label_45 () Bool)
(declare-fun label_44 () Bool)
(declare-fun label_43 () Bool)
(declare-fun label_42 () Bool)
(declare-fun label_41 () Bool)
(declare-fun label_40 () Bool)
(declare-fun label_39 () Bool)
(declare-fun label_38 () Bool)
(declare-fun label_37 () Bool)
(declare-fun label_36 () Bool)
(declare-fun label_35 () Bool)
(declare-fun label_34 () Bool)
(declare-fun label_33 () Bool)
(declare-fun label_32 () Bool)
(declare-fun label_31 () Bool)
(declare-fun label_30 () Bool)
(declare-fun label_29 () Bool)
(declare-fun label_28 () Bool)
(declare-fun label_27 () Bool)
(declare-fun label_26 () Bool)
(declare-fun label_25 () Bool)
(declare-fun label_24 () Bool)
(declare-fun label_23 () Bool)
(declare-fun label_22 () Bool)
(declare-fun label_21 () Bool)
(declare-fun label_20 () Bool)
(declare-fun label_19 () Bool)
(declare-fun label_18 () Bool)
(declare-fun label_17 () Bool)
(declare-fun label_16 () Bool)
(declare-fun label_15 () Bool)
(declare-fun label_14 () Bool)
(declare-fun label_13 () Bool)
(declare-fun label_12 () Bool)
(declare-fun label_11 () Bool)
(declare-fun label_10 () Bool)
(declare-fun label_9 () Bool)
(declare-fun label_8 () Bool)
(declare-fun label_7 () Bool)
(declare-fun label_6 () Bool)
(declare-fun label_5 () Bool)
(declare-fun label_4 () Bool)
(declare-fun label_3 () Bool)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; _: Prims.unit -> FStar.Calc.calc_pack [] ((a + k * n) % n - a % n) ((a + k * n) % n - a % n)
(declare-fun Tm_arrow_ec09fe0cb197587ff4f8022e98f56e3b (Term Term Term) Term)
; kinding_Tm_arrow_ec09fe0cb197587ff4f8022e98f56e3b
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(219,2-228,3)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term))
   (! (HasType (Tm_arrow_ec09fe0cb197587ff4f8022e98f56e3b @x0 @x1 @x2) Tm_type)
    :pattern ((HasType (Tm_arrow_ec09fe0cb197587ff4f8022e98f56e3b @x0 @x1 @x2) Tm_type))
    :qid kinding_Tm_arrow_ec09fe0cb197587ff4f8022e98f56e3b))
  :named kinding_Tm_arrow_ec09fe0cb197587ff4f8022e98f56e3b))
; pre-typing for functions
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(219,2-228,3)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
   (! (implies
     (HasTypeFuel @u0 @x1 (Tm_arrow_ec09fe0cb197587ff4f8022e98f56e3b @x2 @x3 @x4))
     (is-Tm_arrow (PreType @x1)))
    :pattern ((HasTypeFuel @u0 @x1 (Tm_arrow_ec09fe0cb197587ff4f8022e98f56e3b @x2 @x3 @x4)))
    :qid FStar.Math.Lemmas_pre_typing_Tm_arrow_ec09fe0cb197587ff4f8022e98f56e3b))
  :named FStar.Math.Lemmas_pre_typing_Tm_arrow_ec09fe0cb197587ff4f8022e98f56e3b))
; interpretation_Tm_arrow_ec09fe0cb197587ff4f8022e98f56e3b
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(219,2-228,3)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
   (! (iff
     (HasTypeZ @x0 (Tm_arrow_ec09fe0cb197587ff4f8022e98f56e3b @x1 @x2 @x3))
     (and
      ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(219,2-228,3)
      (forall ((@x4 Term))
       (! (implies
         (HasType @x4 Prims.unit)
         (HasType
          (ApplyTT @x0 @x4)
          (FStar.Calc.calc_pack
           Prims.int
           (Prims.Nil (FStar.Preorder.relation Prims.int))
           (Prims.op_Subtraction
            (Prims.op_Modulus (Prims.op_Addition @x3 (Prims.op_Multiply @x2 @x1)) @x1)
            (Prims.op_Modulus @x3 @x1))
           (Prims.op_Subtraction
            (Prims.op_Modulus (Prims.op_Addition @x3 (Prims.op_Multiply @x2 @x1)) @x1)
            (Prims.op_Modulus @x3 @x1)))))
        :pattern ((ApplyTT @x0 @x4))
        :qid FStar.Math.Lemmas_interpretation_Tm_arrow_ec09fe0cb197587ff4f8022e98f56e3b.1))
      (IsTotFun @x0)))
    :pattern ((HasTypeZ @x0 (Tm_arrow_ec09fe0cb197587ff4f8022e98f56e3b @x1 @x2 @x3)))
    :qid FStar.Math.Lemmas_interpretation_Tm_arrow_ec09fe0cb197587ff4f8022e98f56e3b))
  :named FStar.Math.Lemmas_interpretation_Tm_arrow_ec09fe0cb197587ff4f8022e98f56e3b))
; x5: Prims.int -> y6: Prims.int -> Type
(declare-fun Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0 () Term)
; kinding_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0
;;; Fact-ids: 
(assert
 (! (HasType Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0 Tm_type)
  :named kinding_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0))
; pre-typing for functions
;;; Fact-ids: 
(assert
 (! ;; def=Prims.fst(554,38-554,41); use=FStar.Math.Lemmas.fst(219,2-228,3)
  (forall ((@u0 Fuel) (@x1 Term))
   (! (implies
     (HasTypeFuel @u0 @x1 Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0)
     (is-Tm_arrow (PreType @x1)))
    :pattern ((HasTypeFuel @u0 @x1 Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0))
    :qid FStar.Math.Lemmas_pre_typing_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0))
  :named FStar.Math.Lemmas_pre_typing_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0))
; interpretation_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0
;;; Fact-ids: 
(assert
 (! ;; def=Prims.fst(554,38-554,41); use=FStar.Math.Lemmas.fst(219,2-228,3)
  (forall ((@x0 Term))
   (! (iff
     (HasTypeZ @x0 Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0)
     (and
      ;; def=Prims.fst(554,38-554,41); use=FStar.Math.Lemmas.fst(219,2-228,3)
      (forall ((@x1 Term) (@x2 Term))
       (! (implies
         (and (HasType @x1 Prims.int) (HasType @x2 Prims.int))
         (HasType (ApplyTT (ApplyTT @x0 @x1) @x2) Tm_type))
        :pattern ((ApplyTT (ApplyTT @x0 @x1) @x2))
        :qid FStar.Math.Lemmas_interpretation_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0.1))
      (IsTotFun @x0)
      ;; def=Prims.fst(554,38-554,41); use=FStar.Math.Lemmas.fst(219,2-228,3)
      (forall ((@x1 Term))
       (! (implies (HasType @x1 Prims.int) (IsTotFun (ApplyTT @x0 @x1)))
        :pattern ((ApplyTT @x0 @x1))
        :qid FStar.Math.Lemmas_interpretation_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0.2))))
    :pattern ((HasTypeZ @x0 Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0))
    :qid FStar.Math.Lemmas_interpretation_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0))
  :named FStar.Math.Lemmas_interpretation_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0))
(declare-fun Tm_abs_2d12df642cab58f318db60ed4861d203 () Term)
; typing_Tm_abs_2d12df642cab58f318db60ed4861d203
;;; Fact-ids: 
(assert
 (! (HasType Tm_abs_2d12df642cab58f318db60ed4861d203 Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0)
  :named typing_Tm_abs_2d12df642cab58f318db60ed4861d203))
; interpretation_Tm_abs_2d12df642cab58f318db60ed4861d203
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fst(221,4-221,6); use=FStar.Math.Lemmas.fst(219,2-228,3)
  (forall ((@x0 Term) (@x1 Term))
   (! (=
     (ApplyTT (ApplyTT Tm_abs_2d12df642cab58f318db60ed4861d203 @x0) @x1)
     (Prims.eq2 Prims.int @x0 @x1))
    :pattern ((ApplyTT (ApplyTT Tm_abs_2d12df642cab58f318db60ed4861d203 @x0) @x1))
    :qid interpretation_Tm_abs_2d12df642cab58f318db60ed4861d203))
  :named interpretation_Tm_abs_2d12df642cab58f318db60ed4861d203))
; _: Prims.unit   -> FStar.Calc.calc_pack [fun x5 y6 -> x5 == y6 <: Type]       ((a + k * n) % n - a % n)       (a + k * n - n * ((a + k * n) / n) - (a - n * (a / n)))
(declare-fun Tm_arrow_25637cfaa71cfdd51f994e327b27bd15 (Term Term Term) Term)
; kinding_Tm_arrow_25637cfaa71cfdd51f994e327b27bd15
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(219,2-228,3)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term))
   (! (HasType (Tm_arrow_25637cfaa71cfdd51f994e327b27bd15 @x0 @x1 @x2) Tm_type)
    :pattern ((HasType (Tm_arrow_25637cfaa71cfdd51f994e327b27bd15 @x0 @x1 @x2) Tm_type))
    :qid kinding_Tm_arrow_25637cfaa71cfdd51f994e327b27bd15))
  :named kinding_Tm_arrow_25637cfaa71cfdd51f994e327b27bd15))
; pre-typing for functions
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(219,2-228,3)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
   (! (implies
     (HasTypeFuel @u0 @x1 (Tm_arrow_25637cfaa71cfdd51f994e327b27bd15 @x2 @x3 @x4))
     (is-Tm_arrow (PreType @x1)))
    :pattern ((HasTypeFuel @u0 @x1 (Tm_arrow_25637cfaa71cfdd51f994e327b27bd15 @x2 @x3 @x4)))
    :qid FStar.Math.Lemmas_pre_typing_Tm_arrow_25637cfaa71cfdd51f994e327b27bd15))
  :named FStar.Math.Lemmas_pre_typing_Tm_arrow_25637cfaa71cfdd51f994e327b27bd15))
; interpretation_Tm_arrow_25637cfaa71cfdd51f994e327b27bd15
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(219,2-228,3)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
   (! (iff
     (HasTypeZ @x0 (Tm_arrow_25637cfaa71cfdd51f994e327b27bd15 @x1 @x2 @x3))
     (and
      ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(219,2-228,3)
      (forall ((@x4 Term))
       (! (implies
         (HasType @x4 Prims.unit)
         (HasType
          (ApplyTT @x0 @x4)
          (FStar.Calc.calc_pack
           Prims.int
           (Prims.Cons
            (FStar.Preorder.relation Prims.int)
            Tm_abs_2d12df642cab58f318db60ed4861d203
            (Prims.Nil (FStar.Preorder.relation Prims.int)))
           (Prims.op_Subtraction
            (Prims.op_Modulus (Prims.op_Addition @x3 (Prims.op_Multiply @x2 @x1)) @x1)
            (Prims.op_Modulus @x3 @x1))
           (Prims.op_Subtraction
            (Prims.op_Subtraction
             (Prims.op_Addition @x3 (Prims.op_Multiply @x2 @x1))
             (Prims.op_Multiply
              @x1
              (Prims.op_Division (Prims.op_Addition @x3 (Prims.op_Multiply @x2 @x1)) @x1)))
            (Prims.op_Subtraction @x3 (Prims.op_Multiply @x1 (Prims.op_Division @x3 @x1)))))))
        :pattern ((ApplyTT @x0 @x4))
        :qid FStar.Math.Lemmas_interpretation_Tm_arrow_25637cfaa71cfdd51f994e327b27bd15.1))
      (IsTotFun @x0)))
    :pattern ((HasTypeZ @x0 (Tm_arrow_25637cfaa71cfdd51f994e327b27bd15 @x1 @x2 @x3)))
    :qid FStar.Math.Lemmas_interpretation_Tm_arrow_25637cfaa71cfdd51f994e327b27bd15))
  :named FStar.Math.Lemmas_interpretation_Tm_arrow_25637cfaa71cfdd51f994e327b27bd15))




; _: Prims.unit   -> FStar.Calc.calc_pack [(fun x7 y8 -> x7 == y8 <: Type); fun x5 y6 -> x5 == y6 <: Type]       ((a + k * n) % n - a % n)       (n * k + n * (a / n) - n * ((a + k * n) / n))
(declare-fun Tm_arrow_970ab26aebe0cd53184e42983cdfe91b (Term Term Term) Term)
; kinding_Tm_arrow_970ab26aebe0cd53184e42983cdfe91b
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(219,2-228,3)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term))
   (! (HasType (Tm_arrow_970ab26aebe0cd53184e42983cdfe91b @x0 @x1 @x2) Tm_type)
    :pattern ((HasType (Tm_arrow_970ab26aebe0cd53184e42983cdfe91b @x0 @x1 @x2) Tm_type))
    :qid kinding_Tm_arrow_970ab26aebe0cd53184e42983cdfe91b))
  :named kinding_Tm_arrow_970ab26aebe0cd53184e42983cdfe91b))
; pre-typing for functions
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(219,2-228,3)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
   (! (implies
     (HasTypeFuel @u0 @x1 (Tm_arrow_970ab26aebe0cd53184e42983cdfe91b @x2 @x3 @x4))
     (is-Tm_arrow (PreType @x1)))
    :pattern ((HasTypeFuel @u0 @x1 (Tm_arrow_970ab26aebe0cd53184e42983cdfe91b @x2 @x3 @x4)))
    :qid FStar.Math.Lemmas_pre_typing_Tm_arrow_970ab26aebe0cd53184e42983cdfe91b))
  :named FStar.Math.Lemmas_pre_typing_Tm_arrow_970ab26aebe0cd53184e42983cdfe91b))
; interpretation_Tm_arrow_970ab26aebe0cd53184e42983cdfe91b
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(219,2-228,3)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
   (! (iff
     (HasTypeZ @x0 (Tm_arrow_970ab26aebe0cd53184e42983cdfe91b @x1 @x2 @x3))
     (and
      ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(219,2-228,3)
      (forall ((@x4 Term))
       (! (implies
         (HasType @x4 Prims.unit)
         (HasType
          (ApplyTT @x0 @x4)
          (FStar.Calc.calc_pack
           Prims.int
           (Prims.Cons
            (FStar.Preorder.relation Prims.int)
            Tm_abs_2d12df642cab58f318db60ed4861d203
            (Prims.Cons
             (FStar.Preorder.relation Prims.int)
             Tm_abs_2d12df642cab58f318db60ed4861d203
             (Prims.Nil (FStar.Preorder.relation Prims.int))))
           (Prims.op_Subtraction
            (Prims.op_Modulus (Prims.op_Addition @x3 (Prims.op_Multiply @x2 @x1)) @x1)
            (Prims.op_Modulus @x3 @x1))
           (Prims.op_Subtraction
            (Prims.op_Addition
             (Prims.op_Multiply @x1 @x2)
             (Prims.op_Multiply @x1 (Prims.op_Division @x3 @x1)))
            (Prims.op_Multiply
             @x1
             (Prims.op_Division (Prims.op_Addition @x3 (Prims.op_Multiply @x2 @x1)) @x1))))))
        :pattern ((ApplyTT @x0 @x4))
        :qid FStar.Math.Lemmas_interpretation_Tm_arrow_970ab26aebe0cd53184e42983cdfe91b.1))
      (IsTotFun @x0)))
    :pattern ((HasTypeZ @x0 (Tm_arrow_970ab26aebe0cd53184e42983cdfe91b @x1 @x2 @x3)))
    :qid FStar.Math.Lemmas_interpretation_Tm_arrow_970ab26aebe0cd53184e42983cdfe91b))
  :named FStar.Math.Lemmas_interpretation_Tm_arrow_970ab26aebe0cd53184e42983cdfe91b))






; _: Prims.unit   -> FStar.Calc.calc_pack [         (fun x9 y10 -> x9 == y10 <: Type);         (fun x7 y8 -> x7 == y8 <: Type);         fun x5 y6 -> x5 == y6 <: Type       ]       ((a + k * n) % n - a % n)       (n * (k + a / n - (a + k * n) / n))
(declare-fun Tm_arrow_add55cf7f80c77296b3826c2996cf6ad (Term Term Term) Term)
; kinding_Tm_arrow_add55cf7f80c77296b3826c2996cf6ad
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(81,6-81,36); use=FStar.Math.Lemmas.fst(219,2-230,4)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term))
   (! (HasType (Tm_arrow_add55cf7f80c77296b3826c2996cf6ad @x0 @x1 @x2) Tm_type)
    :pattern ((HasType (Tm_arrow_add55cf7f80c77296b3826c2996cf6ad @x0 @x1 @x2) Tm_type))
    :qid kinding_Tm_arrow_add55cf7f80c77296b3826c2996cf6ad))
  :named kinding_Tm_arrow_add55cf7f80c77296b3826c2996cf6ad))
; pre-typing for functions
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(81,6-81,36); use=FStar.Math.Lemmas.fst(219,2-230,4)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
   (! (implies
     (HasTypeFuel @u0 @x1 (Tm_arrow_add55cf7f80c77296b3826c2996cf6ad @x2 @x3 @x4))
     (is-Tm_arrow (PreType @x1)))
    :pattern ((HasTypeFuel @u0 @x1 (Tm_arrow_add55cf7f80c77296b3826c2996cf6ad @x2 @x3 @x4)))
    :qid FStar.Math.Lemmas_pre_typing_Tm_arrow_add55cf7f80c77296b3826c2996cf6ad))
  :named FStar.Math.Lemmas_pre_typing_Tm_arrow_add55cf7f80c77296b3826c2996cf6ad))
; interpretation_Tm_arrow_add55cf7f80c77296b3826c2996cf6ad
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(81,6-81,36); use=FStar.Math.Lemmas.fst(219,2-230,4)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
   (! (iff
     (HasTypeZ @x0 (Tm_arrow_add55cf7f80c77296b3826c2996cf6ad @x1 @x2 @x3))
     (and
      ;; def=FStar.Calc.fsti(81,6-81,36); use=FStar.Math.Lemmas.fst(219,2-230,4)
      (forall ((@x4 Term))
       (! (implies
         (HasType @x4 Prims.unit)
         (HasType
          (ApplyTT @x0 @x4)
          (FStar.Calc.calc_pack
           Prims.int
           (Prims.Cons
            (FStar.Preorder.relation Prims.int)
            Tm_abs_2d12df642cab58f318db60ed4861d203
            (Prims.Cons
             (FStar.Preorder.relation Prims.int)
             Tm_abs_2d12df642cab58f318db60ed4861d203
             (Prims.Cons
              (FStar.Preorder.relation Prims.int)
              Tm_abs_2d12df642cab58f318db60ed4861d203
              (Prims.Nil (FStar.Preorder.relation Prims.int)))))
           (Prims.op_Subtraction
            (Prims.op_Modulus (Prims.op_Addition @x3 (Prims.op_Multiply @x2 @x1)) @x1)
            (Prims.op_Modulus @x3 @x1))
           (Prims.op_Multiply
            @x1
            (Prims.op_Subtraction
             (Prims.op_Addition @x2 (Prims.op_Division @x3 @x1))
             (Prims.op_Division (Prims.op_Addition @x3 (Prims.op_Multiply @x2 @x1)) @x1))))))
        :pattern ((ApplyTT @x0 @x4))
        :qid FStar.Math.Lemmas_interpretation_Tm_arrow_add55cf7f80c77296b3826c2996cf6ad.1))
      (IsTotFun @x0)))
    :pattern ((HasTypeZ @x0 (Tm_arrow_add55cf7f80c77296b3826c2996cf6ad @x1 @x2 @x3)))
    :qid FStar.Math.Lemmas_interpretation_Tm_arrow_add55cf7f80c77296b3826c2996cf6ad))
  :named FStar.Math.Lemmas_interpretation_Tm_arrow_add55cf7f80c77296b3826c2996cf6ad))
; Encoding query formula : forall (a: Prims.int) (k: Prims.int) (n: Prims.pos).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     (forall (pure_result: Prims.unit). (a + k * n) % n = a % n ==> p pure_result) ==>
;     (n > 0 ==> n <> 0) /\
;     (forall (any_result: Prims.pos).
;         n == any_result ==>
;         (forall (any_result: Prims.int).
;             (a + k * n) % n == any_result ==>
;             (n > 0 ==> n <> 0) /\
;             (forall (any_result: Prims.pos).
;                 n == any_result ==>
;                 (forall (any_result: Prims.int).
;                     a % n == any_result ==>
;                     (forall (any_result: Prims.int).
;                         (a + k * n) % n - a % n == any_result ==>
;                         (n > 0 ==> n <> 0) /\
;                         (forall (any_result: Prims.pos).
;                             n == any_result ==>
;                             (forall (any_result: Prims.int).
;                                 a / n == any_result ==>
;                                 (forall (any_result: Prims.int).
;                                     k + a / n == any_result ==>
;                                     (n > 0 ==> n <> 0) /\
;                                     (forall (any_result: Prims.pos).
;                                         n == any_result ==>
;                                         (forall (any_result: Prims.int).
;                                             (a + k * n) / n == any_result ==>
;                                             (forall (any_result: Prims.int).
;                                                 k + a / n - (a + k * n) / n == any_result ==>
;                                                 (forall (any_result: Prims.int).
;                                                     n * (k + a / n - (a + k * n) / n) == any_result ==>
;                                                     (forall (_: Prims.unit).
;                                                         (*  - Could not prove post-condition
; *)
;                                                         (n > 0 ==> n <> 0) /\
;                                                         (forall (any_result: Prims.pos).
;                                                             n == any_result ==>
;                                                             (forall (any_result: Prims.int).
;                                                                 (a + k * n) % n == any_result ==>
;                                                                 (n > 0 ==> n <> 0) /\
;                                                                 (forall (any_result: Prims.pos).
;                                                                     n == any_result ==>
;                                                                     (forall (any_result: Prims.int).
;                                                                         a % n == any_result ==>
;                                                                         (forall (any_result:
;                                                                             Prims.int).
;                                                                             (a + k * n) % n - a % n ==
;                                                                             any_result ==>
;                                                                             (n > 0 ==> n <> 0) /\
;                                                                             (forall (any_result:
;                                                                                 Prims.pos).
;                                                                                 n == any_result ==>
;                                                                                 (forall (any_result:
;                                                                                     Prims.int).
;                                                                                     a / n ==
;                                                                                     any_result ==>
;                                                                                     (forall (any_result:
;                                                                                         Prims.int).
;                                                                                         n * (a / n) ==
;                                                                                         any_result ==>
;                                                                                         (forall (any_result:
;                                                                                             Prims.int)
;                                                                                           .
;                                                                                             n * k +
;                                                                                             n *
;                                                                                             (a / n) ==
;                                                                                             any_result ==>
;                                                                                             (n > 0 ==>
;                                                                                               n <> 0
;                                                                                             ) /\
;                                                                                             (forall (any_result:
;                                                                                                 Prims.pos)
;                                                                                               .
;                                                                                                 n ==
;                                                                                                 any_result ==>
;                                                                                                 (forall
;                                                                                                     (any_result:
;                                                                                                     Prims.int)
;                                                                                                   .
;                                                                                                     (
;                                                                                                       a +
;                                                                                                       k *
;                                                                                                       n
;                                                                                                     ) /
;                                                                                                     n ==
;                                                                                                     any_result ==>
;                                                                                                     (
;                                                                                                       forall
;                                                                                                         (any_result:
;                                                                                                         Prims.int)
;                                                                                                       .
;                                                                                                         n *
;                                                                                                         ((
;                                                                                                           a +
;                                                                                                           k *
;                                                                                                           n
;                                                                                                         ) /
;                                                                                                         n) ==
;                                                                                                         any_result ==>
;                                                                                                         (
;                                                                                                           forall
;                                                                                                             (any_result:
;                                                                                                             Prims.int)
;                                                                                                           .
;                                                                                                             n *
;                                                                                                             k +
;                                                                                                             n *
;                                                                                                             (a /
;                                                                                                             n) -
;                                                                                                             n *
;                                                                                                             ((
;                                                                                                               a +
;                                                                                                               k *
;                                                                                                               n
;                                                                                                             ) /
;                                                                                                             n) ==
;                                                                                                             any_result ==>
;                                                                                                             (
;                                                                                                               n >
;                                                                                                               0 ==>
;                                                                                                               n <>
;                                                                                                               0
;                                                                                                             ) /\
;                                                                                                             (
;                                                                                                               forall
;                                                                                                                 (any_result:
;                                                                                                                 Prims.pos)
;                                                                                                               .
;                                                                                                                 n ==
;                                                                                                                 any_result ==>
;                                                                                                                 (
;                                                                                                                   forall
;                                                                                                                     (any_result:
;                                                                                                                     Prims.int)
;                                                                                                                   .
;                                                                                                                     a /
;                                                                                                                     n ==
;                                                                                                                     any_result ==>
;                                                                                                                     (
;                                                                                                                       forall
;                                                                                                                         (any_result:
;                                                                                                                         Prims.int)
;                                                                                                                       .
;                                                                                                                         k +
;                                                                                                                         a /
;                                                                                                                         n ==
;                                                                                                                         any_result ==>
;                                                                                                                         (
;                                                                                                                           n >
;                                                                                                                           0 ==>
;                                                                                                                           n <>
;                                                                                                                           0
;                                                                                                                         ) /\
;                                                                                                                         (
;                                                                                                                           forall
;                                                                                                                             (any_result:
;                                                                                                                             Prims.pos)
;                                                                                                                           .
;                                                                                                                             n ==
;                                                                                                                             any_result ==>
;                                                                                                                             (
;                                                                                                                               forall
;                                                                                                                                 (any_result:
;                                                                                                                                 Prims.int)
;                                                                                                                               .
;                                                                                                                                 (
;                                                                                                                                   a +
;                                                                                                                                   k *
;                                                                                                                                   n
;                                                                                                                                 ) /
;                                                                                                                                 n ==
;                                                                                                                                 any_result ==>
;                                                                                                                                 (
;                                                                                                                                   forall
;                                                                                                                                     (any_result:
;                                                                                                                                     Prims.int)
;                                                                                                                                   .
;                                                                                                                                     k +
;                                                                                                                                     a /
;                                                                                                                                     n -
;                                                                                                                                     (
;                                                                                                                                       a +
;                                                                                                                                       k *
;                                                                                                                                       n
;                                                                                                                                     ) /
;                                                                                                                                     n ==
;                                                                                                                                     any_result ==>
;                                                                                                                                     (
;                                                                                                                                       forall
;                                                                                                                                         (any_result:
;                                                                                                                                         Prims.int)
;                                                                                                                                       .
;                                                                                                                                         n *
;                                                                                                                                         (
;                                                                                                                                           k +
;                                                                                                                                           a /
;                                                                                                                                           n -
;                                                                                                                                           (
;                                                                                                                                             a +
;                                                                                                                                             k *
;                                                                                                                                             n
;                                                                                                                                           ) /
;                                                                                                                                           n
;                                                                                                                                         ) ==
;                                                                                                                                         any_result ==>
;                                                                                                                                         (
;                                                                                                                                           forall
;                                                                                                                                             (_:
;                                                                                                                                             Prims.unit)
;                                                                                                                                           .
;                                                                                                                                             (*  - Could not prove post-condition
; *)
;                                                                                                                                             (
;                                                                                                                                               n >
;                                                                                                                                               0 ==>
;                                                                                                                                               n <>
;                                                                                                                                               0
;                                                                                                                                             ) /\
;                                                                                                                                             (
;                                                                                                                                               forall
;                                                                                                                                                 (any_result:
;                                                                                                                                                 Prims.pos)
;                                                                                                                                               .
;                                                                                                                                                 n ==
;                                                                                                                                                 any_result ==>
;                                                                                                                                                 (
;                                                                                                                                                   forall
;                                                                                                                                                     (any_result:
;                                                                                                                                                     Prims.int)
;                                                                                                                                                   .
;                                                                                                                                                     (
;                                                                                                                                                       a +
;                                                                                                                                                       k *
;                                                                                                                                                       n
;                                                                                                                                                     ) %
;                                                                                                                                                     n ==
;                                                                                                                                                     any_result ==>
;                                                                                                                                                     (
;                                                                                                                                                       n >
;                                                                                                                                                       0 ==>
;                                                                                                                                                       n <>
;                                                                                                                                                       0
;                                                                                                                                                     ) /\
;                                                                                                                                                     (
;                                                                                                                                                       forall
;                                                                                                                                                         (any_result:
;                                                                                                                                                         Prims.pos)
;                                                                                                                                                       .
;                                                                                                                                                         n ==
;                                                                                                                                                         any_result ==>
;                                                                                                                                                         (
;                                                                                                                                                           forall
;                                                                                                                                                             (any_result:
;                                                                                                                                                             Prims.int)
;                                                                                                                                                           .
;                                                                                                                                                             a %
;                                                                                                                                                             n ==
;                                                                                                                                                             any_result ==>
;                                                                                                                                                             (
;                                                                                                                                                               forall
;                                                                                                                                                                 (any_result:
;                                                                                                                                                                 Prims.int)
;                                                                                                                                                               .
;                                                                                                                                                                 (
;                                                                                                                                                                   a +
;                                                                                                                                                                   k *
;                                                                                                                                                                   n
;                                                                                                                                                                 ) %
;                                                                                                                                                                 n -
;                                                                                                                                                                 a %
;                                                                                                                                                                 n ==
;                                                                                                                                                                 any_result ==>
;                                                                                                                                                                 (
;                                                                                                                                                                   n >
;                                                                                                                                                                   0 ==>
;                                                                                                                                                                   n <>
;                                                                                                                                                                   0
;                                                                                                                                                                 ) /\
;                                                                                                                                                                 (
;                                                                                                                                                                   forall
;                                                                                                                                                                     (any_result:
;                                                                                                                                                                     Prims.pos)
;                                                                                                                                                                   .
;                                                                                                                                                                     n ==
;                                                                                                                                                                     any_result ==>
;                                                                                                                                                                     (
;                                                                                                                                                                       forall
;                                                                                                                                                                         (any_result:
;                                                                                                                                                                         Prims.int)
;                                                                                                                                                                       .
;                                                                                                                                                                         (
;                                                                                                                                                                           a +
;                                                                                                                                                                           k *
;                                                                                                                                                                           n
;                                                                                                                                                                         ) /
;                                                                                                                                                                         n ==
;                                                                                                                                                                         any_result ==>
;                                                                                                                                                                         (
;                                                                                                                                                                           forall
;                                                                                                                                                                             (any_result:
;                                                                                                                                                                             Prims.int)
;                                                                                                                                                                           .
;                                                                                                                                                                             n *
;                                                                                                                                                                             ((
;                                                                                                                                                                               a +
;                                                                                                                                                                               k *
;                                                                                                                                                                               n
;                                                                                                                                                                             ) /
;                                                                                                                                                                             n) ==
;                                                                                                                                                                             any_result ==>
;                                                                                                                                                                             (
;                                                                                                                                                                               forall
;                                                                                                                                                                                 (any_result:
;                                                                                                                                                                                 Prims.int)
;                                                                                                                                                                               .
;                                                                                                                                                                                 a +
;                                                                                                                                                                                 k *
;                                                                                                                                                                                 n -
;                                                                                                                                                                                 n *
;                                                                                                                                                                                 ((
;                                                                                                                                                                                   a +
;                                                                                                                                                                                   k *
;                                                                                                                                                                                   n
;                                                                                                                                                                                 ) /
;                                                                                                                                                                                 n) ==
;                                                                                                                                                                                 any_result ==>
;                                                                                                                                                                                 (
;                                                                                                                                                                                   n >
;                                                                                                                                                                                   0 ==>
;                                                                                                                                                                                   n <>
;                                                                                                                                                                                   0
;                                                                                                                                                                                 ) /\
;                                                                                                                                                                                 (
;                                                                                                                                                                                   forall
;                                                                                                                                                                                     (any_result:
;                                                                                                                                                                                     Prims.pos)
;                                                                                                                                                                                   .
;                                                                                                                                                                                     n ==
;                                                                                                                                                                                     any_result ==>
;                                                                                                                                                                                     (
;                                                                                                                                                                                       forall
;                                                                                                                                                                                         (any_result:
;                                                                                                                                                                                         Prims.int)
;                                                                                                                                                                                       .
;                                                                                                                                                                                         a /
;                                                                                                                                                                                         n ==
;                                                                                                                                                                                         any_result ==>
;                                                                                                                                                                                         (
;                                                                                                                                                                                           forall
;                                                                                                                                                                                             (any_result:
;                                                                                                                                                                                             Prims.int)
;                                                                                                                                                                                           .
;                                                                                                                                                                                             n *
;                                                                                                                                                                                             (a /
;                                                                                                                                                                                             n) ==
;                                                                                                                                                                                             any_result ==>
;                                                                                                                                                                                             (
;                                                                                                                                                                                               forall
;                                                                                                                                                                                                 (any_result:
;                                                                                                                                                                                                 Prims.int)
;                                                                                                                                                                                               .
;                                                                                                                                                                                                 a -
;                                                                                                                                                                                                 n *
;                                                                                                                                                                                                 (a /
;                                                                                                                                                                                                 n) ==
;                                                                                                                                                                                                 any_result ==>
;                                                                                                                                                                                                 (
;                                                                                                                                                                                                   forall
;                                                                                                                                                                                                     (any_result:
;                                                                                                                                                                                                     Prims.int)
;                                                                                                                                                                                                   .
;                                                                                                                                                                                                     a +
;                                                                                                                                                                                                     k *
;                                                                                                                                                                                                     n -
;                                                                                                                                                                                                     n *
;                                                                                                                                                                                                     ((
;                                                                                                                                                                                                       a +
;                                                                                                                                                                                                       k *
;                                                                                                                                                                                                       n
;                                                                                                                                                                                                     ) /
;                                                                                                                                                                                                     n) -
;                                                                                                                                                                                                     (a -
;                                                                                                                                                                                                     n *
;                                                                                                                                                                                                     (a /
;                                                                                                                                                                                                     n)) ==
;                                                                                                                                                                                                     any_result ==>
;                                                                                                                                                                                                     (
;                                                                                                                                                                                                       n >
;                                                                                                                                                                                                       0 ==>
;                                                                                                                                                                                                       n <>
;                                                                                                                                                                                                       0
;                                                                                                                                                                                                     ) /\
;                                                                                                                                                                                                     (
;                                                                                                                                                                                                       forall
;                                                                                                                                                                                                         (any_result:
;                                                                                                                                                                                                         Prims.pos)
;                                                                                                                                                                                                       .
;                                                                                                                                                                                                         n ==
;                                                                                                                                                                                                         any_result ==>
;                                                                                                                                                                                                         (
;                                                                                                                                                                                                           forall
;                                                                                                                                                                                                             (any_result:
;                                                                                                                                                                                                             Prims.int)
;                                                                                                                                                                                                           .
;                                                                                                                                                                                                             a /
;                                                                                                                                                                                                             n ==
;                                                                                                                                                                                                             any_result ==>
;                                                                                                                                                                                                             (
;                                                                                                                                                                                                               forall
;                                                                                                                                                                                                                 (any_result:
;                                                                                                                                                                                                                 Prims.int)
;                                                                                                                                                                                                               .
;                                                                                                                                                                                                                 n *
;                                                                                                                                                                                                                 (a /
;                                                                                                                                                                                                                 n) ==
;                                                                                                                                                                                                                 any_result ==>
;                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                   forall
;                                                                                                                                                                                                                     (any_result:
;                                                                                                                                                                                                                     Prims.int)
;                                                                                                                                                                                                                   .
;                                                                                                                                                                                                                     n *
;                                                                                                                                                                                                                     k +
;                                                                                                                                                                                                                     n *
;                                                                                                                                                                                                                     (a /
;                                                                                                                                                                                                                     n) ==
;                                                                                                                                                                                                                     any_result ==>
;                                                                                                                                                                                                                     (
;                                                                                                                                                                                                                       n >
;                                                                                                                                                                                                                       0 ==>
;                                                                                                                                                                                                                       n <>
;                                                                                                                                                                                                                       0
;                                                                                                                                                                                                                     ) /\
;                                                                                                                                                                                                                     (
;                                                                                                                                                                                                                       forall
;                                                                                                                                                                                                                         (any_result:
;                                                                                                                                                                                                                         Prims.pos)
;                                                                                                                                                                                                                       .
;                                                                                                                                                                                                                         n ==
;                                                                                                                                                                                                                         any_result ==>
;                                                                                                                                                                                                                         (
;                                                                                                                                                                                                                           forall
;                                                                                                                                                                                                                             (any_result:
;                                                                                                                                                                                                                             Prims.int)
;                                                                                                                                                                                                                           .
;                                                                                                                                                                                                                             (
;                                                                                                                                                                                                                               a +
;                                                                                                                                                                                                                               k *
;                                                                                                                                                                                                                               n
;                                                                                                                                                                                                                             ) /
;                                                                                                                                                                                                                             n ==
;                                                                                                                                                                                                                             any_result ==>
;                                                                                                                                                                                                                             (
;                                                                                                                                                                                                                               forall
;                                                                                                                                                                                                                                 (any_result:
;                                                                                                                                                                                                                                 Prims.int)
;                                                                                                                                                                                                                               .
;                                                                                                                                                                                                                                 n *
;                                                                                                                                                                                                                                 ((
;                                                                                                                                                                                                                                   a +
;                                                                                                                                                                                                                                   k *
;                                                                                                                                                                                                                                   n
;                                                                                                                                                                                                                                 ) /
;                                                                                                                                                                                                                                 n) ==
;                                                                                                                                                                                                                                 any_result ==>
;                                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                                   forall
;                                                                                                                                                                                                                                     (any_result:
;                                                                                                                                                                                                                                     Prims.int)
;                                                                                                                                                                                                                                   .
;                                                                                                                                                                                                                                     n *
;                                                                                                                                                                                                                                     k +
;                                                                                                                                                                                                                                     n *
;                                                                                                                                                                                                                                     (a /
;                                                                                                                                                                                                                                     n) -
;                                                                                                                                                                                                                                     n *
;                                                                                                                                                                                                                                     ((
;                                                                                                                                                                                                                                       a +
;                                                                                                                                                                                                                                       k *
;                                                                                                                                                                                                                                       n
;                                                                                                                                                                                                                                     ) /
;                                                                                                                                                                                                                                     n) ==
;                                                                                                                                                                                                                                     any_result ==>
;                                                                                                                                                                                                                                     (
;                                                                                                                                                                                                                                       forall
;                                                                                                                                                                                                                                         (_:
;                                                                                                                                                                                                                                         Prims.unit)
;                                                                                                                                                                                                                                       .
;                                                                                                                                                                                                                                         (*  - Could not prove post-condition
; *)
;                                                                                                                                                                                                                                         (
;                                                                                                                                                                                                                                           n >
;                                                                                                                                                                                                                                           0 ==>
;                                                                                                                                                                                                                                           n <>
;                                                                                                                                                                                                                                           0
;                                                                                                                                                                                                                                         ) /\
;                                                                                                                                                                                                                                         (
;                                                                                                                                                                                                                                           forall
;                                                                                                                                                                                                                                             (any_result:
;                                                                                                                                                                                                                                             Prims.pos)
;                                                                                                                                                                                                                                           .
;                                                                                                                                                                                                                                             n ==
;                                                                                                                                                                                                                                             any_result ==>
;                                                                                                                                                                                                                                             (
;                                                                                                                                                                                                                                               forall
;                                                                                                                                                                                                                                                 (any_result:
;                                                                                                                                                                                                                                                 Prims.int)
;                                                                                                                                                                                                                                               .
;                                                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                                                   a +
;                                                                                                                                                                                                                                                   k *
;                                                                                                                                                                                                                                                   n
;                                                                                                                                                                                                                                                 ) %
;                                                                                                                                                                                                                                                 n ==
;                                                                                                                                                                                                                                                 any_result ==>
;                                                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                                                   n >
;                                                                                                                                                                                                                                                   0 ==>
;                                                                                                                                                                                                                                                   n <>
;                                                                                                                                                                                                                                                   0
;                                                                                                                                                                                                                                                 ) /\
;                                                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                                                   forall
;                                                                                                                                                                                                                                                     (any_result:
;                                                                                                                                                                                                                                                     Prims.pos)
;                                                                                                                                                                                                                                                   .
;                                                                                                                                                                                                                                                     n ==
;                                                                                                                                                                                                                                                     any_result ==>
;                                                                                                                                                                                                                                                     (
;                                                                                                                                                                                                                                                       forall
;                                                                                                                                                                                                                                                         (any_result:
;                                                                                                                                                                                                                                                         Prims.int)
;                                                                                                                                                                                                                                                       .
;                                                                                                                                                                                                                                                         a %
;                                                                                                                                                                                                                                                         n ==
;                                                                                                                                                                                                                                                         any_result ==>
;                                                                                                                                                                                                                                                         (
;                                                                                                                                                                                                                                                           forall
;                                                                                                                                                                                                                                                             (any_result:
;                                                                                                                                                                                                                                                             Prims.int)
;                                                                                                                                                                                                                                                           .
;                                                                                                                                                                                                                                                             (
;                                                                                                                                                                                                                                                               a +
;                                                                                                                                                                                                                                                               k *
;                                                                                                                                                                                                                                                               n
;                                                                                                                                                                                                                                                             ) %
;                                                                                                                                                                                                                                                             n -
;                                                                                                                                                                                                                                                             a %
;                                                                                                                                                                                                                                                             n ==
;                                                                                                                                                                                                                                                             any_result ==>
;                                                                                                                                                                                                                                                             (
;                                                                                                                                                                                                                                                               n >
;                                                                                                                                                                                                                                                               0 ==>
;                                                                                                                                                                                                                                                               n <>
;                                                                                                                                                                                                                                                               0
;                                                                                                                                                                                                                                                             ) /\
;                                                                                                                                                                                                                                                             (
;                                                                                                                                                                                                                                                               forall
;                                                                                                                                                                                                                                                                 (any_result:
;                                                                                                                                                                                                                                                                 Prims.pos)
;                                                                                                                                                                                                                                                               .
;                                                                                                                                                                                                                                                                 n ==
;                                                                                                                                                                                                                                                                 any_result ==>
;                                                                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                                                                   forall
;                                                                                                                                                                                                                                                                     (any_result:
;                                                                                                                                                                                                                                                                     Prims.int)
;                                                                                                                                                                                                                                                                   .
;                                                                                                                                                                                                                                                                     (
;                                                                                                                                                                                                                                                                       a +
;                                                                                                                                                                                                                                                                       k *
;                                                                                                                                                                                                                                                                       n
;                                                                                                                                                                                                                                                                     ) %
;                                                                                                                                                                                                                                                                     n ==
;                                                                                                                                                                                                                                                                     any_result ==>
;                                                                                                                                                                                                                                                                     (
;                                                                                                                                                                                                                                                                       n >
;                                                                                                                                                                                                                                                                       0 ==>
;                                                                                                                                                                                                                                                                       n <>
;                                                                                                                                                                                                                                                                       0
;                                                                                                                                                                                                                                                                     ) /\
;                                                                                                                                                                                                                                                                     (
;                                                                                                                                                                                                                                                                       forall
;                                                                                                                                                                                                                                                                         (any_result:
;                                                                                                                                                                                                                                                                         Prims.pos)
;                                                                                                                                                                                                                                                                       .
;                                                                                                                                                                                                                                                                         n ==
;                                                                                                                                                                                                                                                                         any_result ==>
;                                                                                                                                                                                                                                                                         (
;                                                                                                                                                                                                                                                                           forall
;                                                                                                                                                                                                                                                                             (any_result:
;                                                                                                                                                                                                                                                                             Prims.int)
;                                                                                                                                                                                                                                                                           .
;                                                                                                                                                                                                                                                                             a %
;                                                                                                                                                                                                                                                                             n ==
;                                                                                                                                                                                                                                                                             any_result ==>
;                                                                                                                                                                                                                                                                             (
;                                                                                                                                                                                                                                                                               forall
;                                                                                                                                                                                                                                                                                 (any_result:
;                                                                                                                                                                                                                                                                                 Prims.int)
;                                                                                                                                                                                                                                                                               .
;                                                                                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                                                                                   a +
;                                                                                                                                                                                                                                                                                   k *
;                                                                                                                                                                                                                                                                                   n
;                                                                                                                                                                                                                                                                                 ) %
;                                                                                                                                                                                                                                                                                 n -
;                                                                                                                                                                                                                                                                                 a %
;                                                                                                                                                                                                                                                                                 n ==
;                                                                                                                                                                                                                                                                                 any_result ==>
;                                                                                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                                                                                   n >
;                                                                                                                                                                                                                                                                                   0 ==>
;                                                                                                                                                                                                                                                                                   n <>
;                                                                                                                                                                                                                                                                                   0
;                                                                                                                                                                                                                                                                                 ) /\
;                                                                                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                                                                                   forall
;                                                                                                                                                                                                                                                                                     (any_result:
;                                                                                                                                                                                                                                                                                     Prims.pos)
;                                                                                                                                                                                                                                                                                   .
;                                                                                                                                                                                                                                                                                     n ==
;                                                                                                                                                                                                                                                                                     any_result ==>
;                                                                                                                                                                                                                                                                                     (
;                                                                                                                                                                                                                                                                                       forall
;                                                                                                                                                                                                                                                                                         (any_result:
;                                                                                                                                                                                                                                                                                         Prims.int)
;                                                                                                                                                                                                                                                                                       .
;                                                                                                                                                                                                                                                                                         (
;                                                                                                                                                                                                                                                                                           a +
;                                                                                                                                                                                                                                                                                           k *
;                                                                                                                                                                                                                                                                                           n
;                                                                                                                                                                                                                                                                                         ) /
;                                                                                                                                                                                                                                                                                         n ==
;                                                                                                                                                                                                                                                                                         any_result ==>
;                                                                                                                                                                                                                                                                                         (
;                                                                                                                                                                                                                                                                                           forall
;                                                                                                                                                                                                                                                                                             (any_result:
;                                                                                                                                                                                                                                                                                             Prims.int)
;                                                                                                                                                                                                                                                                                           .
;                                                                                                                                                                                                                                                                                             n *
;                                                                                                                                                                                                                                                                                             ((
;                                                                                                                                                                                                                                                                                               a +
;                                                                                                                                                                                                                                                                                               k *
;                                                                                                                                                                                                                                                                                               n
;                                                                                                                                                                                                                                                                                             ) /
;                                                                                                                                                                                                                                                                                             n) ==
;                                                                                                                                                                                                                                                                                             any_result ==>
;                                                                                                                                                                                                                                                                                             (
;                                                                                                                                                                                                                                                                                               forall
;                                                                                                                                                                                                                                                                                                 (any_result:
;                                                                                                                                                                                                                                                                                                 Prims.int)
;                                                                                                                                                                                                                                                                                               .
;                                                                                                                                                                                                                                                                                                 a +
;                                                                                                                                                                                                                                                                                                 k *
;                                                                                                                                                                                                                                                                                                 n -
;                                                                                                                                                                                                                                                                                                 n *
;                                                                                                                                                                                                                                                                                                 ((
;                                                                                                                                                                                                                                                                                                   a +
;                                                                                                                                                                                                                                                                                                   k *
;                                                                                                                                                                                                                                                                                                   n
;                                                                                                                                                                                                                                                                                                 ) /
;                                                                                                                                                                                                                                                                                                 n) ==
;                                                                                                                                                                                                                                                                                                 any_result ==>
;                                                                                                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                                                                                                   n >
;                                                                                                                                                                                                                                                                                                   0 ==>
;                                                                                                                                                                                                                                                                                                   n <>
;                                                                                                                                                                                                                                                                                                   0
;                                                                                                                                                                                                                                                                                                 ) /\
;                                                                                                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                                                                                                   forall
;                                                                                                                                                                                                                                                                                                     (any_result:
;                                                                                                                                                                                                                                                                                                     Prims.pos)
;                                                                                                                                                                                                                                                                                                   .
;                                                                                                                                                                                                                                                                                                     n ==
;                                                                                                                                                                                                                                                                                                     any_result ==>
;                                                                                                                                                                                                                                                                                                     (
;                                                                                                                                                                                                                                                                                                       forall
;                                                                                                                                                                                                                                                                                                         (any_result:
;                                                                                                                                                                                                                                                                                                         Prims.int)
;                                                                                                                                                                                                                                                                                                       .
;                                                                                                                                                                                                                                                                                                         a /
;                                                                                                                                                                                                                                                                                                         n ==
;                                                                                                                                                                                                                                                                                                         any_result ==>
;                                                                                                                                                                                                                                                                                                         (
;                                                                                                                                                                                                                                                                                                           forall
;                                                                                                                                                                                                                                                                                                             (any_result:
;                                                                                                                                                                                                                                                                                                             Prims.int)
;                                                                                                                                                                                                                                                                                                           .
;                                                                                                                                                                                                                                                                                                             n *
;                                                                                                                                                                                                                                                                                                             (a /
;                                                                                                                                                                                                                                                                                                             n) ==
;                                                                                                                                                                                                                                                                                                             any_result ==>
;                                                                                                                                                                                                                                                                                                             (
;                                                                                                                                                                                                                                                                                                               forall
;                                                                                                                                                                                                                                                                                                                 (any_result:
;                                                                                                                                                                                                                                                                                                                 Prims.int)
;                                                                                                                                                                                                                                                                                                               .
;                                                                                                                                                                                                                                                                                                                 a -
;                                                                                                                                                                                                                                                                                                                 n *
;                                                                                                                                                                                                                                                                                                                 (a /
;                                                                                                                                                                                                                                                                                                                 n) ==
;                                                                                                                                                                                                                                                                                                                 any_result ==>
;                                                                                                                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                                                                                                                   forall
;                                                                                                                                                                                                                                                                                                                     (any_result:
;                                                                                                                                                                                                                                                                                                                     Prims.int)
;                                                                                                                                                                                                                                                                                                                   .
;                                                                                                                                                                                                                                                                                                                     a +
;                                                                                                                                                                                                                                                                                                                     k *
;                                                                                                                                                                                                                                                                                                                     n -
;                                                                                                                                                                                                                                                                                                                     n *
;                                                                                                                                                                                                                                                                                                                     ((
;                                                                                                                                                                                                                                                                                                                       a +
;                                                                                                                                                                                                                                                                                                                       k *
;                                                                                                                                                                                                                                                                                                                       n
;                                                                                                                                                                                                                                                                                                                     ) /
;                                                                                                                                                                                                                                                                                                                     n) -
;                                                                                                                                                                                                                                                                                                                     (a -
;                                                                                                                                                                                                                                                                                                                     n *
;                                                                                                                                                                                                                                                                                                                     (a /
;                                                                                                                                                                                                                                                                                                                     n)) ==
;                                                                                                                                                                                                                                                                                                                     any_result ==>
;                                                                                                                                                                                                                                                                                                                     (
;                                                                                                                                                                                                                                                                                                                       forall
;                                                                                                                                                                                                                                                                                                                         (_:
;                                                                                                                                                                                                                                                                                                                         Prims.unit)
;                                                                                                                                                                                                                                                                                                                       .
;                                                                                                                                                                                                                                                                                                                         (*  - Could not prove post-condition
; *)
;                                                                                                                                                                                                                                                                                                                         (
;                                                                                                                                                                                                                                                                                                                           n >
;                                                                                                                                                                                                                                                                                                                           0 ==>
;                                                                                                                                                                                                                                                                                                                           n <>
;                                                                                                                                                                                                                                                                                                                           0
;                                                                                                                                                                                                                                                                                                                         ) /\
;                                                                                                                                                                                                                                                                                                                         (
;                                                                                                                                                                                                                                                                                                                           forall
;                                                                                                                                                                                                                                                                                                                             (any_result:
;                                                                                                                                                                                                                                                                                                                             Prims.pos)
;                                                                                                                                                                                                                                                                                                                           .
;                                                                                                                                                                                                                                                                                                                             n ==
;                                                                                                                                                                                                                                                                                                                             any_result ==>
;                                                                                                                                                                                                                                                                                                                             (
;                                                                                                                                                                                                                                                                                                                               forall
;                                                                                                                                                                                                                                                                                                                                 (any_result:
;                                                                                                                                                                                                                                                                                                                                 Prims.int)
;                                                                                                                                                                                                                                                                                                                               .
;                                                                                                                                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                                                                                                                                   a +
;                                                                                                                                                                                                                                                                                                                                   k *
;                                                                                                                                                                                                                                                                                                                                   n
;                                                                                                                                                                                                                                                                                                                                 ) %
;                                                                                                                                                                                                                                                                                                                                 n ==
;                                                                                                                                                                                                                                                                                                                                 any_result ==>
;                                                                                                                                                                                                                                                                                                                                 n >
;                                                                                                                                                                                                                                                                                                                                 0 ==>
;                                                                                                                                                                                                                                                                                                                                 n <>
;                                                                                                                                                                                                                                                                                                                                 0
;                                                                                                                                                                                                                                                                                                                             )
;                                                                                                                                                                                                                                                                                                                         )
;                                                                                                                                                                                                                                                                                                                     ) /\
;                                                                                                                                                                                                                                                                                                                     (
;                                                                                                                                                                                                                                                                                                                       forall
;                                                                                                                                                                                                                                                                                                                         (any_result:
;                                                                                                                                                                                                                                                                                                                         (
; 
;                                                                                                                                                                                                                                                                                                                               _:
;                                                                                                                                                                                                                                                                                                                                 Prims.unit
;                                                                                                                                                                                                                                                                                                                             -> FStar.Calc.calc_pack
;                                                                                                                                                                                                                                                                                                                                 [
; 
;                                                                                                                                                                                                                                                                                                                                 ]
;                                                                                                                                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                                                                                                                                   (
;                                                                                                                                                                                                                                                                                                                                     a +
;                                                                                                                                                                                                                                                                                                                                     k *
;                                                                                                                                                                                                                                                                                                                                     n
;                                                                                                                                                                                                                                                                                                                                   ) %
;                                                                                                                                                                                                                                                                                                                                   n -
;                                                                                                                                                                                                                                                                                                                                   a %
;                                                                                                                                                                                                                                                                                                                                   n
;                                                                                                                                                                                                                                                                                                                                 )
;                                                                                                                                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                                                                                                                                   (
;                                                                                                                                                                                                                                                                                                                                     a +
;                                                                                                                                                                                                                                                                                                                                     k *
;                                                                                                                                                                                                                                                                                                                                     n
;                                                                                                                                                                                                                                                                                                                                   ) %
;                                                                                                                                                                                                                                                                                                                                   n -
;                                                                                                                                                                                                                                                                                                                                   a %
;                                                                                                                                                                                                                                                                                                                                   n
;                                                                                                                                                                                                                                                                                                                                 )
; 
;                                                                                                                                                                                                                                                                                                                         ))
;                                                                                                                                                                                                                                                                                                                         (_:
;                                                                                                                                                                                                                                                                                                                         Prims.unit)
;                                                                                                                                                                                                                                                                                                                       .
;                                                                                                                                                                                                                                                                                                                         (*  - Could not prove post-condition
; *)
;                                                                                                                                                                                                                                                                                                                         (
;                                                                                                                                                                                                                                                                                                                           n >
;                                                                                                                                                                                                                                                                                                                           0 ==>
;                                                                                                                                                                                                                                                                                                                           n <>
;                                                                                                                                                                                                                                                                                                                           0
;                                                                                                                                                                                                                                                                                                                         ) /\
;                                                                                                                                                                                                                                                                                                                         (
;                                                                                                                                                                                                                                                                                                                           forall
;                                                                                                                                                                                                                                                                                                                             (any_result:
;                                                                                                                                                                                                                                                                                                                             Prims.pos)
;                                                                                                                                                                                                                                                                                                                           .
;                                                                                                                                                                                                                                                                                                                             n ==
;                                                                                                                                                                                                                                                                                                                             any_result ==>
;                                                                                                                                                                                                                                                                                                                             (
;                                                                                                                                                                                                                                                                                                                               forall
;                                                                                                                                                                                                                                                                                                                                 (pure_result:
;                                                                                                                                                                                                                                                                                                                                 Prims.unit)
;                                                                                                                                                                                                                                                                                                                               .
;                                                                                                                                                                                                                                                                                                                                 a =
;                                                                                                                                                                                                                                                                                                                                 n *
;                                                                                                                                                                                                                                                                                                                                 (a /
;                                                                                                                                                                                                                                                                                                                                 n) +
;                                                                                                                                                                                                                                                                                                                                 a %
;                                                                                                                                                                                                                                                                                                                                 n ==>
;                                                                                                                                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                                                                                                                                   n >
;                                                                                                                                                                                                                                                                                                                                   0 ==>
;                                                                                                                                                                                                                                                                                                                                   n <>
;                                                                                                                                                                                                                                                                                                                                   0
;                                                                                                                                                                                                                                                                                                                                 ) /\
;                                                                                                                                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                                                                                                                                   forall
;                                                                                                                                                                                                                                                                                                                                     (any_result:
;                                                                                                                                                                                                                                                                                                                                     Prims.pos)
;                                                                                                                                                                                                                                                                                                                                   .
;                                                                                                                                                                                                                                                                                                                                     n ==
;                                                                                                                                                                                                                                                                                                                                     any_result ==>
;                                                                                                                                                                                                                                                                                                                                     (
;                                                                                                                                                                                                                                                                                                                                       forall
;                                                                                                                                                                                                                                                                                                                                         (pure_result:
;                                                                                                                                                                                                                                                                                                                                         Prims.unit)
;                                                                                                                                                                                                                                                                                                                                       .
;                                                                                                                                                                                                                                                                                                                                         a +
;                                                                                                                                                                                                                                                                                                                                         k *
;                                                                                                                                                                                                                                                                                                                                         n =
;                                                                                                                                                                                                                                                                                                                                         n *
;                                                                                                                                                                                                                                                                                                                                         ((
;                                                                                                                                                                                                                                                                                                                                           a +
;                                                                                                                                                                                                                                                                                                                                           k *
;                                                                                                                                                                                                                                                                                                                                           n
;                                                                                                                                                                                                                                                                                                                                         ) /
;                                                                                                                                                                                                                                                                                                                                         n) +
;                                                                                                                                                                                                                                                                                                                                         (
;                                                                                                                                                                                                                                                                                                                                           a +
;                                                                                                                                                                                                                                                                                                                                           k *
;                                                                                                                                                                                                                                                                                                                                           n
;                                                                                                                                                                                                                                                                                                                                         ) %
;                                                                                                                                                                                                                                                                                                                                         n ==>
;                                                                                                                                                                                                                                                                                                                                         (
;                                                                                                                                                                                                                                                                                                                                           a +
;                                                                                                                                                                                                                                                                                                                                           k *
;                                                                                                                                                                                                                                                                                                                                           n
;                                                                                                                                                                                                                                                                                                                                         ) %
;                                                                                                                                                                                                                                                                                                                                         n -
;                                                                                                                                                                                                                                                                                                                                         a %
;                                                                                                                                                                                                                                                                                                                                         n ==
;                                                                                                                                                                                                                                                                                                                                         a +
;                                                                                                                                                                                                                                                                                                                                         k *
;                                                                                                                                                                                                                                                                                                                                         n -
;                                                                                                                                                                                                                                                                                                                                         n *
;                                                                                                                                                                                                                                                                                                                                         ((
;                                                                                                                                                                                                                                                                                                                                           a +
;                                                                                                                                                                                                                                                                                                                                           k *
;                                                                                                                                                                                                                                                                                                                                           n
;                                                                                                                                                                                                                                                                                                                                         ) /
;                                                                                                                                                                                                                                                                                                                                         n) -
;                                                                                                                                                                                                                                                                                                                                         (a -
;                                                                                                                                                                                                                                                                                                                                         n *
;                                                                                                                                                                                                                                                                                                                                         (a /
;                                                                                                                                                                                                                                                                                                                                         n))
;                                                                                                                                                                                                                                                                                                                                     )
;                                                                                                                                                                                                                                                                                                                                 )
;                                                                                                                                                                                                                                                                                                                             )
;                                                                                                                                                                                                                                                                                                                         )
;                                                                                                                                                                                                                                                                                                                     )
;                                                                                                                                                                                                                                                                                                                 )
;                                                                                                                                                                                                                                                                                                             )
;                                                                                                                                                                                                                                                                                                         )
;                                                                                                                                                                                                                                                                                                     )
;                                                                                                                                                                                                                                                                                                 )
;                                                                                                                                                                                                                                                                                             )
;                                                                                                                                                                                                                                                                                         )
;                                                                                                                                                                                                                                                                                     )
;                                                                                                                                                                                                                                                                                 )
;                                                                                                                                                                                                                                                                             )
;                                                                                                                                                                                                                                                                         )
;                                                                                                                                                                                                                                                                     )
;                                                                                                                                                                                                                                                                 )
;                                                                                                                                                                                                                                                             )
;                                                                                                                                                                                                                                                         )
;                                                                                                                                                                                                                                                     )
;                                                                                                                                                                                                                                                 )
;                                                                                                                                                                                                                                             )
;                                                                                                                                                                                                                                         )
;                                                                                                                                                                                                                                     ) /\
;                                                                                                                                                                                                                                     (
;                                                                                                                                                                                                                                       forall
;                                                                                                                                                                                                                                         (any_result:
;                                                                                                                                                                                                                                         (
; 
;                                                                                                                                                                                                                                               _:
;                                                                                                                                                                                                                                                 Prims.unit
;                                                                                                                                                                                                                                             -> FStar.Calc.calc_pack
;                                                                                                                                                                                                                                                 [
;                                                                                                                                                                                                                                                   fun
;                                                                                                                                                                                                                                                     x5
;                                                                                                                                                                                                                                                     y6
;                                                                                                                                                                                                                                                     ->
;                                                                                                                                                                                                                                                     x5 ==
;                                                                                                                                                                                                                                                     y6
;                                                                                                                                                                                                                                                     <:
;                                                                                                                                                                                                                                                     Type0
;                                                                                                                                                                                                                                                 ]
;                                                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                                                   (
;                                                                                                                                                                                                                                                     a +
;                                                                                                                                                                                                                                                     k *
;                                                                                                                                                                                                                                                     n
;                                                                                                                                                                                                                                                   ) %
;                                                                                                                                                                                                                                                   n -
;                                                                                                                                                                                                                                                   a %
;                                                                                                                                                                                                                                                   n
;                                                                                                                                                                                                                                                 )
;                                                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                                                   a +
;                                                                                                                                                                                                                                                   k *
;                                                                                                                                                                                                                                                   n -
;                                                                                                                                                                                                                                                   n *
;                                                                                                                                                                                                                                                   ((
;                                                                                                                                                                                                                                                     a +
;                                                                                                                                                                                                                                                     k *
;                                                                                                                                                                                                                                                     n
;                                                                                                                                                                                                                                                   ) /
;                                                                                                                                                                                                                                                   n) -
;                                                                                                                                                                                                                                                   (a -
;                                                                                                                                                                                                                                                   n *
;                                                                                                                                                                                                                                                   (a /
;                                                                                                                                                                                                                                                   n))
;                                                                                                                                                                                                                                                 )
; 
;                                                                                                                                                                                                                                         ))
;                                                                                                                                                                                                                                         (_:
;                                                                                                                                                                                                                                         Prims.unit)
;                                                                                                                                                                                                                                       .
;                                                                                                                                                                                                                                         (*  - Could not prove post-condition
; *)
;                                                                                                                                                                                                                                         a +
;                                                                                                                                                                                                                                         k *
;                                                                                                                                                                                                                                         n -
;                                                                                                                                                                                                                                         n *
;                                                                                                                                                                                                                                         ((
;                                                                                                                                                                                                                                           a +
;                                                                                                                                                                                                                                           k *
;                                                                                                                                                                                                                                           n
;                                                                                                                                                                                                                                         ) /
;                                                                                                                                                                                                                                         n) -
;                                                                                                                                                                                                                                         (a -
;                                                                                                                                                                                                                                         n *
;                                                                                                                                                                                                                                         (a /
;                                                                                                                                                                                                                                         n)) ==
;                                                                                                                                                                                                                                         n *
;                                                                                                                                                                                                                                         k +
;                                                                                                                                                                                                                                         n *
;                                                                                                                                                                                                                                         (a /
;                                                                                                                                                                                                                                         n) -
;                                                                                                                                                                                                                                         n *
;                                                                                                                                                                                                                                         ((
;                                                                                                                                                                                                                                           a +
;                                                                                                                                                                                                                                           k *
;                                                                                                                                                                                                                                           n
;                                                                                                                                                                                                                                         ) /
;                                                                                                                                                                                                                                         n)
;                                                                                                                                                                                                                                     )
;                                                                                                                                                                                                                                 )
;                                                                                                                                                                                                                             )
;                                                                                                                                                                                                                         )
;                                                                                                                                                                                                                     )
;                                                                                                                                                                                                                 )
;                                                                                                                                                                                                             )
;                                                                                                                                                                                                         )
;                                                                                                                                                                                                     )
;                                                                                                                                                                                                 )
;                                                                                                                                                                                             )
;                                                                                                                                                                                         )
;                                                                                                                                                                                     )
;                                                                                                                                                                                 )
;                                                                                                                                                                             )
;                                                                                                                                                                         )
;                                                                                                                                                                     )
;                                                                                                                                                                 )
;                                                                                                                                                             )
;                                                                                                                                                         )
;                                                                                                                                                     )
;                                                                                                                                                 )
;                                                                                                                                             )
;                                                                                                                                         ) /\
;                                                                                                                                         (
;                                                                                                                                           forall
;                                                                                                                                             (any_result:
;                                                                                                                                             (
; 
;                                                                                                                                                   _:
;                                                                                                                                                     Prims.unit
;                                                                                                                                                 -> FStar.Calc.calc_pack
;                                                                                                                                                     [
;                                                                                                                                                       (
;                                                                                                                                                         fun
;                                                                                                                                                           x7
;                                                                                                                                                           y8
;                                                                                                                                                           ->
;                                                                                                                                                           x7 ==
;                                                                                                                                                           y8
;                                                                                                                                                           <:
;                                                                                                                                                           Type0
;                                                                                                                                                       );
;                                                                                                                                                       fun
;                                                                                                                                                         x5
;                                                                                                                                                         y6
;                                                                                                                                                         ->
;                                                                                                                                                         x5 ==
;                                                                                                                                                         y6
;                                                                                                                                                         <:
;                                                                                                                                                         Type0
;                                                                                                                                                     ]
;                                                                                                                                                     (
;                                                                                                                                                       (
;                                                                                                                                                         a +
;                                                                                                                                                         k *
;                                                                                                                                                         n
;                                                                                                                                                       ) %
;                                                                                                                                                       n -
;                                                                                                                                                       a %
;                                                                                                                                                       n
;                                                                                                                                                     )
;                                                                                                                                                     (
;                                                                                                                                                       n *
;                                                                                                                                                       k +
;                                                                                                                                                       n *
;                                                                                                                                                       (a /
;                                                                                                                                                       n) -
;                                                                                                                                                       n *
;                                                                                                                                                       ((
;                                                                                                                                                         a +
;                                                                                                                                                         k *
;                                                                                                                                                         n
;                                                                                                                                                       ) /
;                                                                                                                                                       n)
;                                                                                                                                                     )
; 
;                                                                                                                                             ))
;                                                                                                                                             (_:
;                                                                                                                                             Prims.unit)
;                                                                                                                                           .
;                                                                                                                                             (*  - Could not prove post-condition
; *)
;                                                                                                                                             (
;                                                                                                                                               n >
;                                                                                                                                               0 ==>
;                                                                                                                                               n <>
;                                                                                                                                               0
;                                                                                                                                             ) /\
;                                                                                                                                             (
;                                                                                                                                               forall
;                                                                                                                                                 (any_result:
;                                                                                                                                                 Prims.pos)
;                                                                                                                                               .
;                                                                                                                                                 n ==
;                                                                                                                                                 any_result ==>
;                                                                                                                                                 (
;                                                                                                                                                   forall
;                                                                                                                                                     (any_result:
;                                                                                                                                                     Prims.int)
;                                                                                                                                                   .
;                                                                                                                                                     a /
;                                                                                                                                                     n ==
;                                                                                                                                                     any_result ==>
;                                                                                                                                                     (
;                                                                                                                                                       forall
;                                                                                                                                                         (pure_result:
;                                                                                                                                                         Prims.unit)
;                                                                                                                                                       .
;                                                                                                                                                         n *
;                                                                                                                                                         (
;                                                                                                                                                           k +
;                                                                                                                                                           a /
;                                                                                                                                                           n
;                                                                                                                                                         ) =
;                                                                                                                                                         n *
;                                                                                                                                                         k +
;                                                                                                                                                         n *
;                                                                                                                                                         (a /
;                                                                                                                                                         n) ==>
;                                                                                                                                                         (
;                                                                                                                                                           n >
;                                                                                                                                                           0 ==>
;                                                                                                                                                           n <>
;                                                                                                                                                           0
;                                                                                                                                                         ) /\
;                                                                                                                                                         (
;                                                                                                                                                           forall
;                                                                                                                                                             (any_result:
;                                                                                                                                                             Prims.pos)
;                                                                                                                                                           .
;                                                                                                                                                             n ==
;                                                                                                                                                             any_result ==>
;                                                                                                                                                             (
;                                                                                                                                                               forall
;                                                                                                                                                                 (any_result:
;                                                                                                                                                                 Prims.int)
;                                                                                                                                                               .
;                                                                                                                                                                 a /
;                                                                                                                                                                 n ==
;                                                                                                                                                                 any_result ==>
;                                                                                                                                                                 (
;                                                                                                                                                                   forall
;                                                                                                                                                                     (any_result:
;                                                                                                                                                                     Prims.int)
;                                                                                                                                                                   .
;                                                                                                                                                                     k +
;                                                                                                                                                                     a /
;                                                                                                                                                                     n ==
;                                                                                                                                                                     any_result ==>
;                                                                                                                                                                     (
;                                                                                                                                                                       n >
;                                                                                                                                                                       0 ==>
;                                                                                                                                                                       n <>
;                                                                                                                                                                       0
;                                                                                                                                                                     ) /\
;                                                                                                                                                                     (
;                                                                                                                                                                       forall
;                                                                                                                                                                         (any_result:
;                                                                                                                                                                         Prims.pos)
;                                                                                                                                                                       .
;                                                                                                                                                                         n ==
;                                                                                                                                                                         any_result ==>
;                                                                                                                                                                         (
;                                                                                                                                                                           forall
;                                                                                                                                                                             (any_result:
;                                                                                                                                                                             Prims.int)
;                                                                                                                                                                           .
;                                                                                                                                                                             (
;                                                                                                                                                                               a +
;                                                                                                                                                                               k *
;                                                                                                                                                                               n
;                                                                                                                                                                             ) /
;                                                                                                                                                                             n ==
;                                                                                                                                                                             any_result ==>
;                                                                                                                                                                             (
;                                                                                                                                                                               forall
;                                                                                                                                                                                 (pure_result:
;                                                                                                                                                                                 Prims.unit)
;                                                                                                                                                                               .
;                                                                                                                                                                                 n *
;                                                                                                                                                                                 (
;                                                                                                                                                                                   k +
;                                                                                                                                                                                   a /
;                                                                                                                                                                                   n -
;                                                                                                                                                                                   (
;                                                                                                                                                                                     a +
;                                                                                                                                                                                     k *
;                                                                                                                                                                                     n
;                                                                                                                                                                                   ) /
;                                                                                                                                                                                   n
;                                                                                                                                                                                 ) =
;                                                                                                                                                                                 n *
;                                                                                                                                                                                 (
;                                                                                                                                                                                   k +
;                                                                                                                                                                                   a /
;                                                                                                                                                                                   n
;                                                                                                                                                                                 ) -
;                                                                                                                                                                                 n *
;                                                                                                                                                                                 ((
;                                                                                                                                                                                   a +
;                                                                                                                                                                                   k *
;                                                                                                                                                                                   n
;                                                                                                                                                                                 ) /
;                                                                                                                                                                                 n) ==>
;                                                                                                                                                                                 n *
;                                                                                                                                                                                 k +
;                                                                                                                                                                                 n *
;                                                                                                                                                                                 (a /
;                                                                                                                                                                                 n) -
;                                                                                                                                                                                 n *
;                                                                                                                                                                                 ((
;                                                                                                                                                                                   a +
;                                                                                                                                                                                   k *
;                                                                                                                                                                                   n
;                                                                                                                                                                                 ) /
;                                                                                                                                                                                 n) ==
;                                                                                                                                                                                 n *
;                                                                                                                                                                                 (
;                                                                                                                                                                                   k +
;                                                                                                                                                                                   a /
;                                                                                                                                                                                   n -
;                                                                                                                                                                                   (
;                                                                                                                                                                                     a +
;                                                                                                                                                                                     k *
;                                                                                                                                                                                     n
;                                                                                                                                                                                   ) /
;                                                                                                                                                                                   n
;                                                                                                                                                                                 )
;                                                                                                                                                                             )
;                                                                                                                                                                         )
;                                                                                                                                                                     )
;                                                                                                                                                                 )
;                                                                                                                                                             )
;                                                                                                                                                         )
;                                                                                                                                                     )
;                                                                                                                                                 )
;                                                                                                                                             )
;                                                                                                                                         )
;                                                                                                                                     )
;                                                                                                                                 )
;                                                                                                                             )
;                                                                                                                         )
;                                                                                                                     )
;                                                                                                                 )
;                                                                                                             )
;                                                                                                         )
;                                                                                                     )
;                                                                                                 ))))
;                                                                                 )))))))) /\
;                                                     (forall (any_result:
;                                                         (_: Prims.unit
;                                                             -> FStar.Calc.calc_pack [
;                                                                   (fun x9 y10 -> x9 == y10 <: Type0);
;                                                                   (fun x7 y8 -> x7 == y8 <: Type0);
;                                                                   fun x5 y6 -> x5 == y6 <: Type0
;                                                                 ]
;                                                                 ((a + k * n) % n - a % n)
;                                                                 (n * (k + a / n - (a + k * n) / n))))
;                                                       .
;                                                         FStar.Range.labeled (FStar.Sealed.seal FStar.Calc.fsti(86,37-86,50)
;                                                             )
;                                                           "Could not prove that this calc-chain is compatible"
;                                                           (forall (x: Prims.int) (y: Prims.int).
;                                                               (exists (w: Prims.int).
;                                                                   (exists (w: Prims.int).
;                                                                       (exists (w: Prims.int).
;                                                                           x == w /\ w == w) /\
;                                                                       w == w) /\ w == y) ==>
;                                                               x == y) /\
;                                                         (forall (pure_result: Prims.unit).
;                                                             (a + k * n) % n - a % n ==
;                                                             n * (k + a / n - (a + k * n) / n) ==>
;                                                             (n > 0 ==> n <> 0) /\
;                                                             (forall (any_result: Prims.pos).
;                                                                 n == any_result ==>
;                                                                 (forall (any_result: Prims.int).
;                                                                     (a + k * n) % n == any_result ==>
;                                                                     (a + k * n) % n >= 0 /\
;                                                                     (forall (return_val: Prims.nat).
;                                                                         return_val ==
;                                                                         (a + k * n) % n ==>
;                                                                         (a + k * n) % n ==
;                                                                         return_val ==>
;                                                                         (n > 0 ==> n <> 0) /\
;                                                                         (forall (any_result:
;                                                                             Prims.pos).
;                                                                             n == any_result ==>
;                                                                             (forall (any_result:
;                                                                                 Prims.int).
;                                                                                 a % n == any_result ==>
;                                                                                 a % n >= 0 /\
;                                                                                 (forall (return_val:
;                                                                                     Prims.nat).
;                                                                                     return_val ==
;                                                                                     a % n ==>
;                                                                                     a % n ==
;                                                                                     return_val ==>
;                                                                                     (n > 0 ==>
;                                                                                       n <> 0) /\
;                                                                                     (forall (any_result:
;                                                                                         Prims.pos).
;                                                                                         n ==
;                                                                                         any_result ==>
;                                                                                         (forall (any_result:
;                                                                                             Prims.int)
;                                                                                           .
;                                                                                             a / n ==
;                                                                                             any_result ==>
;                                                                                             (forall (any_result:
;                                                                                                 Prims.int)
;                                                                                               .
;                                                                                                 k +
;                                                                                                 a /
;                                                                                                 n ==
;                                                                                                 any_result ==>
;                                                                                                 (n >
;                                                                                                   0 ==>
;                                                                                                   n <>
;                                                                                                   0) /\
;                                                                                                 (forall
;                                                                                                     (any_result:
;                                                                                                     Prims.pos)
;                                                                                                   .
;                                                                                                     n ==
;                                                                                                     any_result ==>
;                                                                                                     (
;                                                                                                       forall
;                                                                                                         (any_result:
;                                                                                                         Prims.int)
;                                                                                                       .
;                                                                                                         (
;                                                                                                           a +
;                                                                                                           k *
;                                                                                                           n
;                                                                                                         ) /
;                                                                                                         n ==
;                                                                                                         any_result ==>
;                                                                                                         (
;                                                                                                           forall
;                                                                                                             (any_result:
;                                                                                                             Prims.int)
;                                                                                                           .
;                                                                                                             k +
;                                                                                                             a /
;                                                                                                             n -
;                                                                                                             (
;                                                                                                               a +
;                                                                                                               k *
;                                                                                                               n
;                                                                                                             ) /
;                                                                                                             n ==
;                                                                                                             any_result ==>
;                                                                                                             (
;                                                                                                               n >
;                                                                                                               0 ==>
;                                                                                                               n <>
;                                                                                                               0
;                                                                                                             ) /\
;                                                                                                             (
;                                                                                                               forall
;                                                                                                                 (any_result:
;                                                                                                                 Prims.pos)
;                                                                                                               .
;                                                                                                                 n ==
;                                                                                                                 any_result ==>
;                                                                                                                 (
;                                                                                                                   a +
;                                                                                                                   k *
;                                                                                                                   n
;                                                                                                                 ) %
;                                                                                                                 n <
;                                                                                                                 n /\
;                                                                                                                 a %
;                                                                                                                 n <
;                                                                                                                 n /\
;                                                                                                                 (
;                                                                                                                   a +
;                                                                                                                   k *
;                                                                                                                   n
;                                                                                                                 ) %
;                                                                                                                 n ==
;                                                                                                                 a %
;                                                                                                                 n +
;                                                                                                                 (
;                                                                                                                   k +
;                                                                                                                   a /
;                                                                                                                   n -
;                                                                                                                   (
;                                                                                                                     a +
;                                                                                                                     k *
;                                                                                                                     n
;                                                                                                                   ) /
;                                                                                                                   n
;                                                                                                                 ) *
;                                                                                                                 n /\
;                                                                                                                 (
;                                                                                                                   forall
;                                                                                                                     (pure_result:
;                                                                                                                     Prims.unit)
;                                                                                                                   .
;                                                                                                                     (
;                                                                                                                       a +
;                                                                                                                       k *
;                                                                                                                       n
;                                                                                                                     ) %
;                                                                                                                     n ==
;                                                                                                                     a %
;                                                                                                                     n /\
;                                                                                                                     k +
;                                                                                                                     a /
;                                                                                                                     n -
;                                                                                                                     (
;                                                                                                                       a +
;                                                                                                                       k *
;                                                                                                                       n
;                                                                                                                     ) /
;                                                                                                                     n ==
;                                                                                                                     0 ==>
;                                                                                                                     (
;                                                                                                                       forall
;                                                                                                                         (any_result:
;                                                                                                                         Prims.unit)
;                                                                                                                       .
;                                                                                                                         p
;                                                                                                                           any_result
; 
;                                                                                                                     )
;                                                                                                                 )
;                                                                                                             )
;                                                                                                         )
;                                                                                                     )
;                                                                                                 ))))
;                                                                                 ))))))))))))))))))))
; Context: While encoding a query
; While typechecking the top-level declaration `let lemma_mod_plus`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term) (@x2 Term))
    (! (implies
      (and (HasType @x0 Prims.int) (HasType @x1 Prims.int) (HasType @x2 Prims.pos))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x3 Term))
       (! (implies
         (and
          (HasType @x3 (Prims.pure_post Prims.unit))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(219,2-230,4)
          (forall ((@x4 Term))
           (! (implies
             (and
              (or label_1 (HasType @x4 Prims.unit))
              ;; def=FStar.Math.Lemmas.fsti(194,51-194,76); use=FStar.Math.Lemmas.fst(219,2-230,4)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fsti(194,51-194,76); use=FStar.Math.Lemmas.fst(219,2-230,4)
               (=
                (Prims.op_Modulus (Prims.op_Addition @x0 (Prims.op_Multiply @x1 @x2)) @x2)
                (Prims.op_Modulus @x0 @x2))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(219,2-230,4)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(219,2-230,4)
              (ApplyTT @x3 @x4)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(219,2-230,4)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(219,2-230,4)
               (ApplyTT @x3 @x4)))
            :qid @query.2)))
         ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(219,2-230,4)
         (and
          (implies
           ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(220,12-220,13)
           (> (BoxInt_proj_0 @x2) (BoxInt_proj_0 (BoxInt 0)))
           ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(220,12-220,13)
           (or
            label_3
            ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(220,12-220,13)
            (not (= @x2 (BoxInt 0)))))
          ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-230,4)
          (forall ((@x4 Term))
           (! (implies
             (and
              (HasType @x4 Prims.pos)
              ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-230,4)
              (= @x2 @x4))
             ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-230,4)
             (forall ((@x5 Term))
              (! (implies
                (and
                 (HasType @x5 Prims.int)
                 ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-230,4)
                 (= (Prims.op_Modulus (Prims.op_Addition @x0 (Prims.op_Multiply @x1 @x2)) @x2) @x5))
                ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(219,2-230,4)
                (and
                 (implies
                  ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(220,18-220,19)
                  (> (BoxInt_proj_0 @x2) (BoxInt_proj_0 (BoxInt 0)))
                  ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(220,18-220,19)
                  (or
                   label_4
                   ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(220,18-220,19)
                   (not (= @x2 (BoxInt 0)))))
                 ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-230,4)
                 (forall ((@x6 Term))
                  (! (implies
                    (and
                     (HasType @x6 Prims.pos)
                     ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-230,4)
                     (= @x2 @x6))
                    ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-230,4)
                    (forall ((@x7 Term))
                     (! (implies
                       (and
                        (HasType @x7 Prims.int)
                        ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-230,4)
                        (= (Prims.op_Modulus @x0 @x2) @x7))
                       ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-230,4)
                       (forall ((@x8 Term))
                        (! (implies
                          (and
                           (HasType @x8 Prims.int)
                           ;; def=FStar.Calc.fsti(79,4-79,5); use=FStar.Math.Lemmas.fst(219,2-230,4)
                           (=
                            (Prims.op_Subtraction
                             (Prims.op_Modulus
                              (Prims.op_Addition @x0 (Prims.op_Multiply @x1 @x2))
                              @x2)
                             (Prims.op_Modulus @x0 @x2))
                            @x8))
                          ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(219,2-230,4)
                          (and
                           (implies
                            ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(227,15-227,16)
                            (> (BoxInt_proj_0 @x2) (BoxInt_proj_0 (BoxInt 0)))
                            ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(227,15-227,16)
                            (or
                             label_5
                             ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(227,15-227,16)
                             (not (= @x2 (BoxInt 0)))))
                           ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-230,4)
                           (forall ((@x9 Term))
                            (! (implies
                              (and
                               (HasType @x9 Prims.pos)
                               ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-230,4)
                               (= @x2 @x9))
                              ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-230,4)
                              (forall ((@x10 Term))
                               (! (implies
                                 (and
                                  (HasType @x10 Prims.int)
                                  ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                  (= (Prims.op_Division @x0 @x2) @x10))
                                 ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                 (forall ((@x11 Term))
                                  (! (implies
                                    (and
                                     (HasType @x11 Prims.int)
                                     ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                     (= (Prims.op_Addition @x1 (Prims.op_Division @x0 @x2)) @x11))
                                    ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                    (and
                                     (implies
                                      ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(227,27-227,28)
                                      (> (BoxInt_proj_0 @x2) (BoxInt_proj_0 (BoxInt 0)))
                                      ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(227,27-227,28)
                                      (or
                                       label_6
                                       ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(227,27-227,28)
                                       (not (= @x2 (BoxInt 0)))))
                                     ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                     (forall ((@x12 Term))
                                      (! (implies
                                        (and
                                         (HasType @x12 Prims.pos)
                                         ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                         (= @x2 @x12))
                                        ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                        (forall ((@x13 Term))
                                         (! (implies
                                           (and
                                            (HasType @x13 Prims.int)
                                            ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                            (=
                                             (Prims.op_Division
                                              (Prims.op_Addition @x0 (Prims.op_Multiply @x1 @x2))
                                              @x2)
                                             @x13))
                                           ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                           (forall ((@x14 Term))
                                            (! (implies
                                              (and
                                               (HasType @x14 Prims.int)
                                               ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                               (=
                                                (Prims.op_Subtraction
                                                 (Prims.op_Addition @x1 (Prims.op_Division @x0 @x2))
                                                 (Prims.op_Division
                                                  (Prims.op_Addition @x0 (Prims.op_Multiply @x1 @x2))
                                                  @x2))
                                                @x14))
                                              ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                              (forall ((@x15 Term))
                                               (! (implies
                                                 (and
                                                  (HasType @x15 Prims.int)
                                                  ;; def=FStar.Calc.fsti(79,7-79,8); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                  (=
                                                   (Prims.op_Multiply
                                                    @x2
                                                    (Prims.op_Subtraction
                                                     (Prims.op_Addition
                                                      @x1
                                                      (Prims.op_Division @x0 @x2))
                                                     (Prims.op_Division
                                                      (Prims.op_Addition
                                                       @x0
                                                       (Prims.op_Multiply @x1 @x2))
                                                      @x2)))
                                                   @x15))
                                                 ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                 (and
                                                  ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                  (forall ((@x16 Term))
                                                   (! (implies
                                                     (HasType @x16 Prims.unit)
                                                     ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                     (and
                                                      (implies
                                                       ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(220,12-220,13)
                                                       (>
                                                        (BoxInt_proj_0 @x2)
                                                        (BoxInt_proj_0 (BoxInt 0)))
                                                       ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(220,12-220,13)
                                                       (or
                                                        label_7
                                                        ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(220,12-220,13)
                                                        (not (= @x2 (BoxInt 0)))))
                                                      ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                      (forall ((@x17 Term))
                                                       (! (implies
                                                         (and
                                                          (HasType @x17 Prims.pos)
                                                          ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                          (= @x2 @x17))
                                                         ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                         (forall ((@x18 Term))
                                                          (! (implies
                                                            (and
                                                             (HasType @x18 Prims.int)
                                                             ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                             (=
                                                              (Prims.op_Modulus
                                                               (Prims.op_Addition
                                                                @x0
                                                                (Prims.op_Multiply @x1 @x2))
                                                               @x2)
                                                              @x18))
                                                            ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                            (and
                                                             (implies
                                                              ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(220,18-220,19)
                                                              (>
                                                               (BoxInt_proj_0 @x2)
                                                               (BoxInt_proj_0 (BoxInt 0)))
                                                              ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(220,18-220,19)
                                                              (or
                                                               label_8
                                                               ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(220,18-220,19)
                                                               (not (= @x2 (BoxInt 0)))))
                                                             ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                             (forall ((@x19 Term))
                                                              (! (implies
                                                                (and
                                                                 (HasType @x19 Prims.pos)
                                                                 ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                 (= @x2 @x19))
                                                                ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                (forall ((@x20 Term))
                                                                 (! (implies
                                                                   (and
                                                                    (HasType @x20 Prims.int)
                                                                    ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                    (=
                                                                     (Prims.op_Modulus @x0 @x2)
                                                                     @x20))
                                                                   ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                   (forall ((@x21 Term))
                                                                    (! (implies
                                                                      (and
                                                                       (HasType @x21 Prims.int)
                                                                       ;; def=FStar.Calc.fsti(65,4-65,5); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                       (=
                                                                        (Prims.op_Subtraction
                                                                         (Prims.op_Modulus
                                                                          (Prims.op_Addition
                                                                           @x0
                                                                           (Prims.op_Multiply
                                                                            @x1
                                                                            @x2))
                                                                          @x2)
                                                                         (Prims.op_Modulus @x0 @x2))
                                                                        @x21))
                                                                      ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                      (and
                                                                       (implies
                                                                        ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(224,15-224,16)
                                                                        (>
                                                                         (BoxInt_proj_0 @x2)
                                                                         (BoxInt_proj_0 (BoxInt 0)))
                                                                        ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(224,15-224,16)
                                                                        (or
                                                                         label_9
                                                                         ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(224,15-224,16)
                                                                         (not (= @x2 (BoxInt 0)))))
                                                                       ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                       (forall ((@x22 Term))
                                                                        (! (implies
                                                                          (and
                                                                           (HasType @x22 Prims.pos)
                                                                           ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                           (= @x2 @x22))
                                                                          ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                          (forall ((@x23 Term))
                                                                           (! (implies
                                                                             (and
                                                                              (HasType
                                                                               @x23
                                                                               Prims.int)
                                                                              ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                              (=
                                                                               (Prims.op_Division
                                                                                @x0
                                                                                @x2)
                                                                               @x23))
                                                                             ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                             (forall ((@x24 Term))
                                                                              (! (implies
                                                                                (and
                                                                                 (HasType
                                                                                  @x24
                                                                                  Prims.int)
                                                                                 ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                 (=
                                                                                  (Prims.op_Multiply
                                                                                   @x2
                                                                                   (Prims.op_Division
                                                                                    @x0
                                                                                    @x2))
                                                                                  @x24))
                                                                                ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                (forall
                                                                                  ((@x25 Term))
                                                                                 (! (implies
                                                                                   (and
                                                                                    (HasType
                                                                                     @x25
                                                                                     Prims.int)
                                                                                    ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                    (=
                                                                                     (Prims.op_Addition
                                                                                      (Prims.op_Multiply
                                                                                       @x2
                                                                                       @x1)
                                                                                      (Prims.op_Multiply
                                                                                       @x2
                                                                                       (Prims.op_Division
                                                                                        @x0
                                                                                        @x2)))
                                                                                     @x25))
                                                                                   ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                   (and
                                                                                    (implies
                                                                                     ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(224,33-224,34)
                                                                                     (>
                                                                                      (BoxInt_proj_0
                                                                                       @x2)
                                                                                      (BoxInt_proj_0
                                                                                       (BoxInt 0)))
                                                                                     ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(224,33-224,34)
                                                                                     (or
                                                                                      label_10
                                                                                      ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(224,33-224,34)
                                                                                      (not
                                                                                       (=
                                                                                        @x2
                                                                                        (BoxInt 0)))))
                                                                                    ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                    (forall
                                                                                      ((@x26 Term))
                                                                                     (! (implies
                                                                                       (and
                                                                                        (HasType
                                                                                         @x26
                                                                                         Prims.pos)
                                                                                        ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                        (= @x2 @x26))
                                                                                       ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                       (forall
                                                                                         ((@x27 Term))
                                                                                        (! (implies
                                                                                          (and
                                                                                           (HasType
                                                                                            @x27
                                                                                            Prims.int)
                                                                                           ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                           (=
                                                                                            (Prims.op_Division
                                                                                             (Prims.op_Addition
                                                                                              @x0
                                                                                              (Prims.op_Multiply
                                                                                               @x1
                                                                                               @x2))
                                                                                             @x2)
                                                                                            @x27))
                                                                                          ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                          (forall
                                                                                            ((@x28
                                                                                              Term))
                                                                                           (! (implies
                                                                                             (and
                                                                                              (HasType
                                                                                               @x28
                                                                                               Prims.int)
                                                                                              ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                              (=
                                                                                               (Prims.op_Multiply
                                                                                                @x2
                                                                                                (Prims.op_Division
                                                                                                 (Prims.op_Addition
                                                                                                  @x0
                                                                                                  (Prims.op_Multiply
                                                                                                   @x1
                                                                                                   @x2))
                                                                                                 @x2))
                                                                                               @x28))
                                                                                             ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                             (forall
                                                                                               ((@x29
                                                                                                 Term))
                                                                                              (! (implies
                                                                                                (and
                                                                                                 (HasType
                                                                                                  @x29
                                                                                                  Prims.int)
                                                                                                 ;; def=FStar.Calc.fsti(65,7-65,8); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                 (=
                                                                                                  (Prims.op_Subtraction
                                                                                                   (Prims.op_Addition
                                                                                                    (Prims.op_Multiply
                                                                                                     @x2
                                                                                                     @x1)
                                                                                                    (Prims.op_Multiply
                                                                                                     @x2
                                                                                                     (Prims.op_Division
                                                                                                      @x0
                                                                                                      @x2)))
                                                                                                   (Prims.op_Multiply
                                                                                                    @x2
                                                                                                    (Prims.op_Division
                                                                                                     (Prims.op_Addition
                                                                                                      @x0
                                                                                                      (Prims.op_Multiply
                                                                                                       @x1
                                                                                                       @x2))
                                                                                                     @x2)))
                                                                                                  @x29))
                                                                                                ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                (and
                                                                                                 (implies
                                                                                                  ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(227,15-227,16)
                                                                                                  (>
                                                                                                   (BoxInt_proj_0
                                                                                                    @x2)
                                                                                                   (BoxInt_proj_0
                                                                                                    (BoxInt
                                                                                                     0)))
                                                                                                  ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(227,15-227,16)
                                                                                                  (or
                                                                                                   label_11
                                                                                                   ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(227,15-227,16)
                                                                                                   (not
                                                                                                    (=
                                                                                                     @x2
                                                                                                     (BoxInt
                                                                                                      0)))))
                                                                                                 ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                 (forall
                                                                                                   ((@x30
                                                                                                     Term))
                                                                                                  (! (implies
                                                                                                    (and
                                                                                                     (HasType
                                                                                                      @x30
                                                                                                      Prims.pos)
                                                                                                     ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                     (=
                                                                                                      @x2
                                                                                                      @x30))
                                                                                                    ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                    (forall
                                                                                                      ((@x31
                                                                                                        Term))
                                                                                                     (! (implies
                                                                                                       (and
                                                                                                        (HasType
                                                                                                         @x31
                                                                                                         Prims.int)
                                                                                                        ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                        (=
                                                                                                         (Prims.op_Division
                                                                                                          @x0
                                                                                                          @x2)
                                                                                                         @x31))
                                                                                                       ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                       (forall
                                                                                                         ((@x32
                                                                                                           Term))
                                                                                                        (! (implies
                                                                                                          (and
                                                                                                           (HasType
                                                                                                            @x32
                                                                                                            Prims.int)
                                                                                                           ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                           (=
                                                                                                            (Prims.op_Addition
                                                                                                             @x1
                                                                                                             (Prims.op_Division
                                                                                                              @x0
                                                                                                              @x2))
                                                                                                            @x32))
                                                                                                          ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                          (and
                                                                                                           (implies
                                                                                                            ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(227,27-227,28)
                                                                                                            (>
                                                                                                             (BoxInt_proj_0
                                                                                                              @x2)
                                                                                                             (BoxInt_proj_0
                                                                                                              (BoxInt
                                                                                                               0)))
                                                                                                            ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(227,27-227,28)
                                                                                                            (or
                                                                                                             label_12
                                                                                                             ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(227,27-227,28)
                                                                                                             (not
                                                                                                              (=
                                                                                                               @x2
                                                                                                               (BoxInt
                                                                                                                0)))))
                                                                                                           ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                           (forall
                                                                                                             ((@x33
                                                                                                               Term))
                                                                                                            (! (implies
                                                                                                              (and
                                                                                                               (HasType
                                                                                                                @x33
                                                                                                                Prims.pos)
                                                                                                               ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                               (=
                                                                                                                @x2
                                                                                                                @x33))
                                                                                                              ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                              (forall
                                                                                                                ((@x34
                                                                                                                  Term))
                                                                                                               (! (implies
                                                                                                                 (and
                                                                                                                  (HasType
                                                                                                                   @x34
                                                                                                                   Prims.int)
                                                                                                                  ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                  (=
                                                                                                                   (Prims.op_Division
                                                                                                                    (Prims.op_Addition
                                                                                                                     @x0
                                                                                                                     (Prims.op_Multiply
                                                                                                                      @x1
                                                                                                                      @x2))
                                                                                                                    @x2)
                                                                                                                   @x34))
                                                                                                                 ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                 (forall
                                                                                                                   ((@x35
                                                                                                                     Term))
                                                                                                                  (! (implies
                                                                                                                    (and
                                                                                                                     (HasType
                                                                                                                      @x35
                                                                                                                      Prims.int)
                                                                                                                     ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                     (=
                                                                                                                      (Prims.op_Subtraction
                                                                                                                       (Prims.op_Addition
                                                                                                                        @x1
                                                                                                                        (Prims.op_Division
                                                                                                                         @x0
                                                                                                                         @x2))
                                                                                                                       (Prims.op_Division
                                                                                                                        (Prims.op_Addition
                                                                                                                         @x0
                                                                                                                         (Prims.op_Multiply
                                                                                                                          @x1
                                                                                                                          @x2))
                                                                                                                        @x2))
                                                                                                                      @x35))
                                                                                                                    ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                    (forall
                                                                                                                      ((@x36
                                                                                                                        Term))
                                                                                                                     (! (implies
                                                                                                                       (and
                                                                                                                        (HasType
                                                                                                                         @x36
                                                                                                                         Prims.int)
                                                                                                                        ;; def=FStar.Calc.fsti(67,3-67,4); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                        (=
                                                                                                                         (Prims.op_Multiply
                                                                                                                          @x2
                                                                                                                          (Prims.op_Subtraction
                                                                                                                           (Prims.op_Addition
                                                                                                                            @x1
                                                                                                                            (Prims.op_Division
                                                                                                                             @x0
                                                                                                                             @x2))
                                                                                                                           (Prims.op_Division
                                                                                                                            (Prims.op_Addition
                                                                                                                             @x0
                                                                                                                             (Prims.op_Multiply
                                                                                                                              @x1
                                                                                                                              @x2))
                                                                                                                            @x2)))
                                                                                                                         @x36))
                                                                                                                       ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                       (and
                                                                                                                        ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                        (forall
                                                                                                                          ((@x37
                                                                                                                            Term))
                                                                                                                         (! (implies
                                                                                                                           (HasType
                                                                                                                            @x37
                                                                                                                            Prims.unit)
                                                                                                                           ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                           (and
                                                                                                                            (implies
                                                                                                                             ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(220,12-220,13)
                                                                                                                             (>
                                                                                                                              (BoxInt_proj_0
                                                                                                                               @x2)
                                                                                                                              (BoxInt_proj_0
                                                                                                                               (BoxInt
                                                                                                                                0)))
                                                                                                                             ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(220,12-220,13)
                                                                                                                             (or
                                                                                                                              label_13
                                                                                                                              ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(220,12-220,13)
                                                                                                                              (not
                                                                                                                               (=
                                                                                                                                @x2
                                                                                                                                (BoxInt
                                                                                                                                 0)))))
                                                                                                                            ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                            (forall
                                                                                                                              ((@x38
                                                                                                                                Term))
                                                                                                                             (! (implies
                                                                                                                               (and
                                                                                                                                (HasType
                                                                                                                                 @x38
                                                                                                                                 Prims.pos)
                                                                                                                                ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                (=
                                                                                                                                 @x2
                                                                                                                                 @x38))
                                                                                                                               ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                               (forall
                                                                                                                                 ((@x39
                                                                                                                                   Term))
                                                                                                                                (! (implies
                                                                                                                                  (and
                                                                                                                                   (HasType
                                                                                                                                    @x39
                                                                                                                                    Prims.int)
                                                                                                                                   ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                   (=
                                                                                                                                    (Prims.op_Modulus
                                                                                                                                     (Prims.op_Addition
                                                                                                                                      @x0
                                                                                                                                      (Prims.op_Multiply
                                                                                                                                       @x1
                                                                                                                                       @x2))
                                                                                                                                     @x2)
                                                                                                                                    @x39))
                                                                                                                                  ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                  (and
                                                                                                                                   (implies
                                                                                                                                    ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(220,18-220,19)
                                                                                                                                    (>
                                                                                                                                     (BoxInt_proj_0
                                                                                                                                      @x2)
                                                                                                                                     (BoxInt_proj_0
                                                                                                                                      (BoxInt
                                                                                                                                       0)))
                                                                                                                                    ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(220,18-220,19)
                                                                                                                                    (or
                                                                                                                                     label_14
                                                                                                                                     ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(220,18-220,19)
                                                                                                                                     (not
                                                                                                                                      (=
                                                                                                                                       @x2
                                                                                                                                       (BoxInt
                                                                                                                                        0)))))
                                                                                                                                   ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                   (forall
                                                                                                                                     ((@x40
                                                                                                                                       Term))
                                                                                                                                    (! (implies
                                                                                                                                      (and
                                                                                                                                       (HasType
                                                                                                                                        @x40
                                                                                                                                        Prims.pos)
                                                                                                                                       ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                       (=
                                                                                                                                        @x2
                                                                                                                                        @x40))
                                                                                                                                      ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                      (forall
                                                                                                                                        ((@x41
                                                                                                                                          Term))
                                                                                                                                       (! (implies
                                                                                                                                         (and
                                                                                                                                          (HasType
                                                                                                                                           @x41
                                                                                                                                           Prims.int)
                                                                                                                                          ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                          (=
                                                                                                                                           (Prims.op_Modulus
                                                                                                                                            @x0
                                                                                                                                            @x2)
                                                                                                                                           @x41))
                                                                                                                                         ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                         (forall
                                                                                                                                           ((@x42
                                                                                                                                             Term))
                                                                                                                                          (! (implies
                                                                                                                                            (and
                                                                                                                                             (HasType
                                                                                                                                              @x42
                                                                                                                                              Prims.int)
                                                                                                                                             ;; def=FStar.Calc.fsti(65,4-65,5); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                             (=
                                                                                                                                              (Prims.op_Subtraction
                                                                                                                                               (Prims.op_Modulus
                                                                                                                                                (Prims.op_Addition
                                                                                                                                                 @x0
                                                                                                                                                 (Prims.op_Multiply
                                                                                                                                                  @x1
                                                                                                                                                  @x2))
                                                                                                                                                @x2)
                                                                                                                                               (Prims.op_Modulus
                                                                                                                                                @x0
                                                                                                                                                @x2))
                                                                                                                                              @x42))
                                                                                                                                            ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                            (and
                                                                                                                                             (implies
                                                                                                                                              ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(222,30-222,31)
                                                                                                                                              (>
                                                                                                                                               (BoxInt_proj_0
                                                                                                                                                @x2)
                                                                                                                                               (BoxInt_proj_0
                                                                                                                                                (BoxInt
                                                                                                                                                 0)))
                                                                                                                                              ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(222,30-222,31)
                                                                                                                                              (or
                                                                                                                                               label_15
                                                                                                                                               ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(222,30-222,31)
                                                                                                                                               (not
                                                                                                                                                (=
                                                                                                                                                 @x2
                                                                                                                                                 (BoxInt
                                                                                                                                                  0)))))
                                                                                                                                             ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                             (forall
                                                                                                                                               ((@x43
                                                                                                                                                 Term))
                                                                                                                                              (! (implies
                                                                                                                                                (and
                                                                                                                                                 (HasType
                                                                                                                                                  @x43
                                                                                                                                                  Prims.pos)
                                                                                                                                                 ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                 (=
                                                                                                                                                  @x2
                                                                                                                                                  @x43))
                                                                                                                                                ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                (forall
                                                                                                                                                  ((@x44
                                                                                                                                                    Term))
                                                                                                                                                 (! (implies
                                                                                                                                                   (and
                                                                                                                                                    (HasType
                                                                                                                                                     @x44
                                                                                                                                                     Prims.int)
                                                                                                                                                    ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                    (=
                                                                                                                                                     (Prims.op_Division
                                                                                                                                                      (Prims.op_Addition
                                                                                                                                                       @x0
                                                                                                                                                       (Prims.op_Multiply
                                                                                                                                                        @x1
                                                                                                                                                        @x2))
                                                                                                                                                      @x2)
                                                                                                                                                     @x44))
                                                                                                                                                   ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                   (forall
                                                                                                                                                     ((@x45
                                                                                                                                                       Term))
                                                                                                                                                    (! (implies
                                                                                                                                                      (and
                                                                                                                                                       (HasType
                                                                                                                                                        @x45
                                                                                                                                                        Prims.int)
                                                                                                                                                       ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                       (=
                                                                                                                                                        (Prims.op_Multiply
                                                                                                                                                         @x2
                                                                                                                                                         (Prims.op_Division
                                                                                                                                                          (Prims.op_Addition
                                                                                                                                                           @x0
                                                                                                                                                           (Prims.op_Multiply
                                                                                                                                                            @x1
                                                                                                                                                            @x2))
                                                                                                                                                          @x2))
                                                                                                                                                        @x45))
                                                                                                                                                      ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                      (forall
                                                                                                                                                        ((@x46
                                                                                                                                                          Term))
                                                                                                                                                       (! (implies
                                                                                                                                                         (and
                                                                                                                                                          (HasType
                                                                                                                                                           @x46
                                                                                                                                                           Prims.int)
                                                                                                                                                          ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                          (=
                                                                                                                                                           (Prims.op_Subtraction
                                                                                                                                                            (Prims.op_Addition
                                                                                                                                                             @x0
                                                                                                                                                             (Prims.op_Multiply
                                                                                                                                                              @x1
                                                                                                                                                              @x2))
                                                                                                                                                            (Prims.op_Multiply
                                                                                                                                                             @x2
                                                                                                                                                             (Prims.op_Division
                                                                                                                                                              (Prims.op_Addition
                                                                                                                                                               @x0
                                                                                                                                                               (Prims.op_Multiply
                                                                                                                                                                @x1
                                                                                                                                                                @x2))
                                                                                                                                                              @x2)))
                                                                                                                                                           @x46))
                                                                                                                                                         ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                         (and
                                                                                                                                                          (implies
                                                                                                                                                           ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(222,46-222,47)
                                                                                                                                                           (>
                                                                                                                                                            (BoxInt_proj_0
                                                                                                                                                             @x2)
                                                                                                                                                            (BoxInt_proj_0
                                                                                                                                                             (BoxInt
                                                                                                                                                              0)))
                                                                                                                                                           ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(222,46-222,47)
                                                                                                                                                           (or
                                                                                                                                                            label_16
                                                                                                                                                            ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(222,46-222,47)
                                                                                                                                                            (not
                                                                                                                                                             (=
                                                                                                                                                              @x2
                                                                                                                                                              (BoxInt
                                                                                                                                                               0)))))
                                                                                                                                                          ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                          (forall
                                                                                                                                                            ((@x47
                                                                                                                                                              Term))
                                                                                                                                                           (! (implies
                                                                                                                                                             (and
                                                                                                                                                              (HasType
                                                                                                                                                               @x47
                                                                                                                                                               Prims.pos)
                                                                                                                                                              ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                              (=
                                                                                                                                                               @x2
                                                                                                                                                               @x47))
                                                                                                                                                             ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                             (forall
                                                                                                                                                               ((@x48
                                                                                                                                                                 Term))
                                                                                                                                                              (! (implies
                                                                                                                                                                (and
                                                                                                                                                                 (HasType
                                                                                                                                                                  @x48
                                                                                                                                                                  Prims.int)
                                                                                                                                                                 ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                 (=
                                                                                                                                                                  (Prims.op_Division
                                                                                                                                                                   @x0
                                                                                                                                                                   @x2)
                                                                                                                                                                  @x48))
                                                                                                                                                                ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                (forall
                                                                                                                                                                  ((@x49
                                                                                                                                                                    Term))
                                                                                                                                                                 (! (implies
                                                                                                                                                                   (and
                                                                                                                                                                    (HasType
                                                                                                                                                                     @x49
                                                                                                                                                                     Prims.int)
                                                                                                                                                                    ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                    (=
                                                                                                                                                                     (Prims.op_Multiply
                                                                                                                                                                      @x2
                                                                                                                                                                      (Prims.op_Division
                                                                                                                                                                       @x0
                                                                                                                                                                       @x2))
                                                                                                                                                                     @x49))
                                                                                                                                                                   ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                   (forall
                                                                                                                                                                     ((@x50
                                                                                                                                                                       Term))
                                                                                                                                                                    (! (implies
                                                                                                                                                                      (and
                                                                                                                                                                       (HasType
                                                                                                                                                                        @x50
                                                                                                                                                                        Prims.int)
                                                                                                                                                                       ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                       (=
                                                                                                                                                                        (Prims.op_Subtraction
                                                                                                                                                                         @x0
                                                                                                                                                                         (Prims.op_Multiply
                                                                                                                                                                          @x2
                                                                                                                                                                          (Prims.op_Division
                                                                                                                                                                           @x0
                                                                                                                                                                           @x2)))
                                                                                                                                                                        @x50))
                                                                                                                                                                      ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                      (forall
                                                                                                                                                                        ((@x51
                                                                                                                                                                          Term))
                                                                                                                                                                       (! (implies
                                                                                                                                                                         (and
                                                                                                                                                                          (HasType
                                                                                                                                                                           @x51
                                                                                                                                                                           Prims.int)
                                                                                                                                                                          ;; def=FStar.Calc.fsti(65,7-65,8); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                          (=
                                                                                                                                                                           (Prims.op_Subtraction
                                                                                                                                                                            (Prims.op_Subtraction
                                                                                                                                                                             (Prims.op_Addition
                                                                                                                                                                              @x0
                                                                                                                                                                              (Prims.op_Multiply
                                                                                                                                                                               @x1
                                                                                                                                                                               @x2))
                                                                                                                                                                             (Prims.op_Multiply
                                                                                                                                                                              @x2
                                                                                                                                                                              (Prims.op_Division
                                                                                                                                                                               (Prims.op_Addition
                                                                                                                                                                                @x0
                                                                                                                                                                                (Prims.op_Multiply
                                                                                                                                                                                 @x1
                                                                                                                                                                                 @x2))
                                                                                                                                                                               @x2)))
                                                                                                                                                                            (Prims.op_Subtraction
                                                                                                                                                                             @x0
                                                                                                                                                                             (Prims.op_Multiply
                                                                                                                                                                              @x2
                                                                                                                                                                              (Prims.op_Division
                                                                                                                                                                               @x0
                                                                                                                                                                               @x2))))
                                                                                                                                                                           @x51))
                                                                                                                                                                         ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                         (and
                                                                                                                                                                          (implies
                                                                                                                                                                           ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(224,15-224,16)
                                                                                                                                                                           (>
                                                                                                                                                                            (BoxInt_proj_0
                                                                                                                                                                             @x2)
                                                                                                                                                                            (BoxInt_proj_0
                                                                                                                                                                             (BoxInt
                                                                                                                                                                              0)))
                                                                                                                                                                           ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(224,15-224,16)
                                                                                                                                                                           (or
                                                                                                                                                                            label_17
                                                                                                                                                                            ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(224,15-224,16)
                                                                                                                                                                            (not
                                                                                                                                                                             (=
                                                                                                                                                                              @x2
                                                                                                                                                                              (BoxInt
                                                                                                                                                                               0)))))
                                                                                                                                                                          ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                          (forall
                                                                                                                                                                            ((@x52
                                                                                                                                                                              Term))
                                                                                                                                                                           (! (implies
                                                                                                                                                                             (and
                                                                                                                                                                              (HasType
                                                                                                                                                                               @x52
                                                                                                                                                                               Prims.pos)
                                                                                                                                                                              ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                              (=
                                                                                                                                                                               @x2
                                                                                                                                                                               @x52))
                                                                                                                                                                             ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                             (forall
                                                                                                                                                                               ((@x53
                                                                                                                                                                                 Term))
                                                                                                                                                                              (! (implies
                                                                                                                                                                                (and
                                                                                                                                                                                 (HasType
                                                                                                                                                                                  @x53
                                                                                                                                                                                  Prims.int)
                                                                                                                                                                                 ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                 (=
                                                                                                                                                                                  (Prims.op_Division
                                                                                                                                                                                   @x0
                                                                                                                                                                                   @x2)
                                                                                                                                                                                  @x53))
                                                                                                                                                                                ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                (forall
                                                                                                                                                                                  ((@x54
                                                                                                                                                                                    Term))
                                                                                                                                                                                 (! (implies
                                                                                                                                                                                   (and
                                                                                                                                                                                    (HasType
                                                                                                                                                                                     @x54
                                                                                                                                                                                     Prims.int)
                                                                                                                                                                                    ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                    (=
                                                                                                                                                                                     (Prims.op_Multiply
                                                                                                                                                                                      @x2
                                                                                                                                                                                      (Prims.op_Division
                                                                                                                                                                                       @x0
                                                                                                                                                                                       @x2))
                                                                                                                                                                                     @x54))
                                                                                                                                                                                   ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                   (forall
                                                                                                                                                                                     ((@x55
                                                                                                                                                                                       Term))
                                                                                                                                                                                    (! (implies
                                                                                                                                                                                      (and
                                                                                                                                                                                       (HasType
                                                                                                                                                                                        @x55
                                                                                                                                                                                        Prims.int)
                                                                                                                                                                                       ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                       (=
                                                                                                                                                                                        (Prims.op_Addition
                                                                                                                                                                                         (Prims.op_Multiply
                                                                                                                                                                                          @x2
                                                                                                                                                                                          @x1)
                                                                                                                                                                                         (Prims.op_Multiply
                                                                                                                                                                                          @x2
                                                                                                                                                                                          (Prims.op_Division
                                                                                                                                                                                           @x0
                                                                                                                                                                                           @x2)))
                                                                                                                                                                                        @x55))
                                                                                                                                                                                      ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                      (and
                                                                                                                                                                                       (implies
                                                                                                                                                                                        ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(224,33-224,34)
                                                                                                                                                                                        (>
                                                                                                                                                                                         (BoxInt_proj_0
                                                                                                                                                                                          @x2)
                                                                                                                                                                                         (BoxInt_proj_0
                                                                                                                                                                                          (BoxInt
                                                                                                                                                                                           0)))
                                                                                                                                                                                        ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(224,33-224,34)
                                                                                                                                                                                        (or
                                                                                                                                                                                         label_18
                                                                                                                                                                                         ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(224,33-224,34)
                                                                                                                                                                                         (not
                                                                                                                                                                                          (=
                                                                                                                                                                                           @x2
                                                                                                                                                                                           (BoxInt
                                                                                                                                                                                            0)))))
                                                                                                                                                                                       ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                       (forall
                                                                                                                                                                                         ((@x56
                                                                                                                                                                                           Term))
                                                                                                                                                                                        (! (implies
                                                                                                                                                                                          (and
                                                                                                                                                                                           (HasType
                                                                                                                                                                                            @x56
                                                                                                                                                                                            Prims.pos)
                                                                                                                                                                                           ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                           (=
                                                                                                                                                                                            @x2
                                                                                                                                                                                            @x56))
                                                                                                                                                                                          ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                          (forall
                                                                                                                                                                                            ((@x57
                                                                                                                                                                                              Term))
                                                                                                                                                                                           (! (implies
                                                                                                                                                                                             (and
                                                                                                                                                                                              (HasType
                                                                                                                                                                                               @x57
                                                                                                                                                                                               Prims.int)
                                                                                                                                                                                              ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                              (=
                                                                                                                                                                                               (Prims.op_Division
                                                                                                                                                                                                (Prims.op_Addition
                                                                                                                                                                                                 @x0
                                                                                                                                                                                                 (Prims.op_Multiply
                                                                                                                                                                                                  @x1
                                                                                                                                                                                                  @x2))
                                                                                                                                                                                                @x2)
                                                                                                                                                                                               @x57))
                                                                                                                                                                                             ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                             (forall
                                                                                                                                                                                               ((@x58
                                                                                                                                                                                                 Term))
                                                                                                                                                                                              (! (implies
                                                                                                                                                                                                (and
                                                                                                                                                                                                 (HasType
                                                                                                                                                                                                  @x58
                                                                                                                                                                                                  Prims.int)
                                                                                                                                                                                                 ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                 (=
                                                                                                                                                                                                  (Prims.op_Multiply
                                                                                                                                                                                                   @x2
                                                                                                                                                                                                   (Prims.op_Division
                                                                                                                                                                                                    (Prims.op_Addition
                                                                                                                                                                                                     @x0
                                                                                                                                                                                                     (Prims.op_Multiply
                                                                                                                                                                                                      @x1
                                                                                                                                                                                                      @x2))
                                                                                                                                                                                                    @x2))
                                                                                                                                                                                                  @x58))
                                                                                                                                                                                                ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                (forall
                                                                                                                                                                                                  ((@x59
                                                                                                                                                                                                    Term))
                                                                                                                                                                                                 (! (implies
                                                                                                                                                                                                   (and
                                                                                                                                                                                                    (HasType
                                                                                                                                                                                                     @x59
                                                                                                                                                                                                     Prims.int)
                                                                                                                                                                                                    ;; def=FStar.Calc.fsti(67,3-67,4); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                    (=
                                                                                                                                                                                                     (Prims.op_Subtraction
                                                                                                                                                                                                      (Prims.op_Addition
                                                                                                                                                                                                       (Prims.op_Multiply
                                                                                                                                                                                                        @x2
                                                                                                                                                                                                        @x1)
                                                                                                                                                                                                       (Prims.op_Multiply
                                                                                                                                                                                                        @x2
                                                                                                                                                                                                        (Prims.op_Division
                                                                                                                                                                                                         @x0
                                                                                                                                                                                                         @x2)))
                                                                                                                                                                                                      (Prims.op_Multiply
                                                                                                                                                                                                       @x2
                                                                                                                                                                                                       (Prims.op_Division
                                                                                                                                                                                                        (Prims.op_Addition
                                                                                                                                                                                                         @x0
                                                                                                                                                                                                         (Prims.op_Multiply
                                                                                                                                                                                                          @x1
                                                                                                                                                                                                          @x2))
                                                                                                                                                                                                        @x2)))
                                                                                                                                                                                                     @x59))
                                                                                                                                                                                                   ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                   (and
                                                                                                                                                                                                    ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                    (forall
                                                                                                                                                                                                      ((@x60
                                                                                                                                                                                                        Term))
                                                                                                                                                                                                     (! (implies
                                                                                                                                                                                                       (HasType
                                                                                                                                                                                                        @x60
                                                                                                                                                                                                        Prims.unit)
                                                                                                                                                                                                       ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                       (and
                                                                                                                                                                                                        (implies
                                                                                                                                                                                                         ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(220,12-220,13)
                                                                                                                                                                                                         (>
                                                                                                                                                                                                          (BoxInt_proj_0
                                                                                                                                                                                                           @x2)
                                                                                                                                                                                                          (BoxInt_proj_0
                                                                                                                                                                                                           (BoxInt
                                                                                                                                                                                                            0)))
                                                                                                                                                                                                         ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(220,12-220,13)
                                                                                                                                                                                                         (or
                                                                                                                                                                                                          label_19
                                                                                                                                                                                                          ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(220,12-220,13)
                                                                                                                                                                                                          (not
                                                                                                                                                                                                           (=
                                                                                                                                                                                                            @x2
                                                                                                                                                                                                            (BoxInt
                                                                                                                                                                                                             0)))))
                                                                                                                                                                                                        ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                        (forall
                                                                                                                                                                                                          ((@x61
                                                                                                                                                                                                            Term))
                                                                                                                                                                                                         (! (implies
                                                                                                                                                                                                           (and
                                                                                                                                                                                                            (HasType
                                                                                                                                                                                                             @x61
                                                                                                                                                                                                             Prims.pos)
                                                                                                                                                                                                            ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                            (=
                                                                                                                                                                                                             @x2
                                                                                                                                                                                                             @x61))
                                                                                                                                                                                                           ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                           (forall
                                                                                                                                                                                                             ((@x62
                                                                                                                                                                                                               Term))
                                                                                                                                                                                                            (! (implies
                                                                                                                                                                                                              (and
                                                                                                                                                                                                               (HasType
                                                                                                                                                                                                                @x62
                                                                                                                                                                                                                Prims.int)
                                                                                                                                                                                                               ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                               (=
                                                                                                                                                                                                                (Prims.op_Modulus
                                                                                                                                                                                                                 (Prims.op_Addition
                                                                                                                                                                                                                  @x0
                                                                                                                                                                                                                  (Prims.op_Multiply
                                                                                                                                                                                                                   @x1
                                                                                                                                                                                                                   @x2))
                                                                                                                                                                                                                 @x2)
                                                                                                                                                                                                                @x62))
                                                                                                                                                                                                              ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                              (and
                                                                                                                                                                                                               (implies
                                                                                                                                                                                                                ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(220,18-220,19)
                                                                                                                                                                                                                (>
                                                                                                                                                                                                                 (BoxInt_proj_0
                                                                                                                                                                                                                  @x2)
                                                                                                                                                                                                                 (BoxInt_proj_0
                                                                                                                                                                                                                  (BoxInt
                                                                                                                                                                                                                   0)))
                                                                                                                                                                                                                ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(220,18-220,19)
                                                                                                                                                                                                                (or
                                                                                                                                                                                                                 label_20
                                                                                                                                                                                                                 ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(220,18-220,19)
                                                                                                                                                                                                                 (not
                                                                                                                                                                                                                  (=
                                                                                                                                                                                                                   @x2
                                                                                                                                                                                                                   (BoxInt
                                                                                                                                                                                                                    0)))))
                                                                                                                                                                                                               ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                               (forall
                                                                                                                                                                                                                 ((@x63
                                                                                                                                                                                                                   Term))
                                                                                                                                                                                                                (! (implies
                                                                                                                                                                                                                  (and
                                                                                                                                                                                                                   (HasType
                                                                                                                                                                                                                    @x63
                                                                                                                                                                                                                    Prims.pos)
                                                                                                                                                                                                                   ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                                   (=
                                                                                                                                                                                                                    @x2
                                                                                                                                                                                                                    @x63))
                                                                                                                                                                                                                  ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                                  (forall
                                                                                                                                                                                                                    ((@x64
                                                                                                                                                                                                                      Term))
                                                                                                                                                                                                                   (! (implies
                                                                                                                                                                                                                     (and
                                                                                                                                                                                                                      (HasType
                                                                                                                                                                                                                       @x64
                                                                                                                                                                                                                       Prims.int)
                                                                                                                                                                                                                      ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                                      (=
                                                                                                                                                                                                                       (Prims.op_Modulus
                                                                                                                                                                                                                        @x0
                                                                                                                                                                                                                        @x2)
                                                                                                                                                                                                                       @x64))
                                                                                                                                                                                                                     ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                                     (forall
                                                                                                                                                                                                                       ((@x65
                                                                                                                                                                                                                         Term))
                                                                                                                                                                                                                      (! (implies
                                                                                                                                                                                                                        (and
                                                                                                                                                                                                                         (HasType
                                                                                                                                                                                                                          @x65
                                                                                                                                                                                                                          Prims.int)
                                                                                                                                                                                                                         ;; def=FStar.Calc.fsti(65,4-65,5); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                                         (=
                                                                                                                                                                                                                          (Prims.op_Subtraction
                                                                                                                                                                                                                           (Prims.op_Modulus
                                                                                                                                                                                                                            (Prims.op_Addition
                                                                                                                                                                                                                             @x0
                                                                                                                                                                                                                             (Prims.op_Multiply
                                                                                                                                                                                                                              @x1
                                                                                                                                                                                                                              @x2))
                                                                                                                                                                                                                            @x2)
                                                                                                                                                                                                                           (Prims.op_Modulus
                                                                                                                                                                                                                            @x0
                                                                                                                                                                                                                            @x2))
                                                                                                                                                                                                                          @x65))
                                                                                                                                                                                                                        ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                                        (and
                                                                                                                                                                                                                         (implies
                                                                                                                                                                                                                          ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(220,12-220,13)
                                                                                                                                                                                                                          (>
                                                                                                                                                                                                                           (BoxInt_proj_0
                                                                                                                                                                                                                            @x2)
                                                                                                                                                                                                                           (BoxInt_proj_0
                                                                                                                                                                                                                            (BoxInt
                                                                                                                                                                                                                             0)))
                                                                                                                                                                                                                          ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(220,12-220,13)
                                                                                                                                                                                                                          (or
                                                                                                                                                                                                                           label_21
                                                                                                                                                                                                                           ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(220,12-220,13)
                                                                                                                                                                                                                           (not
                                                                                                                                                                                                                            (=
                                                                                                                                                                                                                             @x2
                                                                                                                                                                                                                             (BoxInt
                                                                                                                                                                                                                              0)))))
                                                                                                                                                                                                                         ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                                         (forall
                                                                                                                                                                                                                           ((@x66
                                                                                                                                                                                                                             Term))
                                                                                                                                                                                                                          (! (implies
                                                                                                                                                                                                                            (and
                                                                                                                                                                                                                             (HasType
                                                                                                                                                                                                                              @x66
                                                                                                                                                                                                                              Prims.pos)
                                                                                                                                                                                                                             ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                                             (=
                                                                                                                                                                                                                              @x2
                                                                                                                                                                                                                              @x66))
                                                                                                                                                                                                                            ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                                            (forall
                                                                                                                                                                                                                              ((@x67
                                                                                                                                                                                                                                Term))
                                                                                                                                                                                                                             (! (implies
                                                                                                                                                                                                                               (and
                                                                                                                                                                                                                                (HasType
                                                                                                                                                                                                                                 @x67
                                                                                                                                                                                                                                 Prims.int)
                                                                                                                                                                                                                                ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                                                (=
                                                                                                                                                                                                                                 (Prims.op_Modulus
                                                                                                                                                                                                                                  (Prims.op_Addition
                                                                                                                                                                                                                                   @x0
                                                                                                                                                                                                                                   (Prims.op_Multiply
                                                                                                                                                                                                                                    @x1
                                                                                                                                                                                                                                    @x2))
                                                                                                                                                                                                                                  @x2)
                                                                                                                                                                                                                                 @x67))
                                                                                                                                                                                                                               ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                                               (and
                                                                                                                                                                                                                                (implies
                                                                                                                                                                                                                                 ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(220,18-220,19)
                                                                                                                                                                                                                                 (>
                                                                                                                                                                                                                                  (BoxInt_proj_0
                                                                                                                                                                                                                                   @x2)
                                                                                                                                                                                                                                  (BoxInt_proj_0
                                                                                                                                                                                                                                   (BoxInt
                                                                                                                                                                                                                                    0)))
                                                                                                                                                                                                                                 ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(220,18-220,19)
                                                                                                                                                                                                                                 (or
                                                                                                                                                                                                                                  label_22
                                                                                                                                                                                                                                  ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(220,18-220,19)
                                                                                                                                                                                                                                  (not
                                                                                                                                                                                                                                   (=
                                                                                                                                                                                                                                    @x2
                                                                                                                                                                                                                                    (BoxInt
                                                                                                                                                                                                                                     0)))))
                                                                                                                                                                                                                                ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                                                (forall
                                                                                                                                                                                                                                  ((@x68
                                                                                                                                                                                                                                    Term))
                                                                                                                                                                                                                                 (! (implies
                                                                                                                                                                                                                                   (and
                                                                                                                                                                                                                                    (HasType
                                                                                                                                                                                                                                     @x68
                                                                                                                                                                                                                                     Prims.pos)
                                                                                                                                                                                                                                    ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                                                    (=
                                                                                                                                                                                                                                     @x2
                                                                                                                                                                                                                                     @x68))
                                                                                                                                                                                                                                   ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                                                   (forall
                                                                                                                                                                                                                                     ((@x69
                                                                                                                                                                                                                                       Term))
                                                                                                                                                                                                                                    (! (implies
                                                                                                                                                                                                                                      (and
                                                                                                                                                                                                                                       (HasType
                                                                                                                                                                                                                                        @x69
                                                                                                                                                                                                                                        Prims.int)
                                                                                                                                                                                                                                       ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                                                       (=
                                                                                                                                                                                                                                        (Prims.op_Modulus
                                                                                                                                                                                                                                         @x0
                                                                                                                                                                                                                                         @x2)
                                                                                                                                                                                                                                        @x69))
                                                                                                                                                                                                                                      ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                                                      (forall
                                                                                                                                                                                                                                        ((@x70
                                                                                                                                                                                                                                          Term))
                                                                                                                                                                                                                                       (! (implies
                                                                                                                                                                                                                                         (and
                                                                                                                                                                                                                                          (HasType
                                                                                                                                                                                                                                           @x70
                                                                                                                                                                                                                                           Prims.int)
                                                                                                                                                                                                                                          ;; def=FStar.Calc.fsti(65,7-65,8); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                                                          (=
                                                                                                                                                                                                                                           (Prims.op_Subtraction
                                                                                                                                                                                                                                            (Prims.op_Modulus
                                                                                                                                                                                                                                             (Prims.op_Addition
                                                                                                                                                                                                                                              @x0
                                                                                                                                                                                                                                              (Prims.op_Multiply
                                                                                                                                                                                                                                               @x1
                                                                                                                                                                                                                                               @x2))
                                                                                                                                                                                                                                             @x2)
                                                                                                                                                                                                                                            (Prims.op_Modulus
                                                                                                                                                                                                                                             @x0
                                                                                                                                                                                                                                             @x2))
                                                                                                                                                                                                                                           @x70))
                                                                                                                                                                                                                                         ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                                                         (and
                                                                                                                                                                                                                                          (implies
                                                                                                                                                                                                                                           ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(222,30-222,31)
                                                                                                                                                                                                                                           (>
                                                                                                                                                                                                                                            (BoxInt_proj_0
                                                                                                                                                                                                                                             @x2)
                                                                                                                                                                                                                                            (BoxInt_proj_0
                                                                                                                                                                                                                                             (BoxInt
                                                                                                                                                                                                                                              0)))
                                                                                                                                                                                                                                           ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(222,30-222,31)
                                                                                                                                                                                                                                           (or
                                                                                                                                                                                                                                            label_23
                                                                                                                                                                                                                                            ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(222,30-222,31)
                                                                                                                                                                                                                                            (not
                                                                                                                                                                                                                                             (=
                                                                                                                                                                                                                                              @x2
                                                                                                                                                                                                                                              (BoxInt
                                                                                                                                                                                                                                               0)))))
                                                                                                                                                                                                                                          ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                                                          (forall
                                                                                                                                                                                                                                            ((@x71
                                                                                                                                                                                                                                              Term))
                                                                                                                                                                                                                                           (! (implies
                                                                                                                                                                                                                                             (and
                                                                                                                                                                                                                                              (HasType
                                                                                                                                                                                                                                               @x71
                                                                                                                                                                                                                                               Prims.pos)
                                                                                                                                                                                                                                              ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                                                              (=
                                                                                                                                                                                                                                               @x2
                                                                                                                                                                                                                                               @x71))
                                                                                                                                                                                                                                             ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                                                             (forall
                                                                                                                                                                                                                                               ((@x72
                                                                                                                                                                                                                                                 Term))
                                                                                                                                                                                                                                              (! (implies
                                                                                                                                                                                                                                                (and
                                                                                                                                                                                                                                                 (HasType
                                                                                                                                                                                                                                                  @x72
                                                                                                                                                                                                                                                  Prims.int)
                                                                                                                                                                                                                                                 ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                                                                 (=
                                                                                                                                                                                                                                                  (Prims.op_Division
                                                                                                                                                                                                                                                   (Prims.op_Addition
                                                                                                                                                                                                                                                    @x0
                                                                                                                                                                                                                                                    (Prims.op_Multiply
                                                                                                                                                                                                                                                     @x1
                                                                                                                                                                                                                                                     @x2))
                                                                                                                                                                                                                                                   @x2)
                                                                                                                                                                                                                                                  @x72))
                                                                                                                                                                                                                                                ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                                                                (forall
                                                                                                                                                                                                                                                  ((@x73
                                                                                                                                                                                                                                                    Term))
                                                                                                                                                                                                                                                 (! (implies
                                                                                                                                                                                                                                                   (and
                                                                                                                                                                                                                                                    (HasType
                                                                                                                                                                                                                                                     @x73
                                                                                                                                                                                                                                                     Prims.int)
                                                                                                                                                                                                                                                    ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                                                                    (=
                                                                                                                                                                                                                                                     (Prims.op_Multiply
                                                                                                                                                                                                                                                      @x2
                                                                                                                                                                                                                                                      (Prims.op_Division
                                                                                                                                                                                                                                                       (Prims.op_Addition
                                                                                                                                                                                                                                                        @x0
                                                                                                                                                                                                                                                        (Prims.op_Multiply
                                                                                                                                                                                                                                                         @x1
                                                                                                                                                                                                                                                         @x2))
                                                                                                                                                                                                                                                       @x2))
                                                                                                                                                                                                                                                     @x73))
                                                                                                                                                                                                                                                   ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                                                                   (forall
                                                                                                                                                                                                                                                     ((@x74
                                                                                                                                                                                                                                                       Term))
                                                                                                                                                                                                                                                    (! (implies
                                                                                                                                                                                                                                                      (and
                                                                                                                                                                                                                                                       (HasType
                                                                                                                                                                                                                                                        @x74
                                                                                                                                                                                                                                                        Prims.int)
                                                                                                                                                                                                                                                       ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                                                                       (=
                                                                                                                                                                                                                                                        (Prims.op_Subtraction
                                                                                                                                                                                                                                                         (Prims.op_Addition
                                                                                                                                                                                                                                                          @x0
                                                                                                                                                                                                                                                          (Prims.op_Multiply
                                                                                                                                                                                                                                                           @x1
                                                                                                                                                                                                                                                           @x2))
                                                                                                                                                                                                                                                         (Prims.op_Multiply
                                                                                                                                                                                                                                                          @x2
                                                                                                                                                                                                                                                          (Prims.op_Division
                                                                                                                                                                                                                                                           (Prims.op_Addition
                                                                                                                                                                                                                                                            @x0
                                                                                                                                                                                                                                                            (Prims.op_Multiply
                                                                                                                                                                                                                                                             @x1
                                                                                                                                                                                                                                                             @x2))
                                                                                                                                                                                                                                                           @x2)))
                                                                                                                                                                                                                                                        @x74))
                                                                                                                                                                                                                                                      ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                                                                      (and
                                                                                                                                                                                                                                                       (implies
                                                                                                                                                                                                                                                        ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(222,46-222,47)
                                                                                                                                                                                                                                                        (>
                                                                                                                                                                                                                                                         (BoxInt_proj_0
                                                                                                                                                                                                                                                          @x2)
                                                                                                                                                                                                                                                         (BoxInt_proj_0
                                                                                                                                                                                                                                                          (BoxInt
                                                                                                                                                                                                                                                           0)))
                                                                                                                                                                                                                                                        ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(222,46-222,47)
                                                                                                                                                                                                                                                        (or
                                                                                                                                                                                                                                                         label_24
                                                                                                                                                                                                                                                         ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(222,46-222,47)
                                                                                                                                                                                                                                                         (not
                                                                                                                                                                                                                                                          (=
                                                                                                                                                                                                                                                           @x2
                                                                                                                                                                                                                                                           (BoxInt
                                                                                                                                                                                                                                                            0)))))
                                                                                                                                                                                                                                                       ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                                                                       (forall
                                                                                                                                                                                                                                                         ((@x75
                                                                                                                                                                                                                                                           Term))
                                                                                                                                                                                                                                                        (! (implies
                                                                                                                                                                                                                                                          (and
                                                                                                                                                                                                                                                           (HasType
                                                                                                                                                                                                                                                            @x75
                                                                                                                                                                                                                                                            Prims.pos)
                                                                                                                                                                                                                                                           ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                                                                           (=
                                                                                                                                                                                                                                                            @x2
                                                                                                                                                                                                                                                            @x75))
                                                                                                                                                                                                                                                          ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                                                                          (forall
                                                                                                                                                                                                                                                            ((@x76
                                                                                                                                                                                                                                                              Term))
                                                                                                                                                                                                                                                           (! (implies
                                                                                                                                                                                                                                                             (and
                                                                                                                                                                                                                                                              (HasType
                                                                                                                                                                                                                                                               @x76
                                                                                                                                                                                                                                                               Prims.int)
                                                                                                                                                                                                                                                              ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                                                                              (=
                                                                                                                                                                                                                                                               (Prims.op_Division
                                                                                                                                                                                                                                                                @x0
                                                                                                                                                                                                                                                                @x2)
                                                                                                                                                                                                                                                               @x76))
                                                                                                                                                                                                                                                             ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                                                                             (forall
                                                                                                                                                                                                                                                               ((@x77
                                                                                                                                                                                                                                                                 Term))
                                                                                                                                                                                                                                                              (! (implies
                                                                                                                                                                                                                                                                (and
                                                                                                                                                                                                                                                                 (HasType
                                                                                                                                                                                                                                                                  @x77
                                                                                                                                                                                                                                                                  Prims.int)
                                                                                                                                                                                                                                                                 ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                                                                                 (=
                                                                                                                                                                                                                                                                  (Prims.op_Multiply
                                                                                                                                                                                                                                                                   @x2
                                                                                                                                                                                                                                                                   (Prims.op_Division
                                                                                                                                                                                                                                                                    @x0
                                                                                                                                                                                                                                                                    @x2))
                                                                                                                                                                                                                                                                  @x77))
                                                                                                                                                                                                                                                                ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                                                                                (forall
                                                                                                                                                                                                                                                                  ((@x78
                                                                                                                                                                                                                                                                    Term))
                                                                                                                                                                                                                                                                 (! (implies
                                                                                                                                                                                                                                                                   (and
                                                                                                                                                                                                                                                                    (HasType
                                                                                                                                                                                                                                                                     @x78
                                                                                                                                                                                                                                                                     Prims.int)
                                                                                                                                                                                                                                                                    ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                                                                                    (=
                                                                                                                                                                                                                                                                     (Prims.op_Subtraction
                                                                                                                                                                                                                                                                      @x0
                                                                                                                                                                                                                                                                      (Prims.op_Multiply
                                                                                                                                                                                                                                                                       @x2
                                                                                                                                                                                                                                                                       (Prims.op_Division
                                                                                                                                                                                                                                                                        @x0
                                                                                                                                                                                                                                                                        @x2)))
                                                                                                                                                                                                                                                                     @x78))
                                                                                                                                                                                                                                                                   ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                                                                                   (forall
                                                                                                                                                                                                                                                                     ((@x79
                                                                                                                                                                                                                                                                       Term))
                                                                                                                                                                                                                                                                    (! (implies
                                                                                                                                                                                                                                                                      (and
                                                                                                                                                                                                                                                                       (HasType
                                                                                                                                                                                                                                                                        @x79
                                                                                                                                                                                                                                                                        Prims.int)
                                                                                                                                                                                                                                                                       ;; def=FStar.Calc.fsti(67,3-67,4); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                                                                                       (=
                                                                                                                                                                                                                                                                        (Prims.op_Subtraction
                                                                                                                                                                                                                                                                         (Prims.op_Subtraction
                                                                                                                                                                                                                                                                          (Prims.op_Addition
                                                                                                                                                                                                                                                                           @x0
                                                                                                                                                                                                                                                                           (Prims.op_Multiply
                                                                                                                                                                                                                                                                            @x1
                                                                                                                                                                                                                                                                            @x2))
                                                                                                                                                                                                                                                                          (Prims.op_Multiply
                                                                                                                                                                                                                                                                           @x2
                                                                                                                                                                                                                                                                           (Prims.op_Division
                                                                                                                                                                                                                                                                            (Prims.op_Addition
                                                                                                                                                                                                                                                                             @x0
                                                                                                                                                                                                                                                                             (Prims.op_Multiply
                                                                                                                                                                                                                                                                              @x1
                                                                                                                                                                                                                                                                              @x2))
                                                                                                                                                                                                                                                                            @x2)))
                                                                                                                                                                                                                                                                         (Prims.op_Subtraction
                                                                                                                                                                                                                                                                          @x0
                                                                                                                                                                                                                                                                          (Prims.op_Multiply
                                                                                                                                                                                                                                                                           @x2
                                                                                                                                                                                                                                                                           (Prims.op_Division
                                                                                                                                                                                                                                                                            @x0
                                                                                                                                                                                                                                                                            @x2))))
                                                                                                                                                                                                                                                                        @x79))
                                                                                                                                                                                                                                                                      ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                                                                                      (and
                                                                                                                                                                                                                                                                       ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                                                                                       (forall
                                                                                                                                                                                                                                                                         ((@x80
                                                                                                                                                                                                                                                                           Term))
                                                                                                                                                                                                                                                                        (! (implies
                                                                                                                                                                                                                                                                          (HasType
                                                                                                                                                                                                                                                                           @x80
                                                                                                                                                                                                                                                                           Prims.unit)
                                                                                                                                                                                                                                                                          ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(220,4-220,19)
                                                                                                                                                                                                                                                                          (and
                                                                                                                                                                                                                                                                           (implies
                                                                                                                                                                                                                                                                            ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(220,12-220,13)
                                                                                                                                                                                                                                                                            (>
                                                                                                                                                                                                                                                                             (BoxInt_proj_0
                                                                                                                                                                                                                                                                              @x2)
                                                                                                                                                                                                                                                                             (BoxInt_proj_0
                                                                                                                                                                                                                                                                              (BoxInt
                                                                                                                                                                                                                                                                               0)))
                                                                                                                                                                                                                                                                            ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(220,12-220,13)
                                                                                                                                                                                                                                                                            (or
                                                                                                                                                                                                                                                                             label_25
                                                                                                                                                                                                                                                                             ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(220,12-220,13)
                                                                                                                                                                                                                                                                             (not
                                                                                                                                                                                                                                                                              (=
                                                                                                                                                                                                                                                                               @x2
                                                                                                                                                                                                                                                                               (BoxInt
                                                                                                                                                                                                                                                                                0)))))
                                                                                                                                                                                                                                                                           ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(220,4-220,19)
                                                                                                                                                                                                                                                                           (forall
                                                                                                                                                                                                                                                                             ((@x81
                                                                                                                                                                                                                                                                               Term))
                                                                                                                                                                                                                                                                            (! (implies
                                                                                                                                                                                                                                                                              (and
                                                                                                                                                                                                                                                                               (HasType
                                                                                                                                                                                                                                                                                @x81
                                                                                                                                                                                                                                                                                Prims.pos)
                                                                                                                                                                                                                                                                               ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(220,4-220,19)
                                                                                                                                                                                                                                                                               (=
                                                                                                                                                                                                                                                                                @x2
                                                                                                                                                                                                                                                                                @x81))
                                                                                                                                                                                                                                                                              ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(220,4-220,19)
                                                                                                                                                                                                                                                                              (forall
                                                                                                                                                                                                                                                                                ((@x82
                                                                                                                                                                                                                                                                                  Term))
                                                                                                                                                                                                                                                                               (! (implies
                                                                                                                                                                                                                                                                                 (and
                                                                                                                                                                                                                                                                                  (HasType
                                                                                                                                                                                                                                                                                   @x82
                                                                                                                                                                                                                                                                                   Prims.int)
                                                                                                                                                                                                                                                                                  ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(220,4-220,19)
                                                                                                                                                                                                                                                                                  (=
                                                                                                                                                                                                                                                                                   (Prims.op_Modulus
                                                                                                                                                                                                                                                                                    (Prims.op_Addition
                                                                                                                                                                                                                                                                                     @x0
                                                                                                                                                                                                                                                                                     (Prims.op_Multiply
                                                                                                                                                                                                                                                                                      @x1
                                                                                                                                                                                                                                                                                      @x2))
                                                                                                                                                                                                                                                                                    @x2)
                                                                                                                                                                                                                                                                                   @x82)
                                                                                                                                                                                                                                                                                  ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(220,18-220,19)
                                                                                                                                                                                                                                                                                  (>
                                                                                                                                                                                                                                                                                   (BoxInt_proj_0
                                                                                                                                                                                                                                                                                    @x2)
                                                                                                                                                                                                                                                                                   (BoxInt_proj_0
                                                                                                                                                                                                                                                                                    (BoxInt
                                                                                                                                                                                                                                                                                     0))))
                                                                                                                                                                                                                                                                                 ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(220,18-220,19)
                                                                                                                                                                                                                                                                                 (or
                                                                                                                                                                                                                                                                                  label_26
                                                                                                                                                                                                                                                                                  ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(220,18-220,19)
                                                                                                                                                                                                                                                                                  (not
                                                                                                                                                                                                                                                                                   (=
                                                                                                                                                                                                                                                                                    @x2
                                                                                                                                                                                                                                                                                    (BoxInt
                                                                                                                                                                                                                                                                                     0)))))
                                                                                                                                                                                                                                                                                :qid
                                                                                                                                                                                                                                                                                 @query.81)))
                                                                                                                                                                                                                                                                             :qid
                                                                                                                                                                                                                                                                              @query.80))))
                                                                                                                                                                                                                                                                         :qid
                                                                                                                                                                                                                                                                          @query.79))
                                                                                                                                                                                                                                                                       ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                                                                                       (forall
                                                                                                                                                                                                                                                                         ((@x80
                                                                                                                                                                                                                                                                           Term))
                                                                                                                                                                                                                                                                        (! (implies
                                                                                                                                                                                                                                                                          (HasType
                                                                                                                                                                                                                                                                           @x80
                                                                                                                                                                                                                                                                           (Tm_arrow_ec09fe0cb197587ff4f8022e98f56e3b
                                                                                                                                                                                                                                                                            @x2
                                                                                                                                                                                                                                                                            @x1
                                                                                                                                                                                                                                                                            @x0))
                                                                                                                                                                                                                                                                          ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                                                                                          (forall
                                                                                                                                                                                                                                                                            ((@x81
                                                                                                                                                                                                                                                                              Term))
                                                                                                                                                                                                                                                                           (! (implies
                                                                                                                                                                                                                                                                             (HasType
                                                                                                                                                                                                                                                                              @x81
                                                                                                                                                                                                                                                                              Prims.unit)
                                                                                                                                                                                                                                                                             ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(221,9-221,51)
                                                                                                                                                                                                                                                                             (and
                                                                                                                                                                                                                                                                              (implies
                                                                                                                                                                                                                                                                               ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(221,25-221,26)
                                                                                                                                                                                                                                                                               (>
                                                                                                                                                                                                                                                                                (BoxInt_proj_0
                                                                                                                                                                                                                                                                                 @x2)
                                                                                                                                                                                                                                                                                (BoxInt_proj_0
                                                                                                                                                                                                                                                                                 (BoxInt
                                                                                                                                                                                                                                                                                  0)))
                                                                                                                                                                                                                                                                               ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(221,25-221,26)
                                                                                                                                                                                                                                                                               (or
                                                                                                                                                                                                                                                                                label_27
                                                                                                                                                                                                                                                                                ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(221,25-221,26)
                                                                                                                                                                                                                                                                                (not
                                                                                                                                                                                                                                                                                 (=
                                                                                                                                                                                                                                                                                  @x2
                                                                                                                                                                                                                                                                                  (BoxInt
                                                                                                                                                                                                                                                                                   0)))))
                                                                                                                                                                                                                                                                              ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(221,9-221,51)
                                                                                                                                                                                                                                                                              (forall
                                                                                                                                                                                                                                                                                ((@x82
                                                                                                                                                                                                                                                                                  Term))
                                                                                                                                                                                                                                                                               (! (implies
                                                                                                                                                                                                                                                                                 (and
                                                                                                                                                                                                                                                                                  (HasType
                                                                                                                                                                                                                                                                                   @x82
                                                                                                                                                                                                                                                                                   Prims.pos)
                                                                                                                                                                                                                                                                                  ;; def=FStar.Math.Lemmas.fsti(170,28-170,29); use=FStar.Math.Lemmas.fst(221,9-221,51)
                                                                                                                                                                                                                                                                                  (=
                                                                                                                                                                                                                                                                                   @x2
                                                                                                                                                                                                                                                                                   @x82))
                                                                                                                                                                                                                                                                                 ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(221,9-221,22)
                                                                                                                                                                                                                                                                                 (forall
                                                                                                                                                                                                                                                                                   ((@x83
                                                                                                                                                                                                                                                                                     Term))
                                                                                                                                                                                                                                                                                  (! (implies
                                                                                                                                                                                                                                                                                    (and
                                                                                                                                                                                                                                                                                     (HasType
                                                                                                                                                                                                                                                                                      @x83
                                                                                                                                                                                                                                                                                      Prims.unit)
                                                                                                                                                                                                                                                                                     ;; def=FStar.Math.Lemmas.fsti(170,47-170,72); use=FStar.Math.Lemmas.fst(221,9-221,22)
                                                                                                                                                                                                                                                                                     (=
                                                                                                                                                                                                                                                                                      @x0
                                                                                                                                                                                                                                                                                      (Prims.op_Addition
                                                                                                                                                                                                                                                                                       (Prims.op_Multiply
                                                                                                                                                                                                                                                                                        @x2
                                                                                                                                                                                                                                                                                        (Prims.op_Division
                                                                                                                                                                                                                                                                                         @x0
                                                                                                                                                                                                                                                                                         @x2))
                                                                                                                                                                                                                                                                                       (Prims.op_Modulus
                                                                                                                                                                                                                                                                                        @x0
                                                                                                                                                                                                                                                                                        @x2))))
                                                                                                                                                                                                                                                                                    ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(221,9-221,51)
                                                                                                                                                                                                                                                                                    (and
                                                                                                                                                                                                                                                                                     (implies
                                                                                                                                                                                                                                                                                      ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(221,50-221,51)
                                                                                                                                                                                                                                                                                      (>
                                                                                                                                                                                                                                                                                       (BoxInt_proj_0
                                                                                                                                                                                                                                                                                        @x2)
                                                                                                                                                                                                                                                                                       (BoxInt_proj_0
                                                                                                                                                                                                                                                                                        (BoxInt
                                                                                                                                                                                                                                                                                         0)))
                                                                                                                                                                                                                                                                                      ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(221,50-221,51)
                                                                                                                                                                                                                                                                                      (or
                                                                                                                                                                                                                                                                                       label_28
                                                                                                                                                                                                                                                                                       ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(221,50-221,51)
                                                                                                                                                                                                                                                                                       (not
                                                                                                                                                                                                                                                                                        (=
                                                                                                                                                                                                                                                                                         @x2
                                                                                                                                                                                                                                                                                         (BoxInt
                                                                                                                                                                                                                                                                                          0)))))
                                                                                                                                                                                                                                                                                     ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(221,9-221,51)
                                                                                                                                                                                                                                                                                     (forall
                                                                                                                                                                                                                                                                                       ((@x84
                                                                                                                                                                                                                                                                                         Term))
                                                                                                                                                                                                                                                                                      (! (implies
                                                                                                                                                                                                                                                                                        (and
                                                                                                                                                                                                                                                                                         (HasType
                                                                                                                                                                                                                                                                                          @x84
                                                                                                                                                                                                                                                                                          Prims.pos)
                                                                                                                                                                                                                                                                                         ;; def=FStar.Math.Lemmas.fsti(170,28-170,29); use=FStar.Math.Lemmas.fst(221,9-221,51)
                                                                                                                                                                                                                                                                                         (=
                                                                                                                                                                                                                                                                                          @x2
                                                                                                                                                                                                                                                                                          @x84))
                                                                                                                                                                                                                                                                                        ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(221,28-221,41)
                                                                                                                                                                                                                                                                                        (forall
                                                                                                                                                                                                                                                                                          ((@x85
                                                                                                                                                                                                                                                                                            Term))
                                                                                                                                                                                                                                                                                         (! (implies
                                                                                                                                                                                                                                                                                           (and
                                                                                                                                                                                                                                                                                            (HasType
                                                                                                                                                                                                                                                                                             @x85
                                                                                                                                                                                                                                                                                             Prims.unit)
                                                                                                                                                                                                                                                                                            ;; def=FStar.Math.Lemmas.fsti(170,47-170,72); use=FStar.Math.Lemmas.fst(221,28-221,41)
                                                                                                                                                                                                                                                                                            (=
                                                                                                                                                                                                                                                                                             (Prims.op_Addition
                                                                                                                                                                                                                                                                                              @x0
                                                                                                                                                                                                                                                                                              (Prims.op_Multiply
                                                                                                                                                                                                                                                                                               @x1
                                                                                                                                                                                                                                                                                               @x2))
                                                                                                                                                                                                                                                                                             (Prims.op_Addition
                                                                                                                                                                                                                                                                                              (Prims.op_Multiply
                                                                                                                                                                                                                                                                                               @x2
                                                                                                                                                                                                                                                                                               (Prims.op_Division
                                                                                                                                                                                                                                                                                                (Prims.op_Addition
                                                                                                                                                                                                                                                                                                 @x0
                                                                                                                                                                                                                                                                                                 (Prims.op_Multiply
                                                                                                                                                                                                                                                                                                  @x1
                                                                                                                                                                                                                                                                                                  @x2))
                                                                                                                                                                                                                                                                                                @x2))
                                                                                                                                                                                                                                                                                              (Prims.op_Modulus
                                                                                                                                                                                                                                                                                               (Prims.op_Addition
                                                                                                                                                                                                                                                                                                @x0
                                                                                                                                                                                                                                                                                                (Prims.op_Multiply
                                                                                                                                                                                                                                                                                                 @x1
                                                                                                                                                                                                                                                                                                 @x2))
                                                                                                                                                                                                                                                                                               @x2))))
                                                                                                                                                                                                                                                                                           ;; def=FStar.Math.Lemmas.fst(221,4-221,6); use=FStar.Math.Lemmas.fst(221,28-221,51)
                                                                                                                                                                                                                                                                                           (or
                                                                                                                                                                                                                                                                                            label_29
                                                                                                                                                                                                                                                                                            ;; def=FStar.Math.Lemmas.fst(221,4-221,6); use=FStar.Math.Lemmas.fst(221,28-221,51)
                                                                                                                                                                                                                                                                                            (=
                                                                                                                                                                                                                                                                                             (Prims.op_Subtraction
                                                                                                                                                                                                                                                                                              (Prims.op_Modulus
                                                                                                                                                                                                                                                                                               (Prims.op_Addition
                                                                                                                                                                                                                                                                                                @x0
                                                                                                                                                                                                                                                                                                (Prims.op_Multiply
                                                                                                                                                                                                                                                                                                 @x1
                                                                                                                                                                                                                                                                                                 @x2))
                                                                                                                                                                                                                                                                                               @x2)
                                                                                                                                                                                                                                                                                              (Prims.op_Modulus
                                                                                                                                                                                                                                                                                               @x0
                                                                                                                                                                                                                                                                                               @x2))
                                                                                                                                                                                                                                                                                             (Prims.op_Subtraction
                                                                                                                                                                                                                                                                                              (Prims.op_Subtraction
                                                                                                                                                                                                                                                                                               (Prims.op_Addition
                                                                                                                                                                                                                                                                                                @x0
                                                                                                                                                                                                                                                                                                (Prims.op_Multiply
                                                                                                                                                                                                                                                                                                 @x1
                                                                                                                                                                                                                                                                                                 @x2))
                                                                                                                                                                                                                                                                                               (Prims.op_Multiply
                                                                                                                                                                                                                                                                                                @x2
                                                                                                                                                                                                                                                                                                (Prims.op_Division
                                                                                                                                                                                                                                                                                                 (Prims.op_Addition
                                                                                                                                                                                                                                                                                                  @x0
                                                                                                                                                                                                                                                                                                  (Prims.op_Multiply
                                                                                                                                                                                                                                                                                                   @x1
                                                                                                                                                                                                                                                                                                   @x2))
                                                                                                                                                                                                                                                                                                 @x2)))
                                                                                                                                                                                                                                                                                              (Prims.op_Subtraction
                                                                                                                                                                                                                                                                                               @x0
                                                                                                                                                                                                                                                                                               (Prims.op_Multiply
                                                                                                                                                                                                                                                                                                @x2
                                                                                                                                                                                                                                                                                                (Prims.op_Division
                                                                                                                                                                                                                                                                                                 @x0
                                                                                                                                                                                                                                                                                                 @x2)))))))
                                                                                                                                                                                                                                                                                          :qid
                                                                                                                                                                                                                                                                                           @query.87)))
                                                                                                                                                                                                                                                                                       :qid
                                                                                                                                                                                                                                                                                        @query.86))))
                                                                                                                                                                                                                                                                                   :qid
                                                                                                                                                                                                                                                                                    @query.85)))
                                                                                                                                                                                                                                                                                :qid
                                                                                                                                                                                                                                                                                 @query.84))))
                                                                                                                                                                                                                                                                            :qid
                                                                                                                                                                                                                                                                             @query.83)))
                                                                                                                                                                                                                                                                         :qid
                                                                                                                                                                                                                                                                          @query.82))))
                                                                                                                                                                                                                                                                     :qid
                                                                                                                                                                                                                                                                      @query.78)))
                                                                                                                                                                                                                                                                  :qid
                                                                                                                                                                                                                                                                   @query.77)))
                                                                                                                                                                                                                                                               :qid
                                                                                                                                                                                                                                                                @query.76)))
                                                                                                                                                                                                                                                            :qid
                                                                                                                                                                                                                                                             @query.75)))
                                                                                                                                                                                                                                                         :qid
                                                                                                                                                                                                                                                          @query.74))))
                                                                                                                                                                                                                                                     :qid
                                                                                                                                                                                                                                                      @query.73)))
                                                                                                                                                                                                                                                  :qid
                                                                                                                                                                                                                                                   @query.72)))
                                                                                                                                                                                                                                               :qid
                                                                                                                                                                                                                                                @query.71)))
                                                                                                                                                                                                                                            :qid
                                                                                                                                                                                                                                             @query.70))))
                                                                                                                                                                                                                                        :qid
                                                                                                                                                                                                                                         @query.69)))
                                                                                                                                                                                                                                     :qid
                                                                                                                                                                                                                                      @query.68)))
                                                                                                                                                                                                                                  :qid
                                                                                                                                                                                                                                   @query.67))))
                                                                                                                                                                                                                              :qid
                                                                                                                                                                                                                               @query.66)))
                                                                                                                                                                                                                           :qid
                                                                                                                                                                                                                            @query.65))))
                                                                                                                                                                                                                       :qid
                                                                                                                                                                                                                        @query.64)))
                                                                                                                                                                                                                    :qid
                                                                                                                                                                                                                     @query.63)))
                                                                                                                                                                                                                 :qid
                                                                                                                                                                                                                  @query.62))))
                                                                                                                                                                                                             :qid
                                                                                                                                                                                                              @query.61)))
                                                                                                                                                                                                          :qid
                                                                                                                                                                                                           @query.60))))
                                                                                                                                                                                                      :qid
                                                                                                                                                                                                       @query.59))
                                                                                                                                                                                                    ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                    (forall
                                                                                                                                                                                                      ((@x60
                                                                                                                                                                                                        Term))
                                                                                                                                                                                                     (! (implies
                                                                                                                                                                                                       (HasType
                                                                                                                                                                                                        @x60
                                                                                                                                                                                                        (Tm_arrow_25637cfaa71cfdd51f994e327b27bd15
                                                                                                                                                                                                         @x2
                                                                                                                                                                                                         @x1
                                                                                                                                                                                                         @x0))
                                                                                                                                                                                                       ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                                                                                                       (forall
                                                                                                                                                                                                         ((@x61
                                                                                                                                                                                                           Term))
                                                                                                                                                                                                        (! (implies
                                                                                                                                                                                                          (HasType
                                                                                                                                                                                                           @x61
                                                                                                                                                                                                           Prims.unit)
                                                                                                                                                                                                          ;; def=FStar.Math.Lemmas.fst(223,4-223,6); use=FStar.Math.Lemmas.fst(223,7-223,9)
                                                                                                                                                                                                          (or
                                                                                                                                                                                                           label_30
                                                                                                                                                                                                           ;; def=FStar.Math.Lemmas.fst(223,4-223,6); use=FStar.Math.Lemmas.fst(223,7-223,9)
                                                                                                                                                                                                           (=
                                                                                                                                                                                                            (Prims.op_Subtraction
                                                                                                                                                                                                             (Prims.op_Subtraction
                                                                                                                                                                                                              (Prims.op_Addition
                                                                                                                                                                                                               @x0
                                                                                                                                                                                                               (Prims.op_Multiply
                                                                                                                                                                                                                @x1
                                                                                                                                                                                                                @x2))
                                                                                                                                                                                                              (Prims.op_Multiply
                                                                                                                                                                                                               @x2
                                                                                                                                                                                                               (Prims.op_Division
                                                                                                                                                                                                                (Prims.op_Addition
                                                                                                                                                                                                                 @x0
                                                                                                                                                                                                                 (Prims.op_Multiply
                                                                                                                                                                                                                  @x1
                                                                                                                                                                                                                  @x2))
                                                                                                                                                                                                                @x2)))
                                                                                                                                                                                                             (Prims.op_Subtraction
                                                                                                                                                                                                              @x0
                                                                                                                                                                                                              (Prims.op_Multiply
                                                                                                                                                                                                               @x2
                                                                                                                                                                                                               (Prims.op_Division
                                                                                                                                                                                                                @x0
                                                                                                                                                                                                                @x2))))
                                                                                                                                                                                                            (Prims.op_Subtraction
                                                                                                                                                                                                             (Prims.op_Addition
                                                                                                                                                                                                              (Prims.op_Multiply
                                                                                                                                                                                                               @x2
                                                                                                                                                                                                               @x1)
                                                                                                                                                                                                              (Prims.op_Multiply
                                                                                                                                                                                                               @x2
                                                                                                                                                                                                               (Prims.op_Division
                                                                                                                                                                                                                @x0
                                                                                                                                                                                                                @x2)))
                                                                                                                                                                                                             (Prims.op_Multiply
                                                                                                                                                                                                              @x2
                                                                                                                                                                                                              (Prims.op_Division
                                                                                                                                                                                                               (Prims.op_Addition
                                                                                                                                                                                                                @x0
                                                                                                                                                                                                                (Prims.op_Multiply
                                                                                                                                                                                                                 @x1
                                                                                                                                                                                                                 @x2))
                                                                                                                                                                                                               @x2))))))
                                                                                                                                                                                                         :qid
                                                                                                                                                                                                          @query.89)))
                                                                                                                                                                                                      :qid
                                                                                                                                                                                                       @query.88))))
                                                                                                                                                                                                  :qid
                                                                                                                                                                                                   @query.58)))
                                                                                                                                                                                               :qid
                                                                                                                                                                                                @query.57)))
                                                                                                                                                                                            :qid
                                                                                                                                                                                             @query.56)))
                                                                                                                                                                                         :qid
                                                                                                                                                                                          @query.55))))
                                                                                                                                                                                     :qid
                                                                                                                                                                                      @query.54)))
                                                                                                                                                                                  :qid
                                                                                                                                                                                   @query.53)))
                                                                                                                                                                               :qid
                                                                                                                                                                                @query.52)))
                                                                                                                                                                            :qid
                                                                                                                                                                             @query.51))))
                                                                                                                                                                        :qid
                                                                                                                                                                         @query.50)))
                                                                                                                                                                     :qid
                                                                                                                                                                      @query.49)))
                                                                                                                                                                  :qid
                                                                                                                                                                   @query.48)))
                                                                                                                                                               :qid
                                                                                                                                                                @query.47)))
                                                                                                                                                            :qid
                                                                                                                                                             @query.46))))
                                                                                                                                                        :qid
                                                                                                                                                         @query.45)))
                                                                                                                                                     :qid
                                                                                                                                                      @query.44)))
                                                                                                                                                  :qid
                                                                                                                                                   @query.43)))
                                                                                                                                               :qid
                                                                                                                                                @query.42))))
                                                                                                                                           :qid
                                                                                                                                            @query.41)))
                                                                                                                                        :qid
                                                                                                                                         @query.40)))
                                                                                                                                     :qid
                                                                                                                                      @query.39))))
                                                                                                                                 :qid
                                                                                                                                  @query.38)))
                                                                                                                              :qid
                                                                                                                               @query.37))))
                                                                                                                          :qid
                                                                                                                           @query.36))
                                                                                                                        ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                        (forall
                                                                                                                          ((@x37
                                                                                                                            Term))
                                                                                                                         (! (implies
                                                                                                                           (HasType
                                                                                                                            @x37
                                                                                                                            (Tm_arrow_970ab26aebe0cd53184e42983cdfe91b
                                                                                                                             @x2
                                                                                                                             @x1
                                                                                                                             @x0))
                                                                                                                           ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-228,3)
                                                                                                                           (forall
                                                                                                                             ((@x38
                                                                                                                               Term))
                                                                                                                            (! (implies
                                                                                                                              (HasType
                                                                                                                               @x38
                                                                                                                               Prims.unit)
                                                                                                                              ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(225,9-226,59)
                                                                                                                              (and
                                                                                                                               (implies
                                                                                                                                ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(225,41-225,42)
                                                                                                                                (>
                                                                                                                                 (BoxInt_proj_0
                                                                                                                                  @x2)
                                                                                                                                 (BoxInt_proj_0
                                                                                                                                  (BoxInt
                                                                                                                                   0)))
                                                                                                                                ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(225,41-225,42)
                                                                                                                                (or
                                                                                                                                 label_31
                                                                                                                                 ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(225,41-225,42)
                                                                                                                                 (not
                                                                                                                                  (=
                                                                                                                                   @x2
                                                                                                                                   (BoxInt
                                                                                                                                    0)))))
                                                                                                                               ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(225,9-226,59)
                                                                                                                               (forall
                                                                                                                                 ((@x39
                                                                                                                                   Term))
                                                                                                                                (! (implies
                                                                                                                                  (and
                                                                                                                                   (HasType
                                                                                                                                    @x39
                                                                                                                                    Prims.pos)
                                                                                                                                   ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(225,9-226,59)
                                                                                                                                   (=
                                                                                                                                    @x2
                                                                                                                                    @x39))
                                                                                                                                  ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(225,9-226,59)
                                                                                                                                  (forall
                                                                                                                                    ((@x40
                                                                                                                                      Term))
                                                                                                                                   (! (implies
                                                                                                                                     (and
                                                                                                                                      (HasType
                                                                                                                                       @x40
                                                                                                                                       Prims.int)
                                                                                                                                      ;; def=FStar.Math.Lemmas.fsti(57,48-57,49); use=FStar.Math.Lemmas.fst(225,9-226,59)
                                                                                                                                      (=
                                                                                                                                       (Prims.op_Division
                                                                                                                                        @x0
                                                                                                                                        @x2)
                                                                                                                                       @x40))
                                                                                                                                     ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(225,9-225,33)
                                                                                                                                     (forall
                                                                                                                                       ((@x41
                                                                                                                                         Term))
                                                                                                                                      (! (implies
                                                                                                                                        (and
                                                                                                                                         (HasType
                                                                                                                                          @x41
                                                                                                                                          Prims.unit)
                                                                                                                                         ;; def=FStar.Math.Lemmas.fsti(58,2-58,31); use=FStar.Math.Lemmas.fst(225,9-225,33)
                                                                                                                                         (=
                                                                                                                                          (Prims.op_Multiply
                                                                                                                                           @x2
                                                                                                                                           (Prims.op_Addition
                                                                                                                                            @x1
                                                                                                                                            (Prims.op_Division
                                                                                                                                             @x0
                                                                                                                                             @x2)))
                                                                                                                                          (Prims.op_Addition
                                                                                                                                           (Prims.op_Multiply
                                                                                                                                            @x2
                                                                                                                                            @x1)
                                                                                                                                           (Prims.op_Multiply
                                                                                                                                            @x2
                                                                                                                                            (Prims.op_Division
                                                                                                                                             @x0
                                                                                                                                             @x2)))))
                                                                                                                                        ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(225,9-226,59)
                                                                                                                                        (and
                                                                                                                                         (implies
                                                                                                                                          ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(226,43-226,44)
                                                                                                                                          (>
                                                                                                                                           (BoxInt_proj_0
                                                                                                                                            @x2)
                                                                                                                                           (BoxInt_proj_0
                                                                                                                                            (BoxInt
                                                                                                                                             0)))
                                                                                                                                          ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(226,43-226,44)
                                                                                                                                          (or
                                                                                                                                           label_32
                                                                                                                                           ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(226,43-226,44)
                                                                                                                                           (not
                                                                                                                                            (=
                                                                                                                                             @x2
                                                                                                                                             (BoxInt
                                                                                                                                              0)))))
                                                                                                                                         ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(225,9-226,59)
                                                                                                                                         (forall
                                                                                                                                           ((@x42
                                                                                                                                             Term))
                                                                                                                                          (! (implies
                                                                                                                                            (and
                                                                                                                                             (HasType
                                                                                                                                              @x42
                                                                                                                                              Prims.pos)
                                                                                                                                             ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(225,9-226,59)
                                                                                                                                             (=
                                                                                                                                              @x2
                                                                                                                                              @x42))
                                                                                                                                            ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(225,9-226,59)
                                                                                                                                            (forall
                                                                                                                                              ((@x43
                                                                                                                                                Term))
                                                                                                                                             (! (implies
                                                                                                                                               (and
                                                                                                                                                (HasType
                                                                                                                                                 @x43
                                                                                                                                                 Prims.int)
                                                                                                                                                ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(225,9-226,59)
                                                                                                                                                (=
                                                                                                                                                 (Prims.op_Division
                                                                                                                                                  @x0
                                                                                                                                                  @x2)
                                                                                                                                                 @x43))
                                                                                                                                               ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(225,9-226,59)
                                                                                                                                               (forall
                                                                                                                                                 ((@x44
                                                                                                                                                   Term))
                                                                                                                                                (! (implies
                                                                                                                                                  (and
                                                                                                                                                   (HasType
                                                                                                                                                    @x44
                                                                                                                                                    Prims.int)
                                                                                                                                                   ;; def=FStar.Math.Lemmas.fsti(103,39-103,40); use=FStar.Math.Lemmas.fst(225,9-226,59)
                                                                                                                                                   (=
                                                                                                                                                    (Prims.op_Addition
                                                                                                                                                     @x1
                                                                                                                                                     (Prims.op_Division
                                                                                                                                                      @x0
                                                                                                                                                      @x2))
                                                                                                                                                    @x44))
                                                                                                                                                  ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(225,9-226,59)
                                                                                                                                                  (and
                                                                                                                                                   (implies
                                                                                                                                                    ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(226,57-226,58)
                                                                                                                                                    (>
                                                                                                                                                     (BoxInt_proj_0
                                                                                                                                                      @x2)
                                                                                                                                                     (BoxInt_proj_0
                                                                                                                                                      (BoxInt
                                                                                                                                                       0)))
                                                                                                                                                    ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(226,57-226,58)
                                                                                                                                                    (or
                                                                                                                                                     label_33
                                                                                                                                                     ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(226,57-226,58)
                                                                                                                                                     (not
                                                                                                                                                      (=
                                                                                                                                                       @x2
                                                                                                                                                       (BoxInt
                                                                                                                                                        0)))))
                                                                                                                                                   ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(225,9-226,59)
                                                                                                                                                   (forall
                                                                                                                                                     ((@x45
                                                                                                                                                       Term))
                                                                                                                                                    (! (implies
                                                                                                                                                      (and
                                                                                                                                                       (HasType
                                                                                                                                                        @x45
                                                                                                                                                        Prims.pos)
                                                                                                                                                       ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(225,9-226,59)
                                                                                                                                                       (=
                                                                                                                                                        @x2
                                                                                                                                                        @x45))
                                                                                                                                                      ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(225,9-226,59)
                                                                                                                                                      (forall
                                                                                                                                                        ((@x46
                                                                                                                                                          Term))
                                                                                                                                                       (! (implies
                                                                                                                                                         (and
                                                                                                                                                          (HasType
                                                                                                                                                           @x46
                                                                                                                                                           Prims.int)
                                                                                                                                                          ;; def=FStar.Math.Lemmas.fsti(103,48-103,49); use=FStar.Math.Lemmas.fst(225,9-226,59)
                                                                                                                                                          (=
                                                                                                                                                           (Prims.op_Division
                                                                                                                                                            (Prims.op_Addition
                                                                                                                                                             @x0
                                                                                                                                                             (Prims.op_Multiply
                                                                                                                                                              @x1
                                                                                                                                                              @x2))
                                                                                                                                                            @x2)
                                                                                                                                                           @x46))
                                                                                                                                                         ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(226,9-226,33)
                                                                                                                                                         (forall
                                                                                                                                                           ((@x47
                                                                                                                                                             Term))
                                                                                                                                                          (! (implies
                                                                                                                                                            (and
                                                                                                                                                             (HasType
                                                                                                                                                              @x47
                                                                                                                                                              Prims.unit)
                                                                                                                                                             ;; def=FStar.Math.Lemmas.fsti(104,8-104,39); use=FStar.Math.Lemmas.fst(226,9-226,33)
                                                                                                                                                             (=
                                                                                                                                                              (Prims.op_Multiply
                                                                                                                                                               @x2
                                                                                                                                                               (Prims.op_Subtraction
                                                                                                                                                                (Prims.op_Addition
                                                                                                                                                                 @x1
                                                                                                                                                                 (Prims.op_Division
                                                                                                                                                                  @x0
                                                                                                                                                                  @x2))
                                                                                                                                                                (Prims.op_Division
                                                                                                                                                                 (Prims.op_Addition
                                                                                                                                                                  @x0
                                                                                                                                                                  (Prims.op_Multiply
                                                                                                                                                                   @x1
                                                                                                                                                                   @x2))
                                                                                                                                                                 @x2)))
                                                                                                                                                              (Prims.op_Subtraction
                                                                                                                                                               (Prims.op_Multiply
                                                                                                                                                                @x2
                                                                                                                                                                (Prims.op_Addition
                                                                                                                                                                 @x1
                                                                                                                                                                 (Prims.op_Division
                                                                                                                                                                  @x0
                                                                                                                                                                  @x2)))
                                                                                                                                                               (Prims.op_Multiply
                                                                                                                                                                @x2
                                                                                                                                                                (Prims.op_Division
                                                                                                                                                                 (Prims.op_Addition
                                                                                                                                                                  @x0
                                                                                                                                                                  (Prims.op_Multiply
                                                                                                                                                                   @x1
                                                                                                                                                                   @x2))
                                                                                                                                                                 @x2)))))
                                                                                                                                                            ;; def=FStar.Math.Lemmas.fst(225,4-225,6); use=FStar.Math.Lemmas.fst(226,9-226,59)
                                                                                                                                                            (or
                                                                                                                                                             label_34
                                                                                                                                                             ;; def=FStar.Math.Lemmas.fst(225,4-225,6); use=FStar.Math.Lemmas.fst(226,9-226,59)
                                                                                                                                                             (=
                                                                                                                                                              (Prims.op_Subtraction
                                                                                                                                                               (Prims.op_Addition
                                                                                                                                                                (Prims.op_Multiply
                                                                                                                                                                 @x2
                                                                                                                                                                 @x1)
                                                                                                                                                                (Prims.op_Multiply
                                                                                                                                                                 @x2
                                                                                                                                                                 (Prims.op_Division
                                                                                                                                                                  @x0
                                                                                                                                                                  @x2)))
                                                                                                                                                               (Prims.op_Multiply
                                                                                                                                                                @x2
                                                                                                                                                                (Prims.op_Division
                                                                                                                                                                 (Prims.op_Addition
                                                                                                                                                                  @x0
                                                                                                                                                                  (Prims.op_Multiply
                                                                                                                                                                   @x1
                                                                                                                                                                   @x2))
                                                                                                                                                                 @x2)))
                                                                                                                                                              (Prims.op_Multiply
                                                                                                                                                               @x2
                                                                                                                                                               (Prims.op_Subtraction
                                                                                                                                                                (Prims.op_Addition
                                                                                                                                                                 @x1
                                                                                                                                                                 (Prims.op_Division
                                                                                                                                                                  @x0
                                                                                                                                                                  @x2))
                                                                                                                                                                (Prims.op_Division
                                                                                                                                                                 (Prims.op_Addition
                                                                                                                                                                  @x0
                                                                                                                                                                  (Prims.op_Multiply
                                                                                                                                                                   @x1
                                                                                                                                                                   @x2))
                                                                                                                                                                 @x2))))))
                                                                                                                                                           :qid
                                                                                                                                                            @query.100)))
                                                                                                                                                        :qid
                                                                                                                                                         @query.99)))
                                                                                                                                                     :qid
                                                                                                                                                      @query.98))))
                                                                                                                                                 :qid
                                                                                                                                                  @query.97)))
                                                                                                                                              :qid
                                                                                                                                               @query.96)))
                                                                                                                                           :qid
                                                                                                                                            @query.95))))
                                                                                                                                       :qid
                                                                                                                                        @query.94)))
                                                                                                                                    :qid
                                                                                                                                     @query.93)))
                                                                                                                                 :qid
                                                                                                                                  @query.92))))
                                                                                                                             :qid
                                                                                                                              @query.91)))
                                                                                                                          :qid
                                                                                                                           @query.90))))
                                                                                                                      :qid
                                                                                                                       @query.35)))
                                                                                                                   :qid
                                                                                                                    @query.34)))
                                                                                                                :qid
                                                                                                                 @query.33)))
                                                                                                             :qid
                                                                                                              @query.32))))
                                                                                                         :qid
                                                                                                          @query.31)))
                                                                                                      :qid
                                                                                                       @query.30)))
                                                                                                   :qid
                                                                                                    @query.29))))
                                                                                               :qid
                                                                                                @query.28)))
                                                                                            :qid
                                                                                             @query.27)))
                                                                                         :qid
                                                                                          @query.26)))
                                                                                      :qid @query.25))))
                                                                                  :qid @query.24)))
                                                                               :qid @query.23)))
                                                                            :qid @query.22)))
                                                                         :qid @query.21))))
                                                                     :qid @query.20)))
                                                                  :qid @query.19)))
                                                               :qid @query.18))))
                                                           :qid @query.17)))
                                                        :qid @query.16))))
                                                    :qid @query.15))
                                                  ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                  (forall ((@x16 Term))
                                                   (! (implies
                                                     (HasType
                                                      @x16
                                                      (Tm_arrow_add55cf7f80c77296b3826c2996cf6ad
                                                       @x2
                                                       @x1
                                                       @x0))
                                                     ;; def=Prims.fst(449,29-449,97); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                     (and
                                                      ;; def=FStar.Calc.fsti(47,4-47,55); use=FStar.Calc.fsti(47,4-47,55)
                                                      (forall ((@x17 Term) (@x18 Term))
                                                       (! (implies
                                                         (and
                                                          (HasType @x17 Prims.int)
                                                          (HasType @x18 Prims.int)
                                                          ;; def=FStar.Calc.fsti(42,16-42,65); use=FStar.Calc.fsti(42,16-42,65)
                                                          (exists ((@x19 Term))
                                                           (! (and
                                                             (HasType @x19 Prims.int)
                                                             ;; def=FStar.Calc.fsti(42,16-42,65); use=FStar.Calc.fsti(42,16-42,65)
                                                             (exists ((@x20 Term))
                                                              (! (and
                                                                (HasType @x20 Prims.int)
                                                                ;; def=FStar.Calc.fsti(42,16-42,65); use=FStar.Calc.fsti(42,16-42,65)
                                                                (exists ((@x21 Term))
                                                                 (! (and
                                                                   (HasType @x21 Prims.int)
                                                                   ;; def=FStar.Calc.fsti(40,12-40,18); use=FStar.Calc.fsti(40,12-40,18)
                                                                   (= @x17 @x21)
                                                                   ;; def=FStar.Math.Lemmas.fst(221,4-221,6); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                                   (= @x21 @x20))
                                                                  :qid @query.105))
                                                                ;; def=FStar.Math.Lemmas.fst(223,4-223,6); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                                (= @x20 @x19))
                                                               :qid @query.104))
                                                             ;; def=FStar.Math.Lemmas.fst(225,4-225,6); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                             (= @x19 @x18))
                                                            :qid @query.103)))
                                                         ;; def=FStar.Math.Lemmas.fst(219,7-219,11); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                         (or
                                                          label_35
                                                          ;; def=FStar.Math.Lemmas.fst(219,7-219,11); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                          (= @x17 @x18)))
                                                        :qid @query.102))
                                                      ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                      (forall ((@x17 Term))
                                                       (! (implies
                                                         (and
                                                          (HasType @x17 Prims.unit)
                                                          ;; def=FStar.Math.Lemmas.fst(219,7-219,11); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                          (=
                                                           (Prims.op_Subtraction
                                                            (Prims.op_Modulus
                                                             (Prims.op_Addition
                                                              @x0
                                                              (Prims.op_Multiply @x1 @x2))
                                                             @x2)
                                                            (Prims.op_Modulus @x0 @x2))
                                                           (Prims.op_Multiply
                                                            @x2
                                                            (Prims.op_Subtraction
                                                             (Prims.op_Addition
                                                              @x1
                                                              (Prims.op_Division @x0 @x2))
                                                             (Prims.op_Division
                                                              (Prims.op_Addition
                                                               @x0
                                                               (Prims.op_Multiply @x1 @x2))
                                                              @x2)))))
                                                         ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                         (and
                                                          (implies
                                                           ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(229,32-229,33)
                                                           (>
                                                            (BoxInt_proj_0 @x2)
                                                            (BoxInt_proj_0 (BoxInt 0)))
                                                           ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(229,32-229,33)
                                                           (or
                                                            label_36
                                                            ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(229,32-229,33)
                                                            (not (= @x2 (BoxInt 0)))))
                                                          ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                          (forall ((@x18 Term))
                                                           (! (implies
                                                             (and
                                                              (HasType @x18 Prims.pos)
                                                              ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                              (= @x2 @x18))
                                                             ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                             (forall ((@x19 Term))
                                                              (! (implies
                                                                (and
                                                                 (HasType @x19 Prims.int)
                                                                 ;; def=FStar.Math.Lemmas.fsti(190,28-190,31); use=FStar.Math.Lemmas.fst(229,2-229,34)
                                                                 (=
                                                                  (Prims.op_Modulus
                                                                   (Prims.op_Addition
                                                                    @x0
                                                                    (Prims.op_Multiply @x1 @x2))
                                                                   @x2)
                                                                  @x19))
                                                                ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                                (and
                                                                 ;; def=Prims.fst(682,18-682,24); use=FStar.Math.Lemmas.fst(229,23-229,34)
                                                                 (or
                                                                  label_37
                                                                  ;; def=Prims.fst(682,18-682,24); use=FStar.Math.Lemmas.fst(229,23-229,34)
                                                                  (>=
                                                                   (BoxInt_proj_0
                                                                    (Prims.op_Modulus
                                                                     (Prims.op_Addition
                                                                      @x0
                                                                      (Prims.op_Multiply @x1 @x2))
                                                                     @x2))
                                                                   (BoxInt_proj_0 (BoxInt 0))))
                                                                 ;; def=Prims.fst(364,2-364,58); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                                 (forall ((@x20 Term))
                                                                  (! (implies
                                                                    (and
                                                                     (HasType @x20 Prims.nat)
                                                                     ;; def=Prims.fst(364,26-364,41); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                                     (=
                                                                      @x20
                                                                      (Prims.op_Modulus
                                                                       (Prims.op_Addition
                                                                        @x0
                                                                        (Prims.op_Multiply @x1 @x2))
                                                                       @x2))
                                                                     ;; def=FStar.Math.Lemmas.fsti(190,26-190,27); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                                     (=
                                                                      (Prims.op_Modulus
                                                                       (Prims.op_Addition
                                                                        @x0
                                                                        (Prims.op_Multiply @x1 @x2))
                                                                       @x2)
                                                                      @x20))
                                                                    ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                                    (and
                                                                     (implies
                                                                      ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(229,38-229,39)
                                                                      (>
                                                                       (BoxInt_proj_0 @x2)
                                                                       (BoxInt_proj_0 (BoxInt 0)))
                                                                      ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(229,38-229,39)
                                                                      (or
                                                                       label_38
                                                                       ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(229,38-229,39)
                                                                       (not (= @x2 (BoxInt 0)))))
                                                                     ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                                     (forall ((@x21 Term))
                                                                      (! (implies
                                                                        (and
                                                                         (HasType @x21 Prims.pos)
                                                                         ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                                         (= @x2 @x21))
                                                                        ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                                        (forall ((@x22 Term))
                                                                         (! (implies
                                                                           (and
                                                                            (HasType @x22 Prims.int)
                                                                            ;; def=FStar.Math.Lemmas.fsti(190,36-190,39); use=FStar.Math.Lemmas.fst(229,2-229,40)
                                                                            (=
                                                                             (Prims.op_Modulus
                                                                              @x0
                                                                              @x2)
                                                                             @x22))
                                                                           ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                                           (and
                                                                            ;; def=Prims.fst(682,18-682,24); use=FStar.Math.Lemmas.fst(229,35-229,40)
                                                                            (or
                                                                             label_39
                                                                             ;; def=Prims.fst(682,18-682,24); use=FStar.Math.Lemmas.fst(229,35-229,40)
                                                                             (>=
                                                                              (BoxInt_proj_0
                                                                               (Prims.op_Modulus
                                                                                @x0
                                                                                @x2))
                                                                              (BoxInt_proj_0
                                                                               (BoxInt 0))))
                                                                            ;; def=Prims.fst(364,2-364,58); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                                            (forall ((@x23 Term))
                                                                             (! (implies
                                                                               (and
                                                                                (HasType
                                                                                 @x23
                                                                                 Prims.nat)
                                                                                ;; def=Prims.fst(364,26-364,41); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                                                (=
                                                                                 @x23
                                                                                 (Prims.op_Modulus
                                                                                  @x0
                                                                                  @x2))
                                                                                ;; def=FStar.Math.Lemmas.fsti(190,34-190,35); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                                                (=
                                                                                 (Prims.op_Modulus
                                                                                  @x0
                                                                                  @x2)
                                                                                 @x23))
                                                                               ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                                               (and
                                                                                (implies
                                                                                 ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(229,48-229,49)
                                                                                 (>
                                                                                  (BoxInt_proj_0 @x2)
                                                                                  (BoxInt_proj_0
                                                                                   (BoxInt 0)))
                                                                                 ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(229,48-229,49)
                                                                                 (or
                                                                                  label_40
                                                                                  ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(229,48-229,49)
                                                                                  (not
                                                                                   (= @x2 (BoxInt 0)))))
                                                                                ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                                                (forall
                                                                                  ((@x24 Term))
                                                                                 (! (implies
                                                                                   (and
                                                                                    (HasType
                                                                                     @x24
                                                                                     Prims.pos)
                                                                                    ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                                                    (= @x2 @x24))
                                                                                   ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                                                   (forall
                                                                                     ((@x25 Term))
                                                                                    (! (implies
                                                                                      (and
                                                                                       (HasType
                                                                                        @x25
                                                                                        Prims.int)
                                                                                       ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                                                       (=
                                                                                        (Prims.op_Division
                                                                                         @x0
                                                                                         @x2)
                                                                                        @x25))
                                                                                      ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                                                      (forall
                                                                                        ((@x26 Term))
                                                                                       (! (implies
                                                                                         (and
                                                                                          (HasType
                                                                                           @x26
                                                                                           Prims.int)
                                                                                          ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                                                          (=
                                                                                           (Prims.op_Addition
                                                                                            @x1
                                                                                            (Prims.op_Division
                                                                                             @x0
                                                                                             @x2))
                                                                                           @x26))
                                                                                         ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                                                         (and
                                                                                          (implies
                                                                                           ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(229,60-229,61)
                                                                                           (>
                                                                                            (BoxInt_proj_0
                                                                                             @x2)
                                                                                            (BoxInt_proj_0
                                                                                             (BoxInt
                                                                                              0)))
                                                                                           ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(229,60-229,61)
                                                                                           (or
                                                                                            label_41
                                                                                            ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(229,60-229,61)
                                                                                            (not
                                                                                             (=
                                                                                              @x2
                                                                                              (BoxInt
                                                                                               0)))))
                                                                                          ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                                                          (forall
                                                                                            ((@x27
                                                                                              Term))
                                                                                           (! (implies
                                                                                             (and
                                                                                              (HasType
                                                                                               @x27
                                                                                               Prims.pos)
                                                                                              ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                                                              (=
                                                                                               @x2
                                                                                               @x27))
                                                                                             ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                                                             (forall
                                                                                               ((@x28
                                                                                                 Term))
                                                                                              (! (implies
                                                                                                (and
                                                                                                 (HasType
                                                                                                  @x28
                                                                                                  Prims.int)
                                                                                                 ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                                                                 (=
                                                                                                  (Prims.op_Division
                                                                                                   (Prims.op_Addition
                                                                                                    @x0
                                                                                                    (Prims.op_Multiply
                                                                                                     @x1
                                                                                                     @x2))
                                                                                                   @x2)
                                                                                                  @x28))
                                                                                                ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                                                                (forall
                                                                                                  ((@x29
                                                                                                    Term))
                                                                                                 (! (implies
                                                                                                   (and
                                                                                                    (HasType
                                                                                                     @x29
                                                                                                     Prims.int)
                                                                                                    ;; def=FStar.Math.Lemmas.fsti(190,42-190,43); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                                                                    (=
                                                                                                     (Prims.op_Subtraction
                                                                                                      (Prims.op_Addition
                                                                                                       @x1
                                                                                                       (Prims.op_Division
                                                                                                        @x0
                                                                                                        @x2))
                                                                                                      (Prims.op_Division
                                                                                                       (Prims.op_Addition
                                                                                                        @x0
                                                                                                        (Prims.op_Multiply
                                                                                                         @x1
                                                                                                         @x2))
                                                                                                       @x2))
                                                                                                     @x29))
                                                                                                   ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                                                                   (and
                                                                                                    (implies
                                                                                                     ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(229,63-229,64)
                                                                                                     (>
                                                                                                      (BoxInt_proj_0
                                                                                                       @x2)
                                                                                                      (BoxInt_proj_0
                                                                                                       (BoxInt
                                                                                                        0)))
                                                                                                     ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(229,63-229,64)
                                                                                                     (or
                                                                                                      label_42
                                                                                                      ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(229,63-229,64)
                                                                                                      (not
                                                                                                       (=
                                                                                                        @x2
                                                                                                        (BoxInt
                                                                                                         0)))))
                                                                                                    ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                                                                    (forall
                                                                                                      ((@x30
                                                                                                        Term))
                                                                                                     (! (implies
                                                                                                       (and
                                                                                                        (HasType
                                                                                                         @x30
                                                                                                         Prims.pos)
                                                                                                        ;; def=FStar.Math.Lemmas.fsti(190,50-190,51); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                                                                        (=
                                                                                                         @x2
                                                                                                         @x30))
                                                                                                       ;; def=Prims.fst(449,29-449,97); use=FStar.Math.Lemmas.fst(229,2-229,22)
                                                                                                       (and
                                                                                                        ;; def=FStar.Math.Lemmas.fsti(191,12-191,17); use=FStar.Math.Lemmas.fst(229,2-229,22)
                                                                                                        (or
                                                                                                         label_43
                                                                                                         ;; def=FStar.Math.Lemmas.fsti(191,12-191,17); use=FStar.Math.Lemmas.fst(229,2-229,22)
                                                                                                         (<
                                                                                                          (BoxInt_proj_0
                                                                                                           (Prims.op_Modulus
                                                                                                            (Prims.op_Addition
                                                                                                             @x0
                                                                                                             (Prims.op_Multiply
                                                                                                              @x1
                                                                                                              @x2))
                                                                                                            @x2))
                                                                                                          (BoxInt_proj_0
                                                                                                           @x2)))
                                                                                                        ;; def=FStar.Math.Lemmas.fsti(191,21-191,26); use=FStar.Math.Lemmas.fst(229,2-229,22)
                                                                                                        (or
                                                                                                         label_44
                                                                                                         ;; def=FStar.Math.Lemmas.fsti(191,21-191,26); use=FStar.Math.Lemmas.fst(229,2-229,22)
                                                                                                         (<
                                                                                                          (BoxInt_proj_0
                                                                                                           (Prims.op_Modulus
                                                                                                            @x0
                                                                                                            @x2))
                                                                                                          (BoxInt_proj_0
                                                                                                           @x2)))
                                                                                                        ;; def=FStar.Math.Lemmas.fsti(191,30-191,44); use=FStar.Math.Lemmas.fst(229,2-229,22)
                                                                                                        (or
                                                                                                         label_45
                                                                                                         ;; def=FStar.Math.Lemmas.fsti(191,30-191,44); use=FStar.Math.Lemmas.fst(229,2-229,22)
                                                                                                         (=
                                                                                                          (Prims.op_Modulus
                                                                                                           (Prims.op_Addition
                                                                                                            @x0
                                                                                                            (Prims.op_Multiply
                                                                                                             @x1
                                                                                                             @x2))
                                                                                                           @x2)
                                                                                                          (Prims.op_Addition
                                                                                                           (Prims.op_Modulus
                                                                                                            @x0
                                                                                                            @x2)
                                                                                                           (Prims.op_Multiply
                                                                                                            (Prims.op_Subtraction
                                                                                                             (Prims.op_Addition
                                                                                                              @x1
                                                                                                              (Prims.op_Division
                                                                                                               @x0
                                                                                                               @x2))
                                                                                                             (Prims.op_Division
                                                                                                              (Prims.op_Addition
                                                                                                               @x0
                                                                                                               (Prims.op_Multiply
                                                                                                                @x1
                                                                                                                @x2))
                                                                                                              @x2))
                                                                                                            @x2))))
                                                                                                        ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(229,2-229,22)
                                                                                                        (forall
                                                                                                          ((@x31
                                                                                                            Term))
                                                                                                         (! (implies
                                                                                                           (and
                                                                                                            (HasType
                                                                                                             @x31
                                                                                                             Prims.unit)
                                                                                                            ;; def=FStar.Math.Lemmas.fsti(192,11-192,17); use=FStar.Math.Lemmas.fst(229,2-229,22)
                                                                                                            (=
                                                                                                             (Prims.op_Modulus
                                                                                                              (Prims.op_Addition
                                                                                                               @x0
                                                                                                               (Prims.op_Multiply
                                                                                                                @x1
                                                                                                                @x2))
                                                                                                              @x2)
                                                                                                             (Prims.op_Modulus
                                                                                                              @x0
                                                                                                              @x2))
                                                                                                            ;; def=FStar.Math.Lemmas.fsti(192,21-192,27); use=FStar.Math.Lemmas.fst(229,2-229,22)
                                                                                                            (=
                                                                                                             (Prims.op_Subtraction
                                                                                                              (Prims.op_Addition
                                                                                                               @x1
                                                                                                               (Prims.op_Division
                                                                                                                @x0
                                                                                                                @x2))
                                                                                                              (Prims.op_Division
                                                                                                               (Prims.op_Addition
                                                                                                                @x0
                                                                                                                (Prims.op_Multiply
                                                                                                                 @x1
                                                                                                                 @x2))
                                                                                                               @x2))
                                                                                                             (BoxInt
                                                                                                              0)))
                                                                                                           ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                                                                           (forall
                                                                                                             ((@x32
                                                                                                               Term))
                                                                                                            (! (implies
                                                                                                              (HasType
                                                                                                               @x32
                                                                                                               Prims.unit)
                                                                                                              ;; def=Prims.fst(459,90-459,102); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                                                                              (Valid
                                                                                                               ;; def=Prims.fst(459,90-459,102); use=FStar.Math.Lemmas.fst(219,2-230,4)
                                                                                                               (ApplyTT
                                                                                                                @x3
                                                                                                                @x32)))
                                                                                                             :qid
                                                                                                              @query.121)))
                                                                                                          :qid
                                                                                                           @query.120))))
                                                                                                      :qid
                                                                                                       @query.119))))
                                                                                                  :qid
                                                                                                   @query.118)))
                                                                                               :qid
                                                                                                @query.117)))
                                                                                            :qid
                                                                                             @query.116))))
                                                                                        :qid
                                                                                         @query.115)))
                                                                                     :qid @query.114)))
                                                                                  :qid @query.113))))
                                                                              :qid @query.112))))
                                                                          :qid @query.111)))
                                                                       :qid @query.110))))
                                                                   :qid @query.109))))
                                                               :qid @query.108)))
                                                            :qid @query.107))))
                                                        :qid @query.106))))
                                                    :qid @query.101))))
                                                :qid @query.14)))
                                             :qid @query.13)))
                                          :qid @query.12)))
                                       :qid @query.11))))
                                   :qid @query.10)))
                                :qid @query.9)))
                             :qid @query.8))))
                         :qid @query.7)))
                      :qid @query.6)))
                   :qid @query.5))))
               :qid @query.4)))
            :qid @query.3))))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_45")
(eval label_45)
(echo "label_44")
(eval label_44)
(echo "label_43")
(eval label_43)
(echo "label_42")
(eval label_42)
(echo "label_41")
(eval label_41)
(echo "label_40")
(eval label_40)
(echo "label_39")
(eval label_39)
(echo "label_38")
(eval label_38)
(echo "label_37")
(eval label_37)
(echo "label_36")
(eval label_36)
(echo "label_35")
(eval label_35)
(echo "label_34")
(eval label_34)
(echo "label_33")
(eval label_33)
(echo "label_32")
(eval label_32)
(echo "label_31")
(eval label_31)
(echo "label_30")
(eval label_30)
(echo "label_29")
(eval label_29)
(echo "label_28")
(eval label_28)
(echo "label_27")
(eval label_27)
(echo "label_26")
(eval label_26)
(echo "label_25")
(eval label_25)
(echo "label_24")
(eval label_24)
(echo "label_23")
(eval label_23)
(echo "label_22")
(eval label_22)
(echo "label_21")
(eval label_21)
(echo "label_20")
(eval label_20)
(echo "label_19")
(eval label_19)
(echo "label_18")
(eval label_18)
(echo "label_17")
(eval label_17)
(echo "label_16")
(eval label_16)
(echo "label_15")
(eval label_15)
(echo "label_14")
(eval label_14)
(echo "label_13")
(eval label_13)
(echo "label_12")
(eval label_12)
(echo "label_11")
(eval label_11)
(echo "label_10")
(eval label_10)
(echo "label_9")
(eval label_9)
(echo "label_8")
(eval label_8)
(echo "label_7")
(eval label_7)
(echo "label_6")
(eval label_6)
(echo "label_5")
(eval label_5)
(echo "label_4")
(eval label_4)
(echo "label_3")
(eval label_3)
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.lemma_mod_plus, 2)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt let lemma_mod_plus
; <Start encoding let lemma_mod_plus>
; Uninterpreted function symbol for impure function
(declare-fun FStar.Math.Lemmas.lemma_mod_plus (Term Term Term) Term)
; Uninterpreted name for impure function
(declare-fun FStar.Math.Lemmas.lemma_mod_plus@tok () Term)
; </end encoding let lemma_mod_plus>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fsti(196,0-196,80)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
(declare-fun Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9 () Term)
; refinement kinding
;;; Fact-ids: 
(assert
 (! (HasType Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9 Tm_type)
  :named refinement_kinding_Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
; refinement_interpretation
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fsti(196,45-196,80); use=FStar.Math.Lemmas.fsti(196,45-196,50)
  (forall ((@u0 Fuel) (@x1 Term))
   (! (iff
     (HasTypeFuel @u0 @x1 Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9)
     (HasTypeFuel @u0 @x1 Prims.unit))
    :pattern ((HasTypeFuel @u0 @x1 Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
    :qid refinement_interpretation_Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
  :named refinement_interpretation_Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
; haseq for Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9
;;; Fact-ids: 
(assert
 (! (iff
   (Valid (Prims.hasEq Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
   (Valid (Prims.hasEq Prims.unit)))
  :named haseqTm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
; Encoding query formula : forall (a: Prims.int) (k: Prims.int) (n: Prims.pos) (_: Prims.squash Prims.l_True).
;   (*  - Could not prove post-condition
; *)
;   (n > 0 ==> n <> 0) /\
;   (forall (any_result: Prims.pos).
;       n == any_result ==>
;       (forall (any_result: Prims.int). (a + k * n) / n == any_result ==> n > 0 ==> n <> 0))
; Context: While encoding a query
; While typechecking the top-level declaration `val FStar.Math.Lemmas.lemma_div_plus`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fsti(196,0-196,80)
   (forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
    (! (implies
      (and
       (HasType @x0 Prims.int)
       (HasType @x1 Prims.int)
       (HasType @x2 Prims.pos)
       (HasType @x3 Tm_refine_4fe5a88d1a1dcab567f82d246dbcb5b9))
      ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fsti(196,51-196,80)
      (and
       (implies
        ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fsti(196,66-196,67)
        (> (BoxInt_proj_0 @x2) (BoxInt_proj_0 (BoxInt 0)))
        ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fsti(196,66-196,67)
        (or
         label_1
         ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fsti(196,66-196,67)
         (not (= @x2 (BoxInt 0)))))
       ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fsti(196,51-196,80)
       (forall ((@x4 Term))
        (! (implies
          (and
           (HasType @x4 Prims.pos)
           ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fsti(196,51-196,80)
           (= @x2 @x4))
          ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fsti(196,51-196,80)
          (forall ((@x5 Term))
           (! (implies
             (and
              (HasType @x5 Prims.int)
              ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fsti(196,51-196,80)
              (= (Prims.op_Division (Prims.op_Addition @x0 (Prims.op_Multiply @x1 @x2)) @x2) @x5)
              ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fsti(196,74-196,75)
              (> (BoxInt_proj_0 @x2) (BoxInt_proj_0 (BoxInt 0))))
             ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fsti(196,74-196,75)
             (or
              label_2
              ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fsti(196,74-196,75)
              (not (= @x2 (BoxInt 0)))))
            :qid @query.2)))
         :qid @query.1))))
     :qid @query)))
  :named @query))
(set-option :rlimit 2500000)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop

; QUERY ID: (FStar.Math.Lemmas.lemma_div_plus, 1)
; STATUS: unsat
; Z3 invocation started by F*
; F* version: 2025.09.04~dev -- commit hash: b6a21dbcc041d7f57afb859f70724cf258982ba6
; Z3 version (according to F*): 4.15.3

(pop) ;; 2}pop
; encoding sigelt val FStar.Math.Lemmas.lemma_div_plus
; <Skipped val FStar.Math.Lemmas.lemma_div_plus/>

(push) ;; push{2
; Starting query at FStar.Math.Lemmas.fst(233,2-244,40)
(declare-fun label_40 () Bool)
(declare-fun label_39 () Bool)
(declare-fun label_38 () Bool)
(declare-fun label_37 () Bool)
(declare-fun label_36 () Bool)
(declare-fun label_35 () Bool)
(declare-fun label_34 () Bool)
(declare-fun label_33 () Bool)
(declare-fun label_32 () Bool)
(declare-fun label_31 () Bool)
(declare-fun label_30 () Bool)
(declare-fun label_29 () Bool)
(declare-fun label_28 () Bool)
(declare-fun label_27 () Bool)
(declare-fun label_26 () Bool)
(declare-fun label_25 () Bool)
(declare-fun label_24 () Bool)
(declare-fun label_23 () Bool)
(declare-fun label_22 () Bool)
(declare-fun label_21 () Bool)
(declare-fun label_20 () Bool)
(declare-fun label_19 () Bool)
(declare-fun label_18 () Bool)
(declare-fun label_17 () Bool)
(declare-fun label_16 () Bool)
(declare-fun label_15 () Bool)
(declare-fun label_14 () Bool)
(declare-fun label_13 () Bool)
(declare-fun label_12 () Bool)
(declare-fun label_11 () Bool)
(declare-fun label_10 () Bool)
(declare-fun label_9 () Bool)
(declare-fun label_8 () Bool)
(declare-fun label_7 () Bool)
(declare-fun label_6 () Bool)
(declare-fun label_5 () Bool)
(declare-fun label_4 () Bool)
(declare-fun label_3 () Bool)
(declare-fun label_2 () Bool)
(declare-fun label_1 () Bool)
; _: Prims.unit   -> FStar.Calc.calc_pack [] (n * ((a + k * n) / n - a / n)) (n * ((a + k * n) / n - a / n))
(declare-fun Tm_arrow_7da6e99647c74ea5e118aa85d2042f39 (Term Term Term) Term)
; kinding_Tm_arrow_7da6e99647c74ea5e118aa85d2042f39
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(233,2-243,3)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term))
   (! (HasType (Tm_arrow_7da6e99647c74ea5e118aa85d2042f39 @x0 @x1 @x2) Tm_type)
    :pattern ((HasType (Tm_arrow_7da6e99647c74ea5e118aa85d2042f39 @x0 @x1 @x2) Tm_type))
    :qid kinding_Tm_arrow_7da6e99647c74ea5e118aa85d2042f39))
  :named kinding_Tm_arrow_7da6e99647c74ea5e118aa85d2042f39))
; pre-typing for functions
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(233,2-243,3)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
   (! (implies
     (HasTypeFuel @u0 @x1 (Tm_arrow_7da6e99647c74ea5e118aa85d2042f39 @x2 @x3 @x4))
     (is-Tm_arrow (PreType @x1)))
    :pattern ((HasTypeFuel @u0 @x1 (Tm_arrow_7da6e99647c74ea5e118aa85d2042f39 @x2 @x3 @x4)))
    :qid FStar.Math.Lemmas_pre_typing_Tm_arrow_7da6e99647c74ea5e118aa85d2042f39))
  :named FStar.Math.Lemmas_pre_typing_Tm_arrow_7da6e99647c74ea5e118aa85d2042f39))
; interpretation_Tm_arrow_7da6e99647c74ea5e118aa85d2042f39
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(233,2-243,3)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
   (! (iff
     (HasTypeZ @x0 (Tm_arrow_7da6e99647c74ea5e118aa85d2042f39 @x1 @x2 @x3))
     (and
      ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(233,2-243,3)
      (forall ((@x4 Term))
       (! (implies
         (HasType @x4 Prims.unit)
         (HasType
          (ApplyTT @x0 @x4)
          (FStar.Calc.calc_pack
           Prims.int
           (Prims.Nil (FStar.Preorder.relation Prims.int))
           (Prims.op_Multiply
            @x3
            (Prims.op_Subtraction
             (Prims.op_Division (Prims.op_Addition @x2 (Prims.op_Multiply @x1 @x3)) @x3)
             (Prims.op_Division @x2 @x3)))
           (Prims.op_Multiply
            @x3
            (Prims.op_Subtraction
             (Prims.op_Division (Prims.op_Addition @x2 (Prims.op_Multiply @x1 @x3)) @x3)
             (Prims.op_Division @x2 @x3))))))
        :pattern ((ApplyTT @x0 @x4))
        :qid FStar.Math.Lemmas_interpretation_Tm_arrow_7da6e99647c74ea5e118aa85d2042f39.1))
      (IsTotFun @x0)))
    :pattern ((HasTypeZ @x0 (Tm_arrow_7da6e99647c74ea5e118aa85d2042f39 @x1 @x2 @x3)))
    :qid FStar.Math.Lemmas_interpretation_Tm_arrow_7da6e99647c74ea5e118aa85d2042f39))
  :named FStar.Math.Lemmas_interpretation_Tm_arrow_7da6e99647c74ea5e118aa85d2042f39))
; x5: Prims.int -> y6: Prims.int -> Type
(declare-fun Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0 () Term)
; kinding_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0
;;; Fact-ids: 
(assert
 (! (HasType Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0 Tm_type)
  :named kinding_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0))
; pre-typing for functions
;;; Fact-ids: 
(assert
 (! ;; def=Prims.fst(548,35-548,38); use=FStar.Math.Lemmas.fst(233,2-243,3)
  (forall ((@u0 Fuel) (@x1 Term))
   (! (implies
     (HasTypeFuel @u0 @x1 Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0)
     (is-Tm_arrow (PreType @x1)))
    :pattern ((HasTypeFuel @u0 @x1 Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0))
    :qid FStar.Math.Lemmas_pre_typing_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0))
  :named FStar.Math.Lemmas_pre_typing_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0))
; interpretation_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0
;;; Fact-ids: 
(assert
 (! ;; def=Prims.fst(548,35-548,38); use=FStar.Math.Lemmas.fst(233,2-243,3)
  (forall ((@x0 Term))
   (! (iff
     (HasTypeZ @x0 Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0)
     (and
      ;; def=Prims.fst(548,35-548,38); use=FStar.Math.Lemmas.fst(233,2-243,3)
      (forall ((@x1 Term) (@x2 Term))
       (! (implies
         (and (HasType @x1 Prims.int) (HasType @x2 Prims.int))
         (HasType (ApplyTT (ApplyTT @x0 @x1) @x2) Tm_type))
        :pattern ((ApplyTT (ApplyTT @x0 @x1) @x2))
        :qid FStar.Math.Lemmas_interpretation_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0.1))
      (IsTotFun @x0)
      ;; def=Prims.fst(548,35-548,38); use=FStar.Math.Lemmas.fst(233,2-243,3)
      (forall ((@x1 Term))
       (! (implies (HasType @x1 Prims.int) (IsTotFun (ApplyTT @x0 @x1)))
        :pattern ((ApplyTT @x0 @x1))
        :qid FStar.Math.Lemmas_interpretation_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0.2))))
    :pattern ((HasTypeZ @x0 Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0))
    :qid FStar.Math.Lemmas_interpretation_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0))
  :named FStar.Math.Lemmas_interpretation_Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0))
(declare-fun Tm_abs_2d12df642cab58f318db60ed4861d203 () Term)
; typing_Tm_abs_2d12df642cab58f318db60ed4861d203
;;; Fact-ids: 
(assert
 (! (HasType Tm_abs_2d12df642cab58f318db60ed4861d203 Tm_arrow_4ac6f7d06c7c49777e40abfcba22b5d0)
  :named typing_Tm_abs_2d12df642cab58f318db60ed4861d203))
; interpretation_Tm_abs_2d12df642cab58f318db60ed4861d203
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Math.Lemmas.fst(235,4-235,6); use=FStar.Math.Lemmas.fst(233,2-243,3)
  (forall ((@x0 Term) (@x1 Term))
   (! (=
     (ApplyTT (ApplyTT Tm_abs_2d12df642cab58f318db60ed4861d203 @x0) @x1)
     (Prims.eq2 Prims.int @x0 @x1))
    :pattern ((ApplyTT (ApplyTT Tm_abs_2d12df642cab58f318db60ed4861d203 @x0) @x1))
    :qid interpretation_Tm_abs_2d12df642cab58f318db60ed4861d203))
  :named interpretation_Tm_abs_2d12df642cab58f318db60ed4861d203))
; _: Prims.unit   -> FStar.Calc.calc_pack [fun x5 y6 -> x5 == y6 <: Type]       (n * ((a + k * n) / n - a / n))       (n * ((a + k * n) / n) - n * (a / n))
(declare-fun Tm_arrow_0cb77c3283d06b401322bff47481f095 (Term Term Term) Term)
; kinding_Tm_arrow_0cb77c3283d06b401322bff47481f095
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(233,2-243,3)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term))
   (! (HasType (Tm_arrow_0cb77c3283d06b401322bff47481f095 @x0 @x1 @x2) Tm_type)
    :pattern ((HasType (Tm_arrow_0cb77c3283d06b401322bff47481f095 @x0 @x1 @x2) Tm_type))
    :qid kinding_Tm_arrow_0cb77c3283d06b401322bff47481f095))
  :named kinding_Tm_arrow_0cb77c3283d06b401322bff47481f095))
; pre-typing for functions
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(233,2-243,3)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
   (! (implies
     (HasTypeFuel @u0 @x1 (Tm_arrow_0cb77c3283d06b401322bff47481f095 @x2 @x3 @x4))
     (is-Tm_arrow (PreType @x1)))
    :pattern ((HasTypeFuel @u0 @x1 (Tm_arrow_0cb77c3283d06b401322bff47481f095 @x2 @x3 @x4)))
    :qid FStar.Math.Lemmas_pre_typing_Tm_arrow_0cb77c3283d06b401322bff47481f095))
  :named FStar.Math.Lemmas_pre_typing_Tm_arrow_0cb77c3283d06b401322bff47481f095))
; interpretation_Tm_arrow_0cb77c3283d06b401322bff47481f095
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(233,2-243,3)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
   (! (iff
     (HasTypeZ @x0 (Tm_arrow_0cb77c3283d06b401322bff47481f095 @x1 @x2 @x3))
     (and
      ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(233,2-243,3)
      (forall ((@x4 Term))
       (! (implies
         (HasType @x4 Prims.unit)
         (HasType
          (ApplyTT @x0 @x4)
          (FStar.Calc.calc_pack
           Prims.int
           (Prims.Cons
            (FStar.Preorder.relation Prims.int)
            Tm_abs_2d12df642cab58f318db60ed4861d203
            (Prims.Nil (FStar.Preorder.relation Prims.int)))
           (Prims.op_Multiply
            @x3
            (Prims.op_Subtraction
             (Prims.op_Division (Prims.op_Addition @x2 (Prims.op_Multiply @x1 @x3)) @x3)
             (Prims.op_Division @x2 @x3)))
           (Prims.op_Subtraction
            (Prims.op_Multiply
             @x3
             (Prims.op_Division (Prims.op_Addition @x2 (Prims.op_Multiply @x1 @x3)) @x3))
            (Prims.op_Multiply @x3 (Prims.op_Division @x2 @x3))))))
        :pattern ((ApplyTT @x0 @x4))
        :qid FStar.Math.Lemmas_interpretation_Tm_arrow_0cb77c3283d06b401322bff47481f095.1))
      (IsTotFun @x0)))
    :pattern ((HasTypeZ @x0 (Tm_arrow_0cb77c3283d06b401322bff47481f095 @x1 @x2 @x3)))
    :qid FStar.Math.Lemmas_interpretation_Tm_arrow_0cb77c3283d06b401322bff47481f095))
  :named FStar.Math.Lemmas_interpretation_Tm_arrow_0cb77c3283d06b401322bff47481f095))




; _: Prims.unit   -> FStar.Calc.calc_pack [(fun x7 y8 -> x7 == y8 <: Type); fun x5 y6 -> x5 == y6 <: Type]       (n * ((a + k * n) / n - a / n))       (a + k * n - (a + k * n) % n - (a - a % n))
(declare-fun Tm_arrow_5191dce4a817d3609230f518fb68cf06 (Term Term Term) Term)
; kinding_Tm_arrow_5191dce4a817d3609230f518fb68cf06
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(233,2-243,3)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term))
   (! (HasType (Tm_arrow_5191dce4a817d3609230f518fb68cf06 @x0 @x1 @x2) Tm_type)
    :pattern ((HasType (Tm_arrow_5191dce4a817d3609230f518fb68cf06 @x0 @x1 @x2) Tm_type))
    :qid kinding_Tm_arrow_5191dce4a817d3609230f518fb68cf06))
  :named kinding_Tm_arrow_5191dce4a817d3609230f518fb68cf06))
; pre-typing for functions
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(233,2-243,3)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
   (! (implies
     (HasTypeFuel @u0 @x1 (Tm_arrow_5191dce4a817d3609230f518fb68cf06 @x2 @x3 @x4))
     (is-Tm_arrow (PreType @x1)))
    :pattern ((HasTypeFuel @u0 @x1 (Tm_arrow_5191dce4a817d3609230f518fb68cf06 @x2 @x3 @x4)))
    :qid FStar.Math.Lemmas_pre_typing_Tm_arrow_5191dce4a817d3609230f518fb68cf06))
  :named FStar.Math.Lemmas_pre_typing_Tm_arrow_5191dce4a817d3609230f518fb68cf06))
; interpretation_Tm_arrow_5191dce4a817d3609230f518fb68cf06
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(233,2-243,3)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
   (! (iff
     (HasTypeZ @x0 (Tm_arrow_5191dce4a817d3609230f518fb68cf06 @x1 @x2 @x3))
     (and
      ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(233,2-243,3)
      (forall ((@x4 Term))
       (! (implies
         (HasType @x4 Prims.unit)
         (HasType
          (ApplyTT @x0 @x4)
          (FStar.Calc.calc_pack
           Prims.int
           (Prims.Cons
            (FStar.Preorder.relation Prims.int)
            Tm_abs_2d12df642cab58f318db60ed4861d203
            (Prims.Cons
             (FStar.Preorder.relation Prims.int)
             Tm_abs_2d12df642cab58f318db60ed4861d203
             (Prims.Nil (FStar.Preorder.relation Prims.int))))
           (Prims.op_Multiply
            @x3
            (Prims.op_Subtraction
             (Prims.op_Division (Prims.op_Addition @x2 (Prims.op_Multiply @x1 @x3)) @x3)
             (Prims.op_Division @x2 @x3)))
           (Prims.op_Subtraction
            (Prims.op_Subtraction
             (Prims.op_Addition @x2 (Prims.op_Multiply @x1 @x3))
             (Prims.op_Modulus (Prims.op_Addition @x2 (Prims.op_Multiply @x1 @x3)) @x3))
            (Prims.op_Subtraction @x2 (Prims.op_Modulus @x2 @x3))))))
        :pattern ((ApplyTT @x0 @x4))
        :qid FStar.Math.Lemmas_interpretation_Tm_arrow_5191dce4a817d3609230f518fb68cf06.1))
      (IsTotFun @x0)))
    :pattern ((HasTypeZ @x0 (Tm_arrow_5191dce4a817d3609230f518fb68cf06 @x1 @x2 @x3)))
    :qid FStar.Math.Lemmas_interpretation_Tm_arrow_5191dce4a817d3609230f518fb68cf06))
  :named FStar.Math.Lemmas_interpretation_Tm_arrow_5191dce4a817d3609230f518fb68cf06))






; _: Prims.unit   -> FStar.Calc.calc_pack [         (fun x9 y10 -> x9 == y10 <: Type);         (fun x7 y8 -> x7 == y8 <: Type);         fun x5 y6 -> x5 == y6 <: Type       ]       (n * ((a + k * n) / n - a / n))       (k * n - (a + k * n) % n + a % n)
(declare-fun Tm_arrow_871f680f33cdf446c9113d272d05a31b (Term Term Term) Term)
; kinding_Tm_arrow_871f680f33cdf446c9113d272d05a31b
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(233,2-243,3)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term))
   (! (HasType (Tm_arrow_871f680f33cdf446c9113d272d05a31b @x0 @x1 @x2) Tm_type)
    :pattern ((HasType (Tm_arrow_871f680f33cdf446c9113d272d05a31b @x0 @x1 @x2) Tm_type))
    :qid kinding_Tm_arrow_871f680f33cdf446c9113d272d05a31b))
  :named kinding_Tm_arrow_871f680f33cdf446c9113d272d05a31b))
; pre-typing for functions
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(233,2-243,3)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
   (! (implies
     (HasTypeFuel @u0 @x1 (Tm_arrow_871f680f33cdf446c9113d272d05a31b @x2 @x3 @x4))
     (is-Tm_arrow (PreType @x1)))
    :pattern ((HasTypeFuel @u0 @x1 (Tm_arrow_871f680f33cdf446c9113d272d05a31b @x2 @x3 @x4)))
    :qid FStar.Math.Lemmas_pre_typing_Tm_arrow_871f680f33cdf446c9113d272d05a31b))
  :named FStar.Math.Lemmas_pre_typing_Tm_arrow_871f680f33cdf446c9113d272d05a31b))
; interpretation_Tm_arrow_871f680f33cdf446c9113d272d05a31b
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(233,2-243,3)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
   (! (iff
     (HasTypeZ @x0 (Tm_arrow_871f680f33cdf446c9113d272d05a31b @x1 @x2 @x3))
     (and
      ;; def=FStar.Calc.fsti(69,6-69,36); use=FStar.Math.Lemmas.fst(233,2-243,3)
      (forall ((@x4 Term))
       (! (implies
         (HasType @x4 Prims.unit)
         (HasType
          (ApplyTT @x0 @x4)
          (FStar.Calc.calc_pack
           Prims.int
           (Prims.Cons
            (FStar.Preorder.relation Prims.int)
            Tm_abs_2d12df642cab58f318db60ed4861d203
            (Prims.Cons
             (FStar.Preorder.relation Prims.int)
             Tm_abs_2d12df642cab58f318db60ed4861d203
             (Prims.Cons
              (FStar.Preorder.relation Prims.int)
              Tm_abs_2d12df642cab58f318db60ed4861d203
              (Prims.Nil (FStar.Preorder.relation Prims.int)))))
           (Prims.op_Multiply
            @x3
            (Prims.op_Subtraction
             (Prims.op_Division (Prims.op_Addition @x2 (Prims.op_Multiply @x1 @x3)) @x3)
             (Prims.op_Division @x2 @x3)))
           (Prims.op_Addition
            (Prims.op_Subtraction
             (Prims.op_Multiply @x1 @x3)
             (Prims.op_Modulus (Prims.op_Addition @x2 (Prims.op_Multiply @x1 @x3)) @x3))
            (Prims.op_Modulus @x2 @x3)))))
        :pattern ((ApplyTT @x0 @x4))
        :qid FStar.Math.Lemmas_interpretation_Tm_arrow_871f680f33cdf446c9113d272d05a31b.1))
      (IsTotFun @x0)))
    :pattern ((HasTypeZ @x0 (Tm_arrow_871f680f33cdf446c9113d272d05a31b @x1 @x2 @x3)))
    :qid FStar.Math.Lemmas_interpretation_Tm_arrow_871f680f33cdf446c9113d272d05a31b))
  :named FStar.Math.Lemmas_interpretation_Tm_arrow_871f680f33cdf446c9113d272d05a31b))








; _: Prims.unit   -> FStar.Calc.calc_pack [         (fun x11 y12 -> x11 == y12 <: Type);         (fun x9 y10 -> x9 == y10 <: Type);         (fun x7 y8 -> x7 == y8 <: Type);         fun x5 y6 -> x5 == y6 <: Type       ]       (n * ((a + k * n) / n - a / n))       (k * n)
(declare-fun Tm_arrow_07970ed8a0a6d06d9714db7437f3dd02 (Term Term Term) Term)
; kinding_Tm_arrow_07970ed8a0a6d06d9714db7437f3dd02
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(81,6-81,36); use=FStar.Math.Lemmas.fst(233,2-244,40)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term))
   (! (HasType (Tm_arrow_07970ed8a0a6d06d9714db7437f3dd02 @x0 @x1 @x2) Tm_type)
    :pattern ((HasType (Tm_arrow_07970ed8a0a6d06d9714db7437f3dd02 @x0 @x1 @x2) Tm_type))
    :qid kinding_Tm_arrow_07970ed8a0a6d06d9714db7437f3dd02))
  :named kinding_Tm_arrow_07970ed8a0a6d06d9714db7437f3dd02))
; pre-typing for functions
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(81,6-81,36); use=FStar.Math.Lemmas.fst(233,2-244,40)
  (forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
   (! (implies
     (HasTypeFuel @u0 @x1 (Tm_arrow_07970ed8a0a6d06d9714db7437f3dd02 @x2 @x3 @x4))
     (is-Tm_arrow (PreType @x1)))
    :pattern ((HasTypeFuel @u0 @x1 (Tm_arrow_07970ed8a0a6d06d9714db7437f3dd02 @x2 @x3 @x4)))
    :qid FStar.Math.Lemmas_pre_typing_Tm_arrow_07970ed8a0a6d06d9714db7437f3dd02))
  :named FStar.Math.Lemmas_pre_typing_Tm_arrow_07970ed8a0a6d06d9714db7437f3dd02))
; interpretation_Tm_arrow_07970ed8a0a6d06d9714db7437f3dd02
;;; Fact-ids: 
(assert
 (! ;; def=FStar.Calc.fsti(81,6-81,36); use=FStar.Math.Lemmas.fst(233,2-244,40)
  (forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
   (! (iff
     (HasTypeZ @x0 (Tm_arrow_07970ed8a0a6d06d9714db7437f3dd02 @x1 @x2 @x3))
     (and
      ;; def=FStar.Calc.fsti(81,6-81,36); use=FStar.Math.Lemmas.fst(233,2-244,40)
      (forall ((@x4 Term))
       (! (implies
         (HasType @x4 Prims.unit)
         (HasType
          (ApplyTT @x0 @x4)
          (FStar.Calc.calc_pack
           Prims.int
           (Prims.Cons
            (FStar.Preorder.relation Prims.int)
            Tm_abs_2d12df642cab58f318db60ed4861d203
            (Prims.Cons
             (FStar.Preorder.relation Prims.int)
             Tm_abs_2d12df642cab58f318db60ed4861d203
             (Prims.Cons
              (FStar.Preorder.relation Prims.int)
              Tm_abs_2d12df642cab58f318db60ed4861d203
              (Prims.Cons
               (FStar.Preorder.relation Prims.int)
               Tm_abs_2d12df642cab58f318db60ed4861d203
               (Prims.Nil (FStar.Preorder.relation Prims.int))))))
           (Prims.op_Multiply
            @x3
            (Prims.op_Subtraction
             (Prims.op_Division (Prims.op_Addition @x2 (Prims.op_Multiply @x1 @x3)) @x3)
             (Prims.op_Division @x2 @x3)))
           (Prims.op_Multiply @x1 @x3))))
        :pattern ((ApplyTT @x0 @x4))
        :qid FStar.Math.Lemmas_interpretation_Tm_arrow_07970ed8a0a6d06d9714db7437f3dd02.1))
      (IsTotFun @x0)))
    :pattern ((HasTypeZ @x0 (Tm_arrow_07970ed8a0a6d06d9714db7437f3dd02 @x1 @x2 @x3)))
    :qid FStar.Math.Lemmas_interpretation_Tm_arrow_07970ed8a0a6d06d9714db7437f3dd02))
  :named FStar.Math.Lemmas_interpretation_Tm_arrow_07970ed8a0a6d06d9714db7437f3dd02))
; Encoding query formula : forall (a: Prims.int) (k: Prims.int) (n: Prims.pos).
;   (*  - Could not prove post-condition
; *)
;   forall (p: Prims.pure_post Prims.unit).
;     (forall (pure_result: Prims.unit). (a + k * n) / n = a / n + k ==> p pure_result) ==>
;     (n > 0 ==> n <> 0) /\
;     (forall (any_result: Prims.pos).
;         n == any_result ==>
;         (forall (any_result: Prims.int).
;             (a + k * n) / n == any_result ==>
;             (n > 0 ==> n <> 0) /\
;             (forall (any_result: Prims.pos).
;                 n == any_result ==>
;                 (forall (any_result: Prims.int).
;                     a / n == any_result ==>
;                     (forall (any_result: Prims.int).
;                         (a + k * n) / n - a / n == any_result ==>
;                         (forall (any_result: Prims.int).
;                             n * ((a + k * n) / n - a / n) == any_result ==>
;                             (forall (_: Prims.unit).
;                                 (*  - Could not prove post-condition
; *)
;                                 (n > 0 ==> n <> 0) /\
;                                 (forall (any_result: Prims.pos).
;                                     n == any_result ==>
;                                     (forall (any_result: Prims.int).
;                                         (a + k * n) / n == any_result ==>
;                                         (n > 0 ==> n <> 0) /\
;                                         (forall (any_result: Prims.pos).
;                                             n == any_result ==>
;                                             (forall (any_result: Prims.int).
;                                                 a / n == any_result ==>
;                                                 (forall (any_result: Prims.int).
;                                                     (a + k * n) / n - a / n == any_result ==>
;                                                     (forall (any_result: Prims.int).
;                                                         n * ((a + k * n) / n - a / n) == any_result ==>
;                                                         (n > 0 ==> n <> 0) /\
;                                                         (forall (any_result: Prims.pos).
;                                                             n == any_result ==>
;                                                             (forall (any_result: Prims.int).
;                                                                 (a + k * n) % n == any_result ==>
;                                                                 (forall (any_result: Prims.int).
;                                                                     k * n - (a + k * n) % n ==
;                                                                     any_result ==>
;                                                                     (n > 0 ==> n <> 0) /\
;                                                                     (forall (any_result: Prims.pos).
;                                                                         n == any_result ==>
;                                                                         (forall (any_result:
;                                                                             Prims.int).
;                                                                             a % n == any_result ==>
;                                                                             (forall (any_result:
;                                                                                 Prims.int).
;                                                                                 k * n -
;                                                                                 (a + k * n) % n +
;                                                                                 a % n ==
;                                                                                 any_result ==>
;                                                                                 (forall (_:
;                                                                                     Prims.unit).
;                                                                                     (*  - Could not prove post-condition
; *)
;                                                                                     (n > 0 ==>
;                                                                                       n <> 0) /\
;                                                                                     (forall (any_result:
;                                                                                         Prims.pos).
;                                                                                         n ==
;                                                                                         any_result ==>
;                                                                                         (forall (any_result:
;                                                                                             Prims.int)
;                                                                                           .
;                                                                                             (a +
;                                                                                               k * n) /
;                                                                                             n ==
;                                                                                             any_result ==>
;                                                                                             (n > 0 ==>
;                                                                                               n <> 0
;                                                                                             ) /\
;                                                                                             (forall (any_result:
;                                                                                                 Prims.pos)
;                                                                                               .
;                                                                                                 n ==
;                                                                                                 any_result ==>
;                                                                                                 (forall
;                                                                                                     (any_result:
;                                                                                                     Prims.int)
;                                                                                                   .
;                                                                                                     a /
;                                                                                                     n ==
;                                                                                                     any_result ==>
;                                                                                                     (
;                                                                                                       forall
;                                                                                                         (any_result:
;                                                                                                         Prims.int)
;                                                                                                       .
;                                                                                                         (
;                                                                                                           a +
;                                                                                                           k *
;                                                                                                           n
;                                                                                                         ) /
;                                                                                                         n -
;                                                                                                         a /
;                                                                                                         n ==
;                                                                                                         any_result ==>
;                                                                                                         (
;                                                                                                           forall
;                                                                                                             (any_result:
;                                                                                                             Prims.int)
;                                                                                                           .
;                                                                                                             n *
;                                                                                                             (
;                                                                                                               (
;                                                                                                                 a +
;                                                                                                                 k *
;                                                                                                                 n
;                                                                                                               ) /
;                                                                                                               n -
;                                                                                                               a /
;                                                                                                               n
;                                                                                                             ) ==
;                                                                                                             any_result ==>
;                                                                                                             (
;                                                                                                               n >
;                                                                                                               0 ==>
;                                                                                                               n <>
;                                                                                                               0
;                                                                                                             ) /\
;                                                                                                             (
;                                                                                                               forall
;                                                                                                                 (any_result:
;                                                                                                                 Prims.pos)
;                                                                                                               .
;                                                                                                                 n ==
;                                                                                                                 any_result ==>
;                                                                                                                 (
;                                                                                                                   forall
;                                                                                                                     (any_result:
;                                                                                                                     Prims.int)
;                                                                                                                   .
;                                                                                                                     (
;                                                                                                                       a +
;                                                                                                                       k *
;                                                                                                                       n
;                                                                                                                     ) %
;                                                                                                                     n ==
;                                                                                                                     any_result ==>
;                                                                                                                     (
;                                                                                                                       forall
;                                                                                                                         (any_result:
;                                                                                                                         Prims.int)
;                                                                                                                       .
;                                                                                                                         a +
;                                                                                                                         k *
;                                                                                                                         n -
;                                                                                                                         (
;                                                                                                                           a +
;                                                                                                                           k *
;                                                                                                                           n
;                                                                                                                         ) %
;                                                                                                                         n ==
;                                                                                                                         any_result ==>
;                                                                                                                         (
;                                                                                                                           n >
;                                                                                                                           0 ==>
;                                                                                                                           n <>
;                                                                                                                           0
;                                                                                                                         ) /\
;                                                                                                                         (
;                                                                                                                           forall
;                                                                                                                             (any_result:
;                                                                                                                             Prims.pos)
;                                                                                                                           .
;                                                                                                                             n ==
;                                                                                                                             any_result ==>
;                                                                                                                             (
;                                                                                                                               forall
;                                                                                                                                 (any_result:
;                                                                                                                                 Prims.int)
;                                                                                                                               .
;                                                                                                                                 a %
;                                                                                                                                 n ==
;                                                                                                                                 any_result ==>
;                                                                                                                                 (
;                                                                                                                                   forall
;                                                                                                                                     (any_result:
;                                                                                                                                     Prims.int)
;                                                                                                                                   .
;                                                                                                                                     a -
;                                                                                                                                     a %
;                                                                                                                                     n ==
;                                                                                                                                     any_result ==>
;                                                                                                                                     (
;                                                                                                                                       forall
;                                                                                                                                         (any_result:
;                                                                                                                                         Prims.int)
;                                                                                                                                       .
;                                                                                                                                         a +
;                                                                                                                                         k *
;                                                                                                                                         n -
;                                                                                                                                         (
;                                                                                                                                           a +
;                                                                                                                                           k *
;                                                                                                                                           n
;                                                                                                                                         ) %
;                                                                                                                                         n -
;                                                                                                                                         (a -
;                                                                                                                                         a %
;                                                                                                                                         n) ==
;                                                                                                                                         any_result ==>
;                                                                                                                                         (
;                                                                                                                                           n >
;                                                                                                                                           0 ==>
;                                                                                                                                           n <>
;                                                                                                                                           0
;                                                                                                                                         ) /\
;                                                                                                                                         (
;                                                                                                                                           forall
;                                                                                                                                             (any_result:
;                                                                                                                                             Prims.pos)
;                                                                                                                                           .
;                                                                                                                                             n ==
;                                                                                                                                             any_result ==>
;                                                                                                                                             (
;                                                                                                                                               forall
;                                                                                                                                                 (any_result:
;                                                                                                                                                 Prims.int)
;                                                                                                                                               .
;                                                                                                                                                 (
;                                                                                                                                                   a +
;                                                                                                                                                   k *
;                                                                                                                                                   n
;                                                                                                                                                 ) %
;                                                                                                                                                 n ==
;                                                                                                                                                 any_result ==>
;                                                                                                                                                 (
;                                                                                                                                                   forall
;                                                                                                                                                     (any_result:
;                                                                                                                                                     Prims.int)
;                                                                                                                                                   .
;                                                                                                                                                     k *
;                                                                                                                                                     n -
;                                                                                                                                                     (
;                                                                                                                                                       a +
;                                                                                                                                                       k *
;                                                                                                                                                       n
;                                                                                                                                                     ) %
;                                                                                                                                                     n ==
;                                                                                                                                                     any_result ==>
;                                                                                                                                                     (
;                                                                                                                                                       n >
;                                                                                                                                                       0 ==>
;                                                                                                                                                       n <>
;                                                                                                                                                       0
;                                                                                                                                                     ) /\
;                                                                                                                                                     (
;                                                                                                                                                       forall
;                                                                                                                                                         (any_result:
;                                                                                                                                                         Prims.pos)
;                                                                                                                                                       .
;                                                                                                                                                         n ==
;                                                                                                                                                         any_result ==>
;                                                                                                                                                         (
;                                                                                                                                                           forall
;                                                                                                                                                             (any_result:
;                                                                                                                                                             Prims.int)
;                                                                                                                                                           .
;                                                                                                                                                             a %
;                                                                                                                                                             n ==
;                                                                                                                                                             any_result ==>
;                                                                                                                                                             (
;                                                                                                                                                               forall
;                                                                                                                                                                 (any_result:
;                                                                                                                                                                 Prims.int)
;                                                                                                                                                               .
;                                                                                                                                                                 k *
;                                                                                                                                                                 n -
;                                                                                                                                                                 (
;                                                                                                                                                                   a +
;                                                                                                                                                                   k *
;                                                                                                                                                                   n
;                                                                                                                                                                 ) %
;                                                                                                                                                                 n +
;                                                                                                                                                                 a %
;                                                                                                                                                                 n ==
;                                                                                                                                                                 any_result ==>
;                                                                                                                                                                 (
;                                                                                                                                                                   forall
;                                                                                                                                                                     (_:
;                                                                                                                                                                     Prims.unit)
;                                                                                                                                                                   .
;                                                                                                                                                                     (*  - Could not prove post-condition
; *)
;                                                                                                                                                                     (
;                                                                                                                                                                       n >
;                                                                                                                                                                       0 ==>
;                                                                                                                                                                       n <>
;                                                                                                                                                                       0
;                                                                                                                                                                     ) /\
;                                                                                                                                                                     (
;                                                                                                                                                                       forall
;                                                                                                                                                                         (any_result:
;                                                                                                                                                                         Prims.pos)
;                                                                                                                                                                       .
;                                                                                                                                                                         n ==
;                                                                                                                                                                         any_result ==>
;                                                                                                                                                                         (
;                                                                                                                                                                           forall
;                                                                                                                                                                             (any_result:
;                                                                                                                                                                             Prims.int)
;                                                                                                                                                                           .
;                                                                                                                                                                             (
;                                                                                                                                                                               a +
;                                                                                                                                                                               k *
;                                                                                                                                                                               n
;                                                                                                                                                                             ) /
;                                                                                                                                                                             n ==
;                                                                                                                                                                             any_result ==>
;                                                                                                                                                                             (
;                                                                                                                                                                               n >
;                                                                                                                                                                               0 ==>
;                                                                                                                                                                               n <>
;                                                                                                                                                                               0
;                                                                                                                                                                             ) /\
;                                                                                                                                                                             (
;                                                                                                                                                                               forall
;                                                                                                                                                                                 (any_result:
;                                                                                                                                                                                 Prims.pos)
;                                                                                                                                                                               .
;                                                                                                                                                                                 n ==
;                                                                                                                                                                                 any_result ==>
;                                                                                                                                                                                 (
;                                                                                                                                                                                   forall
;                                                                                                                                                                                     (any_result:
;                                                                                                                                                                                     Prims.int)
;                                                                                                                                                                                   .
;                                                                                                                                                                                     a /
;                                                                                                                                                                                     n ==
;                                                                                                                                                                                     any_result ==>
;                                                                                                                                                                                     (
;                                                                                                                                                                                       forall
;                                                                                                                                                                                         (any_result:
;                                                                                                                                                                                         Prims.int)
;                                                                                                                                                                                       .
;                                                                                                                                                                                         (
;                                                                                                                                                                                           a +
;                                                                                                                                                                                           k *
;                                                                                                                                                                                           n
;                                                                                                                                                                                         ) /
;                                                                                                                                                                                         n -
;                                                                                                                                                                                         a /
;                                                                                                                                                                                         n ==
;                                                                                                                                                                                         any_result ==>
;                                                                                                                                                                                         (
;                                                                                                                                                                                           forall
;                                                                                                                                                                                             (any_result:
;                                                                                                                                                                                             Prims.int)
;                                                                                                                                                                                           .
;                                                                                                                                                                                             n *
;                                                                                                                                                                                             (
;                                                                                                                                                                                               (
;                                                                                                                                                                                                 a +
;                                                                                                                                                                                                 k *
;                                                                                                                                                                                                 n
;                                                                                                                                                                                               ) /
;                                                                                                                                                                                               n -
;                                                                                                                                                                                               a /
;                                                                                                                                                                                               n
;                                                                                                                                                                                             ) ==
;                                                                                                                                                                                             any_result ==>
;                                                                                                                                                                                             (
;                                                                                                                                                                                               n >
;                                                                                                                                                                                               0 ==>
;                                                                                                                                                                                               n <>
;                                                                                                                                                                                               0
;                                                                                                                                                                                             ) /\
;                                                                                                                                                                                             (
;                                                                                                                                                                                               forall
;                                                                                                                                                                                                 (any_result:
;                                                                                                                                                                                                 Prims.pos)
;                                                                                                                                                                                               .
;                                                                                                                                                                                                 n ==
;                                                                                                                                                                                                 any_result ==>
;                                                                                                                                                                                                 (
;                                                                                                                                                                                                   forall
;                                                                                                                                                                                                     (any_result:
;                                                                                                                                                                                                     Prims.int)
;                                                                                                                                                                                                   .
;                                                                                                                                                                                                     (
;                                                                                                                                                                                                       a +
;                                                                                                                                                                                                       k *
;                                                                                                                                                                                                       n
;                                                                                                                                                                                                     ) /
;                                                                                                                                                                                                     n ==
;                                                                                                                                                                                                     any_result ==>
;                                                                                                                                                                                                     (
;                                                                                                                                                                                                       forall
;                                                                                                                                                                                                         (any_result:
;                                                                                                                                                                                                         Prims.int)
;                                                                                                                                                                                                       .
;                                                                                                                                                                                                         n *
;                                                                                                                                                                                                         ((
;                                                                                                                                                                                                           a +
;                                                                                                                                                                                                           k *
;                                                                                                                                                                                                           n
;                                                                                                                                                                                                         ) /
;                                                                                                                                                                                                         n) ==
;                                                                                                                                                                                                         any_result ==>
;                                                                                                                                                                                                         (
;                                                                                                                                                                                                           n >
;                                                                                                                                                                                                           0 ==>
;                                                                                                                                                                                                           n <>
;                                                                                                                                                                                                           0
;                                                                                                                                                                                                         ) /\
;                                                                                                                                                                                                         (
;                                                                                                                                                                                                           forall
;                                                                                                                                                                                                             (any_result:
;                                                                                                                                                                                                             Prims.pos)
;                                                                                                                                                                                                           .
;                                                                                                                                                                                                             n ==
;                                                                                                                                                                                                             any_result ==>
;                                                                                                                                                                                                             (
;                                                                                                                                                                                                               forall
;                                                                                                                                                                                                                 (any_result:
;                                                                                                                                                                                                                 Prims.int)
;                                                                                                                                                                                                               .
;                                                                                                                                                                                                                 a /
;                                                                                                                                                                                                                 n ==
;                                                                                                                                                                                                                 any_result ==>
;                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                   forall
;                                                                                                                                                                                                                     (any_result:
;                                                                                                                                                                                                                     Prims.int)
;                                                                                                                                                                                                                   .
;                                                                                                                                                                                                                     n *
;                                                                                                                                                                                                                     (a /
;                                                                                                                                                                                                                     n) ==
;                                                                                                                                                                                                                     any_result ==>
;                                                                                                                                                                                                                     (
;                                                                                                                                                                                                                       forall
;                                                                                                                                                                                                                         (any_result:
;                                                                                                                                                                                                                         Prims.int)
;                                                                                                                                                                                                                       .
;                                                                                                                                                                                                                         n *
;                                                                                                                                                                                                                         ((
;                                                                                                                                                                                                                           a +
;                                                                                                                                                                                                                           k *
;                                                                                                                                                                                                                           n
;                                                                                                                                                                                                                         ) /
;                                                                                                                                                                                                                         n) -
;                                                                                                                                                                                                                         n *
;                                                                                                                                                                                                                         (a /
;                                                                                                                                                                                                                         n) ==
;                                                                                                                                                                                                                         any_result ==>
;                                                                                                                                                                                                                         (
;                                                                                                                                                                                                                           n >
;                                                                                                                                                                                                                           0 ==>
;                                                                                                                                                                                                                           n <>
;                                                                                                                                                                                                                           0
;                                                                                                                                                                                                                         ) /\
;                                                                                                                                                                                                                         (
;                                                                                                                                                                                                                           forall
;                                                                                                                                                                                                                             (any_result:
;                                                                                                                                                                                                                             Prims.pos)
;                                                                                                                                                                                                                           .
;                                                                                                                                                                                                                             n ==
;                                                                                                                                                                                                                             any_result ==>
;                                                                                                                                                                                                                             (
;                                                                                                                                                                                                                               forall
;                                                                                                                                                                                                                                 (any_result:
;                                                                                                                                                                                                                                 Prims.int)
;                                                                                                                                                                                                                               .
;                                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                                   a +
;                                                                                                                                                                                                                                   k *
;                                                                                                                                                                                                                                   n
;                                                                                                                                                                                                                                 ) %
;                                                                                                                                                                                                                                 n ==
;                                                                                                                                                                                                                                 any_result ==>
;                                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                                   forall
;                                                                                                                                                                                                                                     (any_result:
;                                                                                                                                                                                                                                     Prims.int)
;                                                                                                                                                                                                                                   .
;                                                                                                                                                                                                                                     a +
;                                                                                                                                                                                                                                     k *
;                                                                                                                                                                                                                                     n -
;                                                                                                                                                                                                                                     (
;                                                                                                                                                                                                                                       a +
;                                                                                                                                                                                                                                       k *
;                                                                                                                                                                                                                                       n
;                                                                                                                                                                                                                                     ) %
;                                                                                                                                                                                                                                     n ==
;                                                                                                                                                                                                                                     any_result ==>
;                                                                                                                                                                                                                                     (
;                                                                                                                                                                                                                                       n >
;                                                                                                                                                                                                                                       0 ==>
;                                                                                                                                                                                                                                       n <>
;                                                                                                                                                                                                                                       0
;                                                                                                                                                                                                                                     ) /\
;                                                                                                                                                                                                                                     (
;                                                                                                                                                                                                                                       forall
;                                                                                                                                                                                                                                         (any_result:
;                                                                                                                                                                                                                                         Prims.pos)
;                                                                                                                                                                                                                                       .
;                                                                                                                                                                                                                                         n ==
;                                                                                                                                                                                                                                         any_result ==>
;                                                                                                                                                                                                                                         (
;                                                                                                                                                                                                                                           forall
;                                                                                                                                                                                                                                             (any_result:
;                                                                                                                                                                                                                                             Prims.int)
;                                                                                                                                                                                                                                           .
;                                                                                                                                                                                                                                             a %
;                                                                                                                                                                                                                                             n ==
;                                                                                                                                                                                                                                             any_result ==>
;                                                                                                                                                                                                                                             (
;                                                                                                                                                                                                                                               forall
;                                                                                                                                                                                                                                                 (any_result:
;                                                                                                                                                                                                                                                 Prims.int)
;                                                                                                                                                                                                                                               .
;                                                                                                                                                                                                                                                 a -
;                                                                                                                                                                                                                                                 a %
;                                                                                                                                                                                                                                                 n ==
;                                                                                                                                                                                                                                                 any_result ==>
;                                                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                                                   forall
;                                                                                                                                                                                                                                                     (any_result:
;                                                                                                                                                                                                                                                     Prims.int)
;                                                                                                                                                                                                                                                   .
;                                                                                                                                                                                                                                                     a +
;                                                                                                                                                                                                                                                     k *
;                                                                                                                                                                                                                                                     n -
;                                                                                                                                                                                                                                                     (
;                                                                                                                                                                                                                                                       a +
;                                                                                                                                                                                                                                                       k *
;                                                                                                                                                                                                                                                       n
;                                                                                                                                                                                                                                                     ) %
;                                                                                                                                                                                                                                                     n -
;                                                                                                                                                                                                                                                     (a -
;                                                                                                                                                                                                                                                     a %
;                                                                                                                                                                                                                                                     n) ==
;                                                                                                                                                                                                                                                     any_result ==>
;                                                                                                                                                                                                                                                     (
;                                                                                                                                                                                                                                                       forall
;                                                                                                                                                                                                                                                         (_:
;                                                                                                                                                                                                                                                         Prims.unit)
;                                                                                                                                                                                                                                                       .
;                                                                                                                                                                                                                                                         (*  - Could not prove post-condition
; *)
;                                                                                                                                                                                                                                                         (
;                                                                                                                                                                                                                                                           n >
;                                                                                                                                                                                                                                                           0 ==>
;                                                                                                                                                                                                                                                           n <>
;                                                                                                                                                                                                                                                           0
;                                                                                                                                                                                                                                                         ) /\
;                                                                                                                                                                                                                                                         (
;                                                                                                                                                                                                                                                           forall
;                                                                                                                                                                                                                                                             (any_result:
;                                                                                                                                                                                                                                                             Prims.pos)
;                                                                                                                                                                                                                                                           .
;                                                                                                                                                                                                                                                             n ==
;                                                                                                                                                                                                                                                             any_result ==>
;                                                                                                                                                                                                                                                             (
;                                                                                                                                                                                                                                                               forall
;                                                                                                                                                                                                                                                                 (any_result:
;                                                                                                                                                                                                                                                                 Prims.int)
;                                                                                                                                                                                                                                                               .
;                                                                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                                                                   a +
;                                                                                                                                                                                                                                                                   k *
;                                                                                                                                                                                                                                                                   n
;                                                                                                                                                                                                                                                                 ) /
;                                                                                                                                                                                                                                                                 n ==
;                                                                                                                                                                                                                                                                 any_result ==>
;                                                                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                                                                   n >
;                                                                                                                                                                                                                                                                   0 ==>
;                                                                                                                                                                                                                                                                   n <>
;                                                                                                                                                                                                                                                                   0
;                                                                                                                                                                                                                                                                 ) /\
;                                                                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                                                                   forall
;                                                                                                                                                                                                                                                                     (any_result:
;                                                                                                                                                                                                                                                                     Prims.pos)
;                                                                                                                                                                                                                                                                   .
;                                                                                                                                                                                                                                                                     n ==
;                                                                                                                                                                                                                                                                     any_result ==>
;                                                                                                                                                                                                                                                                     (
;                                                                                                                                                                                                                                                                       forall
;                                                                                                                                                                                                                                                                         (any_result:
;                                                                                                                                                                                                                                                                         Prims.int)
;                                                                                                                                                                                                                                                                       .
;                                                                                                                                                                                                                                                                         a /
;                                                                                                                                                                                                                                                                         n ==
;                                                                                                                                                                                                                                                                         any_result ==>
;                                                                                                                                                                                                                                                                         (
;                                                                                                                                                                                                                                                                           forall
;                                                                                                                                                                                                                                                                             (any_result:
;                                                                                                                                                                                                                                                                             Prims.int)
;                                                                                                                                                                                                                                                                           .
;                                                                                                                                                                                                                                                                             (
;                                                                                                                                                                                                                                                                               a +
;                                                                                                                                                                                                                                                                               k *
;                                                                                                                                                                                                                                                                               n
;                                                                                                                                                                                                                                                                             ) /
;                                                                                                                                                                                                                                                                             n -
;                                                                                                                                                                                                                                                                             a /
;                                                                                                                                                                                                                                                                             n ==
;                                                                                                                                                                                                                                                                             any_result ==>
;                                                                                                                                                                                                                                                                             (
;                                                                                                                                                                                                                                                                               forall
;                                                                                                                                                                                                                                                                                 (any_result:
;                                                                                                                                                                                                                                                                                 Prims.int)
;                                                                                                                                                                                                                                                                               .
;                                                                                                                                                                                                                                                                                 n *
;                                                                                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                                                                                   (
;                                                                                                                                                                                                                                                                                     a +
;                                                                                                                                                                                                                                                                                     k *
;                                                                                                                                                                                                                                                                                     n
;                                                                                                                                                                                                                                                                                   ) /
;                                                                                                                                                                                                                                                                                   n -
;                                                                                                                                                                                                                                                                                   a /
;                                                                                                                                                                                                                                                                                   n
;                                                                                                                                                                                                                                                                                 ) ==
;                                                                                                                                                                                                                                                                                 any_result ==>
;                                                                                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                                                                                   n >
;                                                                                                                                                                                                                                                                                   0 ==>
;                                                                                                                                                                                                                                                                                   n <>
;                                                                                                                                                                                                                                                                                   0
;                                                                                                                                                                                                                                                                                 ) /\
;                                                                                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                                                                                   forall
;                                                                                                                                                                                                                                                                                     (any_result:
;                                                                                                                                                                                                                                                                                     Prims.pos)
;                                                                                                                                                                                                                                                                                   .
;                                                                                                                                                                                                                                                                                     n ==
;                                                                                                                                                                                                                                                                                     any_result ==>
;                                                                                                                                                                                                                                                                                     (
;                                                                                                                                                                                                                                                                                       forall
;                                                                                                                                                                                                                                                                                         (any_result:
;                                                                                                                                                                                                                                                                                         Prims.int)
;                                                                                                                                                                                                                                                                                       .
;                                                                                                                                                                                                                                                                                         (
;                                                                                                                                                                                                                                                                                           a +
;                                                                                                                                                                                                                                                                                           k *
;                                                                                                                                                                                                                                                                                           n
;                                                                                                                                                                                                                                                                                         ) /
;                                                                                                                                                                                                                                                                                         n ==
;                                                                                                                                                                                                                                                                                         any_result ==>
;                                                                                                                                                                                                                                                                                         (
;                                                                                                                                                                                                                                                                                           n >
;                                                                                                                                                                                                                                                                                           0 ==>
;                                                                                                                                                                                                                                                                                           n <>
;                                                                                                                                                                                                                                                                                           0
;                                                                                                                                                                                                                                                                                         ) /\
;                                                                                                                                                                                                                                                                                         (
;                                                                                                                                                                                                                                                                                           forall
;                                                                                                                                                                                                                                                                                             (any_result:
;                                                                                                                                                                                                                                                                                             Prims.pos)
;                                                                                                                                                                                                                                                                                           .
;                                                                                                                                                                                                                                                                                             n ==
;                                                                                                                                                                                                                                                                                             any_result ==>
;                                                                                                                                                                                                                                                                                             (
;                                                                                                                                                                                                                                                                                               forall
;                                                                                                                                                                                                                                                                                                 (any_result:
;                                                                                                                                                                                                                                                                                                 Prims.int)
;                                                                                                                                                                                                                                                                                               .
;                                                                                                                                                                                                                                                                                                 a /
;                                                                                                                                                                                                                                                                                                 n ==
;                                                                                                                                                                                                                                                                                                 any_result ==>
;                                                                                                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                                                                                                   forall
;                                                                                                                                                                                                                                                                                                     (any_result:
;                                                                                                                                                                                                                                                                                                     Prims.int)
;                                                                                                                                                                                                                                                                                                   .
;                                                                                                                                                                                                                                                                                                     (
;                                                                                                                                                                                                                                                                                                       a +
;                                                                                                                                                                                                                                                                                                       k *
;                                                                                                                                                                                                                                                                                                       n
;                                                                                                                                                                                                                                                                                                     ) /
;                                                                                                                                                                                                                                                                                                     n -
;                                                                                                                                                                                                                                                                                                     a /
;                                                                                                                                                                                                                                                                                                     n ==
;                                                                                                                                                                                                                                                                                                     any_result ==>
;                                                                                                                                                                                                                                                                                                     (
;                                                                                                                                                                                                                                                                                                       forall
;                                                                                                                                                                                                                                                                                                         (any_result:
;                                                                                                                                                                                                                                                                                                         Prims.int)
;                                                                                                                                                                                                                                                                                                       .
;                                                                                                                                                                                                                                                                                                         n *
;                                                                                                                                                                                                                                                                                                         (
;                                                                                                                                                                                                                                                                                                           (
;                                                                                                                                                                                                                                                                                                             a +
;                                                                                                                                                                                                                                                                                                             k *
;                                                                                                                                                                                                                                                                                                             n
;                                                                                                                                                                                                                                                                                                           ) /
;                                                                                                                                                                                                                                                                                                           n -
;                                                                                                                                                                                                                                                                                                           a /
;                                                                                                                                                                                                                                                                                                           n
;                                                                                                                                                                                                                                                                                                         ) ==
;                                                                                                                                                                                                                                                                                                         any_result ==>
;                                                                                                                                                                                                                                                                                                         (
;                                                                                                                                                                                                                                                                                                           n >
;                                                                                                                                                                                                                                                                                                           0 ==>
;                                                                                                                                                                                                                                                                                                           n <>
;                                                                                                                                                                                                                                                                                                           0
;                                                                                                                                                                                                                                                                                                         ) /\
;                                                                                                                                                                                                                                                                                                         (
;                                                                                                                                                                                                                                                                                                           forall
;                                                                                                                                                                                                                                                                                                             (any_result:
;                                                                                                                                                                                                                                                                                                             Prims.pos)
;                                                                                                                                                                                                                                                                                                           .
;                                                                                                                                                                                                                                                                                                             n ==
;                                                                                                                                                                                                                                                                                                             any_result ==>
;                                                                                                                                                                                                                                                                                                             (
;                                                                                                                                                                                                                                                                                                               forall
;                                                                                                                                                                                                                                                                                                                 (any_result:
;                                                                                                                                                                                                                                                                                                                 Prims.int)
;                                                                                                                                                                                                                                                                                                               .
;                                                                                                                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                                                                                                                   a +
;                                                                                                                                                                                                                                                                                                                   k *
;                                                                                                                                                                                                                                                                                                                   n
;                                                                                                                                                                                                                                                                                                                 ) /
;                                                                                                                                                                                                                                                                                                                 n ==
;                                                                                                                                                                                                                                                                                                                 any_result ==>
;                                                                                                                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                                                                                                                   forall
;                                                                                                                                                                                                                                                                                                                     (any_result:
;                                                                                                                                                                                                                                                                                                                     Prims.int)
;                                                                                                                                                                                                                                                                                                                   .
;                                                                                                                                                                                                                                                                                                                     n *
;                                                                                                                                                                                                                                                                                                                     ((
;                                                                                                                                                                                                                                                                                                                       a +
;                                                                                                                                                                                                                                                                                                                       k *
;                                                                                                                                                                                                                                                                                                                       n
;                                                                                                                                                                                                                                                                                                                     ) /
;                                                                                                                                                                                                                                                                                                                     n) ==
;                                                                                                                                                                                                                                                                                                                     any_result ==>
;                                                                                                                                                                                                                                                                                                                     (
;                                                                                                                                                                                                                                                                                                                       n >
;                                                                                                                                                                                                                                                                                                                       0 ==>
;                                                                                                                                                                                                                                                                                                                       n <>
;                                                                                                                                                                                                                                                                                                                       0
;                                                                                                                                                                                                                                                                                                                     ) /\
;                                                                                                                                                                                                                                                                                                                     (
;                                                                                                                                                                                                                                                                                                                       forall
;                                                                                                                                                                                                                                                                                                                         (any_result:
;                                                                                                                                                                                                                                                                                                                         Prims.pos)
;                                                                                                                                                                                                                                                                                                                       .
;                                                                                                                                                                                                                                                                                                                         n ==
;                                                                                                                                                                                                                                                                                                                         any_result ==>
;                                                                                                                                                                                                                                                                                                                         (
;                                                                                                                                                                                                                                                                                                                           forall
;                                                                                                                                                                                                                                                                                                                             (any_result:
;                                                                                                                                                                                                                                                                                                                             Prims.int)
;                                                                                                                                                                                                                                                                                                                           .
;                                                                                                                                                                                                                                                                                                                             a /
;                                                                                                                                                                                                                                                                                                                             n ==
;                                                                                                                                                                                                                                                                                                                             any_result ==>
;                                                                                                                                                                                                                                                                                                                             (
;                                                                                                                                                                                                                                                                                                                               forall
;                                                                                                                                                                                                                                                                                                                                 (any_result:
;                                                                                                                                                                                                                                                                                                                                 Prims.int)
;                                                                                                                                                                                                                                                                                                                               .
;                                                                                                                                                                                                                                                                                                                                 n *
;                                                                                                                                                                                                                                                                                                                                 (a /
;                                                                                                                                                                                                                                                                                                                                 n) ==
;                                                                                                                                                                                                                                                                                                                                 any_result ==>
;                                                                                                                                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                                                                                                                                   forall
;                                                                                                                                                                                                                                                                                                                                     (any_result:
;                                                                                                                                                                                                                                                                                                                                     Prims.int)
;                                                                                                                                                                                                                                                                                                                                   .
;                                                                                                                                                                                                                                                                                                                                     n *
;                                                                                                                                                                                                                                                                                                                                     ((
;                                                                                                                                                                                                                                                                                                                                       a +
;                                                                                                                                                                                                                                                                                                                                       k *
;                                                                                                                                                                                                                                                                                                                                       n
;                                                                                                                                                                                                                                                                                                                                     ) /
;                                                                                                                                                                                                                                                                                                                                     n) -
;                                                                                                                                                                                                                                                                                                                                     n *
;                                                                                                                                                                                                                                                                                                                                     (a /
;                                                                                                                                                                                                                                                                                                                                     n) ==
;                                                                                                                                                                                                                                                                                                                                     any_result ==>
;                                                                                                                                                                                                                                                                                                                                     (
;                                                                                                                                                                                                                                                                                                                                       forall
;                                                                                                                                                                                                                                                                                                                                         (_:
;                                                                                                                                                                                                                                                                                                                                         Prims.unit)
;                                                                                                                                                                                                                                                                                                                                       .
;                                                                                                                                                                                                                                                                                                                                         (*  - Could not prove post-condition
; *)
;                                                                                                                                                                                                                                                                                                                                         (
;                                                                                                                                                                                                                                                                                                                                           n >
;                                                                                                                                                                                                                                                                                                                                           0 ==>
;                                                                                                                                                                                                                                                                                                                                           n <>
;                                                                                                                                                                                                                                                                                                                                           0
;                                                                                                                                                                                                                                                                                                                                         ) /\
;                                                                                                                                                                                                                                                                                                                                         (
;                                                                                                                                                                                                                                                                                                                                           forall
;                                                                                                                                                                                                                                                                                                                                             (any_result:
;                                                                                                                                                                                                                                                                                                                                             Prims.pos)
;                                                                                                                                                                                                                                                                                                                                           .
;                                                                                                                                                                                                                                                                                                                                             n ==
;                                                                                                                                                                                                                                                                                                                                             any_result ==>
;                                                                                                                                                                                                                                                                                                                                             (
;                                                                                                                                                                                                                                                                                                                                               forall
;                                                                                                                                                                                                                                                                                                                                                 (any_result:
;                                                                                                                                                                                                                                                                                                                                                 Prims.int)
;                                                                                                                                                                                                                                                                                                                                               .
;                                                                                                                                                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                                                                                                                                                   a +
;                                                                                                                                                                                                                                                                                                                                                   k *
;                                                                                                                                                                                                                                                                                                                                                   n
;                                                                                                                                                                                                                                                                                                                                                 ) /
;                                                                                                                                                                                                                                                                                                                                                 n ==
;                                                                                                                                                                                                                                                                                                                                                 any_result ==>
;                                                                                                                                                                                                                                                                                                                                                 n >
;                                                                                                                                                                                                                                                                                                                                                 0 ==>
;                                                                                                                                                                                                                                                                                                                                                 n <>
;                                                                                                                                                                                                                                                                                                                                                 0
;                                                                                                                                                                                                                                                                                                                                             )
;                                                                                                                                                                                                                                                                                                                                         )
;                                                                                                                                                                                                                                                                                                                                     ) /\
;                                                                                                                                                                                                                                                                                                                                     (
;                                                                                                                                                                                                                                                                                                                                       forall
;                                                                                                                                                                                                                                                                                                                                         (any_result:
;                                                                                                                                                                                                                                                                                                                                         (
; 
;                                                                                                                                                                                                                                                                                                                                               _:
;                                                                                                                                                                                                                                                                                                                                                 Prims.unit
;                                                                                                                                                                                                                                                                                                                                             -> FStar.Calc.calc_pack
;                                                                                                                                                                                                                                                                                                                                                 [
; 
;                                                                                                                                                                                                                                                                                                                                                 ]
;                                                                                                                                                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                                                                                                                                                   n *
;                                                                                                                                                                                                                                                                                                                                                   (
;                                                                                                                                                                                                                                                                                                                                                     (
;                                                                                                                                                                                                                                                                                                                                                       a +
;                                                                                                                                                                                                                                                                                                                                                       k *
;                                                                                                                                                                                                                                                                                                                                                       n
;                                                                                                                                                                                                                                                                                                                                                     ) /
;                                                                                                                                                                                                                                                                                                                                                     n -
;                                                                                                                                                                                                                                                                                                                                                     a /
;                                                                                                                                                                                                                                                                                                                                                     n
;                                                                                                                                                                                                                                                                                                                                                   )
;                                                                                                                                                                                                                                                                                                                                                 )
;                                                                                                                                                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                                                                                                                                                   n *
;                                                                                                                                                                                                                                                                                                                                                   (
;                                                                                                                                                                                                                                                                                                                                                     (
;                                                                                                                                                                                                                                                                                                                                                       a +
;                                                                                                                                                                                                                                                                                                                                                       k *
;                                                                                                                                                                                                                                                                                                                                                       n
;                                                                                                                                                                                                                                                                                                                                                     ) /
;                                                                                                                                                                                                                                                                                                                                                     n -
;                                                                                                                                                                                                                                                                                                                                                     a /
;                                                                                                                                                                                                                                                                                                                                                     n
;                                                                                                                                                                                                                                                                                                                                                   )
;                                                                                                                                                                                                                                                                                                                                                 )
; 
;                                                                                                                                                                                                                                                                                                                                         ))
;                                                                                                                                                                                                                                                                                                                                         (_:
;                                                                                                                                                                                                                                                                                                                                         Prims.unit)
;                                                                                                                                                                                                                                                                                                                                       .
;                                                                                                                                                                                                                                                                                                                                         (*  - Could not prove post-condition
; *)
;                                                                                                                                                                                                                                                                                                                                         (
;                                                                                                                                                                                                                                                                                                                                           n >
;                                                                                                                                                                                                                                                                                                                                           0 ==>
;                                                                                                                                                                                                                                                                                                                                           n <>
;                                                                                                                                                                                                                                                                                                                                           0
;                                                                                                                                                                                                                                                                                                                                         ) /\
;                                                                                                                                                                                                                                                                                                                                         (
;                                                                                                                                                                                                                                                                                                                                           forall
;                                                                                                                                                                                                                                                                                                                                             (any_result:
;                                                                                                                                                                                                                                                                                                                                             Prims.pos)
;                                                                                                                                                                                                                                                                                                                                           .
;                                                                                                                                                                                                                                                                                                                                             n ==
;                                                                                                                                                                                                                                                                                                                                             any_result ==>
;                                                                                                                                                                                                                                                                                                                                             (
;                                                                                                                                                                                                                                                                                                                                               forall
;                                                                                                                                                                                                                                                                                                                                                 (any_result:
;                                                                                                                                                                                                                                                                                                                                                 Prims.int)
;                                                                                                                                                                                                                                                                                                                                               .
;                                                                                                                                                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                                                                                                                                                   a +
;                                                                                                                                                                                                                                                                                                                                                   k *
;                                                                                                                                                                                                                                                                                                                                                   n
;                                                                                                                                                                                                                                                                                                                                                 ) /
;                                                                                                                                                                                                                                                                                                                                                 n ==
;                                                                                                                                                                                                                                                                                                                                                 any_result ==>
;                                                                                                                                                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                                                                                                                                                   n >
;                                                                                                                                                                                                                                                                                                                                                   0 ==>
;                                                                                                                                                                                                                                                                                                                                                   n <>
;                                                                                                                                                                                                                                                                                                                                                   0
;                                                                                                                                                                                                                                                                                                                                                 ) /\
;                                                                                                                                                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                                                                                                                                                   forall
;                                                                                                                                                                                                                                                                                                                                                     (any_result:
;                                                                                                                                                                                                                                                                                                                                                     Prims.pos)
;                                                                                                                                                                                                                                                                                                                                                   .
;                                                                                                                                                                                                                                                                                                                                                     n ==
;                                                                                                                                                                                                                                                                                                                                                     any_result ==>
;                                                                                                                                                                                                                                                                                                                                                     (
;                                                                                                                                                                                                                                                                                                                                                       forall
;                                                                                                                                                                                                                                                                                                                                                         (any_result:
;                                                                                                                                                                                                                                                                                                                                                         Prims.int)
;                                                                                                                                                                                                                                                                                                                                                       .
;                                                                                                                                                                                                                                                                                                                                                         a /
;                                                                                                                                                                                                                                                                                                                                                         n ==
;                                                                                                                                                                                                                                                                                                                                                         any_result ==>
;                                                                                                                                                                                                                                                                                                                                                         (
;                                                                                                                                                                                                                                                                                                                                                           forall
;                                                                                                                                                                                                                                                                                                                                                             (pure_result:
;                                                                                                                                                                                                                                                                                                                                                             Prims.unit)
;                                                                                                                                                                                                                                                                                                                                                           .
;                                                                                                                                                                                                                                                                                                                                                             n *
;                                                                                                                                                                                                                                                                                                                                                             (
;                                                                                                                                                                                                                                                                                                                                                               (
;                                                                                                                                                                                                                                                                                                                                                                 a +
;                                                                                                                                                                                                                                                                                                                                                                 k *
;                                                                                                                                                                                                                                                                                                                                                                 n
;                                                                                                                                                                                                                                                                                                                                                               ) /
;                                                                                                                                                                                                                                                                                                                                                               n -
;                                                                                                                                                                                                                                                                                                                                                               a /
;                                                                                                                                                                                                                                                                                                                                                               n
;                                                                                                                                                                                                                                                                                                                                                             ) =
;                                                                                                                                                                                                                                                                                                                                                             n *
;                                                                                                                                                                                                                                                                                                                                                             ((
;                                                                                                                                                                                                                                                                                                                                                               a +
;                                                                                                                                                                                                                                                                                                                                                               k *
;                                                                                                                                                                                                                                                                                                                                                               n
;                                                                                                                                                                                                                                                                                                                                                             ) /
;                                                                                                                                                                                                                                                                                                                                                             n) -
;                                                                                                                                                                                                                                                                                                                                                             n *
;                                                                                                                                                                                                                                                                                                                                                             (a /
;                                                                                                                                                                                                                                                                                                                                                             n) ==>
;                                                                                                                                                                                                                                                                                                                                                             n *
;                                                                                                                                                                                                                                                                                                                                                             (
;                                                                                                                                                                                                                                                                                                                                                               (
;                                                                                                                                                                                                                                                                                                                                                                 a +
;                                                                                                                                                                                                                                                                                                                                                                 k *
;                                                                                                                                                                                                                                                                                                                                                                 n
;                                                                                                                                                                                                                                                                                                                                                               ) /
;                                                                                                                                                                                                                                                                                                                                                               n -
;                                                                                                                                                                                                                                                                                                                                                               a /
;                                                                                                                                                                                                                                                                                                                                                               n
;                                                                                                                                                                                                                                                                                                                                                             ) ==
;                                                                                                                                                                                                                                                                                                                                                             n *
;                                                                                                                                                                                                                                                                                                                                                             ((
;                                                                                                                                                                                                                                                                                                                                                               a +
;                                                                                                                                                                                                                                                                                                                                                               k *
;                                                                                                                                                                                                                                                                                                                                                               n
;                                                                                                                                                                                                                                                                                                                                                             ) /
;                                                                                                                                                                                                                                                                                                                                                             n) -
;                                                                                                                                                                                                                                                                                                                                                             n *
;                                                                                                                                                                                                                                                                                                                                                             (a /
;                                                                                                                                                                                                                                                                                                                                                             n)
;                                                                                                                                                                                                                                                                                                                                                         )
;                                                                                                                                                                                                                                                                                                                                                     )
;                                                                                                                                                                                                                                                                                                                                                 )
;                                                                                                                                                                                                                                                                                                                                             )
;                                                                                                                                                                                                                                                                                                                                         )
;                                                                                                                                                                                                                                                                                                                                     )
;                                                                                                                                                                                                                                                                                                                                 )
;                                                                                                                                                                                                                                                                                                                             )
;                                                                                                                                                                                                                                                                                                                         )
;                                                                                                                                                                                                                                                                                                                     )
;                                                                                                                                                                                                                                                                                                                 )
;                                                                                                                                                                                                                                                                                                             )
;                                                                                                                                                                                                                                                                                                         )
;                                                                                                                                                                                                                                                                                                     )
;                                                                                                                                                                                                                                                                                                 )
;                                                                                                                                                                                                                                                                                             )
;                                                                                                                                                                                                                                                                                         )
;                                                                                                                                                                                                                                                                                     )
;                                                                                                                                                                                                                                                                                 )
;                                                                                                                                                                                                                                                                             )
;                                                                                                                                                                                                                                                                         )
;                                                                                                                                                                                                                                                                     )
;                                                                                                                                                                                                                                                                 )
;                                                                                                                                                                                                                                                             )
;                                                                                                                                                                                                                                                         )
;                                                                                                                                                                                                                                                     ) /\
;                                                                                                                                                                                                                                                     (
;                                                                                                                                                                                                                                                       forall
;                                                                                                                                                                                                                                                         (any_result:
;                                                                                                                                                                                                                                                         (
; 
;                                                                                                                                                                                                                                                               _:
;                                                                                                                                                                                                                                                                 Prims.unit
;                                                                                                                                                                                                                                                             -> FStar.Calc.calc_pack
;                                                                                                                                                                                                                                                                 [
;                                                                                                                                                                                                                                                                   fun
;                                                                                                                                                                                                                                                                     x5
;                                                                                                                                                                                                                                                                     y6
;                                                                                                                                                                                                                                                                     ->
;                                                                                                                                                                                                                                                                     x5 ==
;                                                                                                                                                                                                                                                                     y6
;                                                                                                                                                                                                                                                                     <:
;                                                                                                                                                                                                                                                                     Type0
;                                                                                                                                                                                                                                                                 ]
;                                                                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                                                                   n *
;                                                                                                                                                                                                                                                                   (
;                                                                                                                                                                                                                                                                     (
;                                                                                                                                                                                                                                                                       a +
;                                                                                                                                                                                                                                                                       k *
;                                                                                                                                                                                                                                                                       n
;                                                                                                                                                                                                                                                                     ) /
;                                                                                                                                                                                                                                                                     n -
;                                                                                                                                                                                                                                                                     a /
;                                                                                                                                                                                                                                                                     n
;                                                                                                                                                                                                                                                                   )
;                                                                                                                                                                                                                                                                 )
;                                                                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                                                                   n *
;                                                                                                                                                                                                                                                                   ((
;                                                                                                                                                                                                                                                                     a +
;                                                                                                                                                                                                                                                                     k *
;                                                                                                                                                                                                                                                                     n
;                                                                                                                                                                                                                                                                   ) /
;                                                                                                                                                                                                                                                                   n) -
;                                                                                                                                                                                                                                                                   n *
;                                                                                                                                                                                                                                                                   (a /
;                                                                                                                                                                                                                                                                   n)
;                                                                                                                                                                                                                                                                 )
; 
;                                                                                                                                                                                                                                                         ))
;                                                                                                                                                                                                                                                         (_:
;                                                                                                                                                                                                                                                         Prims.unit)
;                                                                                                                                                                                                                                                       .
;                                                                                                                                                                                                                                                         (*  - Could not prove post-condition
; *)
;                                                                                                                                                                                                                                                         (
;                                                                                                                                                                                                                                                           n >
;                                                                                                                                                                                                                                                           0 ==>
;                                                                                                                                                                                                                                                           n <>
;                                                                                                                                                                                                                                                           0
;                                                                                                                                                                                                                                                         ) /\
;                                                                                                                                                                                                                                                         (
;                                                                                                                                                                                                                                                           forall
;                                                                                                                                                                                                                                                             (any_result:
;                                                                                                                                                                                                                                                             Prims.pos)
;                                                                                                                                                                                                                                                           .
;                                                                                                                                                                                                                                                             n ==
;                                                                                                                                                                                                                                                             any_result ==>
;                                                                                                                                                                                                                                                             (
;                                                                                                                                                                                                                                                               forall
;                                                                                                                                                                                                                                                                 (pure_result:
;                                                                                                                                                                                                                                                                 Prims.unit)
;                                                                                                                                                                                                                                                               .
;                                                                                                                                                                                                                                                                 a +
;                                                                                                                                                                                                                                                                 k *
;                                                                                                                                                                                                                                                                 n =
;                                                                                                                                                                                                                                                                 n *
;                                                                                                                                                                                                                                                                 ((
;                                                                                                                                                                                                                                                                   a +
;                                                                                                                                                                                                                                                                   k *
;                                                                                                                                                                                                                                                                   n
;                                                                                                                                                                                                                                                                 ) /
;                                                                                                                                                                                                                                                                 n) +
;                                                                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                                                                   a +
;                                                                                                                                                                                                                                                                   k *
;                                                                                                                                                                                                                                                                   n
;                                                                                                                                                                                                                                                                 ) %
;                                                                                                                                                                                                                                                                 n ==>
;                                                                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                                                                   n >
;                                                                                                                                                                                                                                                                   0 ==>
;                                                                                                                                                                                                                                                                   n <>
;                                                                                                                                                                                                                                                                   0
;                                                                                                                                                                                                                                                                 ) /\
;                                                                                                                                                                                                                                                                 (
;                                                                                                                                                                                                                                                                   forall
;                                                                                                                                                                                                                                                                     (any_result:
;                                                                                                                                                                                                                                                                     Prims.pos)
;                                                                                                                                                                                                                                                                   .
;                                                                                                                                                                                                                                                                     n ==
;                                                                                                                                                                                                                                                                     any_result ==>
;                                                                                                                                                                                                                                                                     (
;                                                                                                                                                                                                                                                                       forall
;                                                                                                                                                                                                                                                                         (pure_result:
;                                                                                                                                                                                                                                                                         Prims.unit)
;                                                                                                                                                                                                                                                                       .
;                                                                                                                                                                                                                                                                         a =
;                                                                                                                                                                                                                                                                         n *
;                                                                                                                                                                                                                                                                         (a /
;                                                                                                                                                                                                                                                                         n) +
;                                                                                                                                                                                                                                                                         a %
;                                                                                                                                                                                                                                                                         n ==>
;                                                                                                                                                                                                                                                                         n *
;                                                                                                                                                                                                                                                                         ((
;                                                                                                                                                                                                                                                                           a +
;                                                                                                                                                                                                                                                                           k *
;                                                                                                                                                                                                                                                                           n
;                                                                                                                                                                                                                                                                         ) /
;                                                                                                                                                                                                                                                                         n) -
;                                                                                                                                                                                                                                                                         n *
;                                                                                                                                                                                                                                                                         (a /
;                                                                                                                                                                                                                                                                         n) ==
;                                                                                                                                                                                                                                                                         a +
;                                                                                                                                                                                                                                                                         k *
;                                                                                                                                                                                                                                                                         n -
;                                                                                                                                                                                                                                                                         (
;                                                                                                                                                                                                                                                                           a +
;                                                                                                                                                                                                                                                                           k *
;                                                                                                                                                                                                                                                                           n
;                                                                                                                                                                                                                                                                         ) %
;                                                                                                                                                                                                                                                                         n -
;                                                                                                                                                                                                                                                                         (a -
;                                                                                                                                                                                                                                                                         a %
;                                                                                                                                                                                                                                                                         n)
;                                                                                                                                                                                                                                                                     )
;                                                                                                                                                                                                                                                                 )
;                                                                                                                                                                                                                                                             )
;                                                                                                                                                                                                                                                         )
;                                                                                                                                                                                                                                                     )
;                                                                                                                                                                                                                                                 )
;                                                                                                                                                                                                                                             )
;                                                                                                                                                                                                                                         )
;                                                                                                                                                                                                                                     )
;                                                                                                                                                                                                                                 )
;                                                                                                                                                                                                                             )
;                                                                                                                                                                                                                         )
;                                                                                                                                                                                                                     )
;                                                                                                                                                                                                                 )
;                                                                                                                                                                                                             )
;                                                                                                                                                                                                         )
;                                                                                                                                                                                                     )
;                                                                                                                                                                                                 )
;                                                                                                                                                                                             )
;                                                                                                                                                                                         )
;                                                                                                                                                                                     )
;                                                                                                                                                                                 )
;                                                                                                                                                                             )
;                                                                                                                                                                         )
;                                                                                                                                                                     )
;                                                                                                                                                                 ) /\
;                                                                                                                                                                 (
;                                                                                                                                                                   forall
;                                                                                                                                                                     (any_result:
;                                                                                                                                                                     (
; 
;                                                                                                                                                                           _:
;                                                                                                                                                                             Prims.unit
;                                                                                                                                                                         -> FStar.Calc.calc_pack
;                                                                                                                                                                             [
;                                                                                                                                                                               (
;                                                                                                                                                                                 fun
;                                                                                                                                                                                   x7
;                                                                                                                                                                                   y8
;                                                                                                                                                                                   ->
;                                                                                                                                                                                   x7 ==
;                                                                                                                                                                                   y8
;                                                                                                                                                                                   <:
;                                                                                                                                                                                   Type0
;                                                                                                                                                                               );
;                                                                                                                                                                               fun
;                                                                                                                                                                                 x5
;                                                                                                                                                                                 y6
;                                                                                                                                                                                 ->
;                                                                                                                                                                                 x5 ==
;                                                                                                                                                                                 y6
;                                                                                                                                                                                 <:
;                                                                                                                                                                                 Type0
;                                                                                                                                                                             ]
;                                                                                                                                                                             (
;                                                                                                                                                                               n *
;                                                                                                                                                                               (
;                                                                                                                                                                                 (
;                                                                                                                                                                                   a +
;                                                                                                                                                                                   k *
;                                                                                                                                                                                   n
;                                                                                                                                                                                 ) /
;                                                                                                                                                                                 n -
;                                                                                                                                                                                 a /
;                                                                                                                                                                                 n
;                                                                                                                                                                               )
;                                                                                                                                                                             )
;                                                                                                                                                                             (
;                                                                                                                                                                               a +
;                                                                                                                                                                               k *
;                                                                                                                                                                               n -
;                                                                                                                                                                               (
;                                                                                                                                                                                 a +
;                                                                                                                                                                                 k *
;                                                                                                                                                                                 n
;                                                                                                                                                                               ) %
;                                                                                                                                                                               n -
;                                                                                                                                                                               (a -
;                                                                                                                                                                               a %
;                                                                                                                                                                               n)
;                                                                                                                                                                             )
; 
;                                                                                                                                                                     ))
;                                                                                                                                                                     (_:
;                                                                                                                                                                     Prims.unit)
;                                                                                                                                                                   .
;                                                                                                                                                                     (*  - Could not prove post-condition
; *)
;                                                                                                                                                                     a +
;                                                                                                                                                                     k *
;                                                                                                                                                                     n -
;                                                                                                                                                                     (
;                                                                                                                                                                       a +
;                                                                                                                                                                       k *
;                                                                                                                                                                       n
;                                                                                                                                                                     ) %
;                                                                                                                                                                     n -
;                                                                                                                                                                     (a -
;                                                                                                                                                                     a %
;                                                                                                                                                                     n) ==
;                                                                                                                                                                     k *
;                                                                                                                                                                     n -
;                                                                                                                                                                     (
;                                                                                                                                                                       a +
;                                                                                                                                                                       k *
;                                                                                                                                                                       n
;                                                                                                                                                                     ) %
;                                                                                                                                                                     n +
;                                                                                                                                                                     a %
;                                                                                                                                                                     n
;                                                                                                                                                                 )
;                                                                                                                                                             )
;                                                                                                                                                         )
;                                                                                                                                                     )
;                                                                                                                                                 )
;                                                                                                                                             )
;                                                                                                                                         )
;                                                                                                                                     )
;                                                                                                                                 )
;                                                                                                                             )
;                                                                                                                         )
;                                                                                                                     )
;                                                                                                                 )
;                                                                                                             )
;                                                                                                         )
;                                                                                                     )
;                                                                                                 ))))
;                                                                                 ) /\
;                                                                                 (forall (any_result:
;                                                                                     (_: Prims.unit
;                                                                                         -> FStar.Calc.calc_pack
;                                                                                             [
;                                                                                               (fun
;                                                                                                   x9
;                                                                                                   y10
;                                                                                                   ->
;                                                                                                   x9 ==
;                                                                                                   y10
;                                                                                                   <:
;                                                                                                   Type0
;                                                                                               );
;                                                                                               (fun
;                                                                                                   x7
;                                                                                                   y8
;                                                                                                   ->
;                                                                                                   x7 ==
;                                                                                                   y8
;                                                                                                   <:
;                                                                                                   Type0
;                                                                                               );
;                                                                                               fun
;                                                                                                 x5
;                                                                                                 y6
;                                                                                                 ->
;                                                                                                 x5 ==
;                                                                                                 y6
;                                                                                                 <:
;                                                                                                 Type0
;                                                                                             ]
;                                                                                             (n *
;                                                                                               ((a +
;                                                                                                   k *
;                                                                                                   n) /
;                                                                                                 n -
;                                                                                                 a /
;                                                                                                 n))
;                                                                                             (k * n -
;                                                                                               (a +
;                                                                                                 k *
;                                                                                                 n) %
;                                                                                               n +
;                                                                                               a % n)
;                                                                                     ))
;                                                                                     (_: Prims.unit).
;                                                                                     (*  - Could not prove post-condition
; *)
;                                                                                     forall (pure_result:
;                                                                                       Prims.unit).
;                                                                                       (a + k * n) %
;                                                                                       n =
;                                                                                       a % n ==>
;                                                                                       k * n -
;                                                                                       (a + k * n) %
;                                                                                       n +
;                                                                                       a % n ==
;                                                                                       k * n)))))))))
;                                             ))))) /\
;                             (forall (any_result:
;                                 (_: Prims.unit
;                                     -> FStar.Calc.calc_pack [
;                                           (fun x11 y12 -> x11 == y12 <: Type0);
;                                           (fun x9 y10 -> x9 == y10 <: Type0);
;                                           (fun x7 y8 -> x7 == y8 <: Type0);
;                                           fun x5 y6 -> x5 == y6 <: Type0
;                                         ]
;                                         (n * ((a + k * n) / n - a / n))
;                                         (k * n))).
;                                 FStar.Range.labeled (FStar.Sealed.seal FStar.Calc.fsti(86,37-86,50))
;                                   "Could not prove that this calc-chain is compatible"
;                                   (forall (x: Prims.int) (y: Prims.int).
;                                       (exists (w: Prims.int).
;                                           (exists (w: Prims.int).
;                                               (exists (w: Prims.int).
;                                                   (exists (w: Prims.int). x == w /\ w == w) /\
;                                                   w == w) /\ w == w) /\ w == y) ==>
;                                       x == y) /\
;                                 (forall (pure_result: Prims.unit).
;                                     n * ((a + k * n) / n - a / n) == k * n ==>
;                                     (n > 0 ==> n <> 0) /\
;                                     (forall (any_result: Prims.pos).
;                                         n == any_result ==>
;                                         (forall (any_result: Prims.int).
;                                             (a + k * n) / n == any_result ==>
;                                             (n > 0 ==> n <> 0) /\
;                                             (forall (any_result: Prims.pos).
;                                                 n == any_result ==>
;                                                 (forall (any_result: Prims.int).
;                                                     a / n == any_result ==>
;                                                     (forall (any_result: Prims.int).
;                                                         (a + k * n) / n - a / n == any_result ==>
;                                                         ((a + k * n) / n - a / n) * n = k * n /\
;                                                         (forall (pure_result: Prims.unit).
;                                                             (a + k * n) / n - a / n = k ==>
;                                                             p pure_result))))))))))))))
; Context: While encoding a query
; While typechecking the top-level declaration `let lemma_div_plus`
(push) ;; push{0
; <fuel='0' ifuel='0'>
;;; Fact-ids: 
(assert (! (= MaxFuel ZFuel) :named @MaxFuel_assumption))
;;; Fact-ids: 
(assert (! (= MaxIFuel ZFuel) :named @MaxIFuel_assumption))
; query
;;; Fact-ids: 
(assert
 (! (not
   (forall ((@x0 Term) (@x1 Term) (@x2 Term))
    (! (implies
      (and (HasType @x0 Prims.int) (HasType @x1 Prims.int) (HasType @x2 Prims.pos))
      ;; def=Prims.fst(414,51-414,91); use=Prims.fst(438,19-438,32)
      (forall ((@x3 Term))
       (! (implies
         (and
          (HasType @x3 (Prims.pure_post Prims.unit))
          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(233,2-244,40)
          (forall ((@x4 Term))
           (! (implies
             (and
              (or label_1 (HasType @x4 Prims.unit))
              ;; def=FStar.Math.Lemmas.fsti(196,51-196,80); use=FStar.Math.Lemmas.fst(233,2-244,40)
              (or
               label_2
               ;; def=FStar.Math.Lemmas.fsti(196,51-196,80); use=FStar.Math.Lemmas.fst(233,2-244,40)
               (=
                (Prims.op_Division (Prims.op_Addition @x0 (Prims.op_Multiply @x1 @x2)) @x2)
                (Prims.op_Addition (Prims.op_Division @x0 @x2) @x1))))
             ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(233,2-244,40)
             (Valid
              ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(233,2-244,40)
              (ApplyTT @x3 @x4)))
            :pattern
             (;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(233,2-244,40)
              (Valid
               ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(233,2-244,40)
               (ApplyTT @x3 @x4)))
            :qid @query.2)))
         ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(233,2-244,40)
         (and
          (implies
           ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(234,17-234,18)
           (> (BoxInt_proj_0 @x2) (BoxInt_proj_0 (BoxInt 0)))
           ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(234,17-234,18)
           (or
            label_3
            ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(234,17-234,18)
            (not (= @x2 (BoxInt 0)))))
          ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-244,40)
          (forall ((@x4 Term))
           (! (implies
             (and
              (HasType @x4 Prims.pos)
              ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-244,40)
              (= @x2 @x4))
             ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-244,40)
             (forall ((@x5 Term))
              (! (implies
                (and
                 (HasType @x5 Prims.int)
                 ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-244,40)
                 (= (Prims.op_Division (Prims.op_Addition @x0 (Prims.op_Multiply @x1 @x2)) @x2) @x5))
                ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(233,2-244,40)
                (and
                 (implies
                  ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(234,23-234,24)
                  (> (BoxInt_proj_0 @x2) (BoxInt_proj_0 (BoxInt 0)))
                  ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(234,23-234,24)
                  (or
                   label_4
                   ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(234,23-234,24)
                   (not (= @x2 (BoxInt 0)))))
                 ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-244,40)
                 (forall ((@x6 Term))
                  (! (implies
                    (and
                     (HasType @x6 Prims.pos)
                     ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-244,40)
                     (= @x2 @x6))
                    ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-244,40)
                    (forall ((@x7 Term))
                     (! (implies
                       (and
                        (HasType @x7 Prims.int)
                        ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-244,40)
                        (= (Prims.op_Division @x0 @x2) @x7))
                       ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-244,40)
                       (forall ((@x8 Term))
                        (! (implies
                          (and
                           (HasType @x8 Prims.int)
                           ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-244,40)
                           (=
                            (Prims.op_Subtraction
                             (Prims.op_Division
                              (Prims.op_Addition @x0 (Prims.op_Multiply @x1 @x2))
                              @x2)
                             (Prims.op_Division @x0 @x2))
                            @x8))
                          ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-244,40)
                          (forall ((@x9 Term))
                           (! (implies
                             (and
                              (HasType @x9 Prims.int)
                              ;; def=FStar.Calc.fsti(79,4-79,5); use=FStar.Math.Lemmas.fst(233,2-244,40)
                              (=
                               (Prims.op_Multiply
                                @x2
                                (Prims.op_Subtraction
                                 (Prims.op_Division
                                  (Prims.op_Addition @x0 (Prims.op_Multiply @x1 @x2))
                                  @x2)
                                 (Prims.op_Division @x0 @x2)))
                               @x9))
                             ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(233,2-244,40)
                             (and
                              ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-244,40)
                              (forall ((@x10 Term))
                               (! (implies
                                 (HasType @x10 Prims.unit)
                                 ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                 (and
                                  (implies
                                   ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(234,17-234,18)
                                   (> (BoxInt_proj_0 @x2) (BoxInt_proj_0 (BoxInt 0)))
                                   ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(234,17-234,18)
                                   (or
                                    label_5
                                    ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(234,17-234,18)
                                    (not (= @x2 (BoxInt 0)))))
                                  ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                  (forall ((@x11 Term))
                                   (! (implies
                                     (and
                                      (HasType @x11 Prims.pos)
                                      ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                      (= @x2 @x11))
                                     ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                     (forall ((@x12 Term))
                                      (! (implies
                                        (and
                                         (HasType @x12 Prims.int)
                                         ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                         (=
                                          (Prims.op_Division
                                           (Prims.op_Addition @x0 (Prims.op_Multiply @x1 @x2))
                                           @x2)
                                          @x12))
                                        ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                        (and
                                         (implies
                                          ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(234,23-234,24)
                                          (> (BoxInt_proj_0 @x2) (BoxInt_proj_0 (BoxInt 0)))
                                          ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(234,23-234,24)
                                          (or
                                           label_6
                                           ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(234,23-234,24)
                                           (not (= @x2 (BoxInt 0)))))
                                         ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                         (forall ((@x13 Term))
                                          (! (implies
                                            (and
                                             (HasType @x13 Prims.pos)
                                             ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                             (= @x2 @x13))
                                            ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                            (forall ((@x14 Term))
                                             (! (implies
                                               (and
                                                (HasType @x14 Prims.int)
                                                ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                (= (Prims.op_Division @x0 @x2) @x14))
                                               ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                               (forall ((@x15 Term))
                                                (! (implies
                                                  (and
                                                   (HasType @x15 Prims.int)
                                                   ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                   (=
                                                    (Prims.op_Subtraction
                                                     (Prims.op_Division
                                                      (Prims.op_Addition
                                                       @x0
                                                       (Prims.op_Multiply @x1 @x2))
                                                      @x2)
                                                     (Prims.op_Division @x0 @x2))
                                                    @x15))
                                                  ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                  (forall ((@x16 Term))
                                                   (! (implies
                                                     (and
                                                      (HasType @x16 Prims.int)
                                                      ;; def=FStar.Calc.fsti(65,4-65,5); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                      (=
                                                       (Prims.op_Multiply
                                                        @x2
                                                        (Prims.op_Subtraction
                                                         (Prims.op_Division
                                                          (Prims.op_Addition
                                                           @x0
                                                           (Prims.op_Multiply @x1 @x2))
                                                          @x2)
                                                         (Prims.op_Division @x0 @x2)))
                                                       @x16))
                                                     ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                     (and
                                                      (implies
                                                       ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(240,18-240,19)
                                                       (>
                                                        (BoxInt_proj_0 @x2)
                                                        (BoxInt_proj_0 (BoxInt 0)))
                                                       ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(240,18-240,19)
                                                       (or
                                                        label_7
                                                        ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(240,18-240,19)
                                                        (not (= @x2 (BoxInt 0)))))
                                                      ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                      (forall ((@x17 Term))
                                                       (! (implies
                                                         (and
                                                          (HasType @x17 Prims.pos)
                                                          ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                          (= @x2 @x17))
                                                         ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                         (forall ((@x18 Term))
                                                          (! (implies
                                                            (and
                                                             (HasType @x18 Prims.int)
                                                             ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                             (=
                                                              (Prims.op_Modulus
                                                               (Prims.op_Addition
                                                                @x0
                                                                (Prims.op_Multiply @x1 @x2))
                                                               @x2)
                                                              @x18))
                                                            ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                            (forall ((@x19 Term))
                                                             (! (implies
                                                               (and
                                                                (HasType @x19 Prims.int)
                                                                ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                (=
                                                                 (Prims.op_Subtraction
                                                                  (Prims.op_Multiply @x1 @x2)
                                                                  (Prims.op_Modulus
                                                                   (Prims.op_Addition
                                                                    @x0
                                                                    (Prims.op_Multiply @x1 @x2))
                                                                   @x2))
                                                                 @x19))
                                                               ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                               (and
                                                                (implies
                                                                 ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(240,24-240,25)
                                                                 (>
                                                                  (BoxInt_proj_0 @x2)
                                                                  (BoxInt_proj_0 (BoxInt 0)))
                                                                 ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(240,24-240,25)
                                                                 (or
                                                                  label_8
                                                                  ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(240,24-240,25)
                                                                  (not (= @x2 (BoxInt 0)))))
                                                                ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                (forall ((@x20 Term))
                                                                 (! (implies
                                                                   (and
                                                                    (HasType @x20 Prims.pos)
                                                                    ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                    (= @x2 @x20))
                                                                   ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                   (forall ((@x21 Term))
                                                                    (! (implies
                                                                      (and
                                                                       (HasType @x21 Prims.int)
                                                                       ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                       (=
                                                                        (Prims.op_Modulus @x0 @x2)
                                                                        @x21))
                                                                      ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                      (forall ((@x22 Term))
                                                                       (! (implies
                                                                         (and
                                                                          (HasType @x22 Prims.int)
                                                                          ;; def=FStar.Calc.fsti(65,7-65,8); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                          (=
                                                                           (Prims.op_Addition
                                                                            (Prims.op_Subtraction
                                                                             (Prims.op_Multiply
                                                                              @x1
                                                                              @x2)
                                                                             (Prims.op_Modulus
                                                                              (Prims.op_Addition
                                                                               @x0
                                                                               (Prims.op_Multiply
                                                                                @x1
                                                                                @x2))
                                                                              @x2))
                                                                            (Prims.op_Modulus
                                                                             @x0
                                                                             @x2))
                                                                           @x22))
                                                                         ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                         (and
                                                                          ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                          (forall ((@x23 Term))
                                                                           (! (implies
                                                                             (HasType
                                                                              @x23
                                                                              Prims.unit)
                                                                             ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                             (and
                                                                              (implies
                                                                               ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(234,17-234,18)
                                                                               (>
                                                                                (BoxInt_proj_0 @x2)
                                                                                (BoxInt_proj_0
                                                                                 (BoxInt 0)))
                                                                               ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(234,17-234,18)
                                                                               (or
                                                                                label_9
                                                                                ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(234,17-234,18)
                                                                                (not
                                                                                 (= @x2 (BoxInt 0)))))
                                                                              ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                              (forall ((@x24 Term))
                                                                               (! (implies
                                                                                 (and
                                                                                  (HasType
                                                                                   @x24
                                                                                   Prims.pos)
                                                                                  ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                  (= @x2 @x24))
                                                                                 ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                 (forall
                                                                                   ((@x25 Term))
                                                                                  (! (implies
                                                                                    (and
                                                                                     (HasType
                                                                                      @x25
                                                                                      Prims.int)
                                                                                     ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                     (=
                                                                                      (Prims.op_Division
                                                                                       (Prims.op_Addition
                                                                                        @x0
                                                                                        (Prims.op_Multiply
                                                                                         @x1
                                                                                         @x2))
                                                                                       @x2)
                                                                                      @x25))
                                                                                    ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                    (and
                                                                                     (implies
                                                                                      ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(234,23-234,24)
                                                                                      (>
                                                                                       (BoxInt_proj_0
                                                                                        @x2)
                                                                                       (BoxInt_proj_0
                                                                                        (BoxInt 0)))
                                                                                      ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(234,23-234,24)
                                                                                      (or
                                                                                       label_10
                                                                                       ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(234,23-234,24)
                                                                                       (not
                                                                                        (=
                                                                                         @x2
                                                                                         (BoxInt 0)))))
                                                                                     ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                     (forall
                                                                                       ((@x26 Term))
                                                                                      (! (implies
                                                                                        (and
                                                                                         (HasType
                                                                                          @x26
                                                                                          Prims.pos)
                                                                                         ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                         (= @x2 @x26))
                                                                                        ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                        (forall
                                                                                          ((@x27
                                                                                            Term))
                                                                                         (! (implies
                                                                                           (and
                                                                                            (HasType
                                                                                             @x27
                                                                                             Prims.int)
                                                                                            ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                            (=
                                                                                             (Prims.op_Division
                                                                                              @x0
                                                                                              @x2)
                                                                                             @x27))
                                                                                           ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                           (forall
                                                                                             ((@x28
                                                                                               Term))
                                                                                            (! (implies
                                                                                              (and
                                                                                               (HasType
                                                                                                @x28
                                                                                                Prims.int)
                                                                                               ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                               (=
                                                                                                (Prims.op_Subtraction
                                                                                                 (Prims.op_Division
                                                                                                  (Prims.op_Addition
                                                                                                   @x0
                                                                                                   (Prims.op_Multiply
                                                                                                    @x1
                                                                                                    @x2))
                                                                                                  @x2)
                                                                                                 (Prims.op_Division
                                                                                                  @x0
                                                                                                  @x2))
                                                                                                @x28))
                                                                                              ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                              (forall
                                                                                                ((@x29
                                                                                                  Term))
                                                                                               (! (implies
                                                                                                 (and
                                                                                                  (HasType
                                                                                                   @x29
                                                                                                   Prims.int)
                                                                                                  ;; def=FStar.Calc.fsti(65,4-65,5); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                  (=
                                                                                                   (Prims.op_Multiply
                                                                                                    @x2
                                                                                                    (Prims.op_Subtraction
                                                                                                     (Prims.op_Division
                                                                                                      (Prims.op_Addition
                                                                                                       @x0
                                                                                                       (Prims.op_Multiply
                                                                                                        @x1
                                                                                                        @x2))
                                                                                                      @x2)
                                                                                                     (Prims.op_Division
                                                                                                      @x0
                                                                                                      @x2)))
                                                                                                   @x29))
                                                                                                 ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                 (and
                                                                                                  (implies
                                                                                                   ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(238,23-238,24)
                                                                                                   (>
                                                                                                    (BoxInt_proj_0
                                                                                                     @x2)
                                                                                                    (BoxInt_proj_0
                                                                                                     (BoxInt
                                                                                                      0)))
                                                                                                   ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(238,23-238,24)
                                                                                                   (or
                                                                                                    label_11
                                                                                                    ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(238,23-238,24)
                                                                                                    (not
                                                                                                     (=
                                                                                                      @x2
                                                                                                      (BoxInt
                                                                                                       0)))))
                                                                                                  ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                  (forall
                                                                                                    ((@x30
                                                                                                      Term))
                                                                                                   (! (implies
                                                                                                     (and
                                                                                                      (HasType
                                                                                                       @x30
                                                                                                       Prims.pos)
                                                                                                      ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                      (=
                                                                                                       @x2
                                                                                                       @x30))
                                                                                                     ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                     (forall
                                                                                                       ((@x31
                                                                                                         Term))
                                                                                                      (! (implies
                                                                                                        (and
                                                                                                         (HasType
                                                                                                          @x31
                                                                                                          Prims.int)
                                                                                                         ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                         (=
                                                                                                          (Prims.op_Modulus
                                                                                                           (Prims.op_Addition
                                                                                                            @x0
                                                                                                            (Prims.op_Multiply
                                                                                                             @x1
                                                                                                             @x2))
                                                                                                           @x2)
                                                                                                          @x31))
                                                                                                        ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                        (forall
                                                                                                          ((@x32
                                                                                                            Term))
                                                                                                         (! (implies
                                                                                                           (and
                                                                                                            (HasType
                                                                                                             @x32
                                                                                                             Prims.int)
                                                                                                            ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                            (=
                                                                                                             (Prims.op_Subtraction
                                                                                                              (Prims.op_Addition
                                                                                                               @x0
                                                                                                               (Prims.op_Multiply
                                                                                                                @x1
                                                                                                                @x2))
                                                                                                              (Prims.op_Modulus
                                                                                                               (Prims.op_Addition
                                                                                                                @x0
                                                                                                                (Prims.op_Multiply
                                                                                                                 @x1
                                                                                                                 @x2))
                                                                                                               @x2))
                                                                                                             @x32))
                                                                                                           ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                           (and
                                                                                                            (implies
                                                                                                             ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(238,35-238,36)
                                                                                                             (>
                                                                                                              (BoxInt_proj_0
                                                                                                               @x2)
                                                                                                              (BoxInt_proj_0
                                                                                                               (BoxInt
                                                                                                                0)))
                                                                                                             ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(238,35-238,36)
                                                                                                             (or
                                                                                                              label_12
                                                                                                              ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(238,35-238,36)
                                                                                                              (not
                                                                                                               (=
                                                                                                                @x2
                                                                                                                (BoxInt
                                                                                                                 0)))))
                                                                                                            ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                            (forall
                                                                                                              ((@x33
                                                                                                                Term))
                                                                                                             (! (implies
                                                                                                               (and
                                                                                                                (HasType
                                                                                                                 @x33
                                                                                                                 Prims.pos)
                                                                                                                ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                (=
                                                                                                                 @x2
                                                                                                                 @x33))
                                                                                                               ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                               (forall
                                                                                                                 ((@x34
                                                                                                                   Term))
                                                                                                                (! (implies
                                                                                                                  (and
                                                                                                                   (HasType
                                                                                                                    @x34
                                                                                                                    Prims.int)
                                                                                                                   ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                   (=
                                                                                                                    (Prims.op_Modulus
                                                                                                                     @x0
                                                                                                                     @x2)
                                                                                                                    @x34))
                                                                                                                  ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                  (forall
                                                                                                                    ((@x35
                                                                                                                      Term))
                                                                                                                   (! (implies
                                                                                                                     (and
                                                                                                                      (HasType
                                                                                                                       @x35
                                                                                                                       Prims.int)
                                                                                                                      ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                      (=
                                                                                                                       (Prims.op_Subtraction
                                                                                                                        @x0
                                                                                                                        (Prims.op_Modulus
                                                                                                                         @x0
                                                                                                                         @x2))
                                                                                                                       @x35))
                                                                                                                     ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                     (forall
                                                                                                                       ((@x36
                                                                                                                         Term))
                                                                                                                      (! (implies
                                                                                                                        (and
                                                                                                                         (HasType
                                                                                                                          @x36
                                                                                                                          Prims.int)
                                                                                                                         ;; def=FStar.Calc.fsti(65,7-65,8); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                         (=
                                                                                                                          (Prims.op_Subtraction
                                                                                                                           (Prims.op_Subtraction
                                                                                                                            (Prims.op_Addition
                                                                                                                             @x0
                                                                                                                             (Prims.op_Multiply
                                                                                                                              @x1
                                                                                                                              @x2))
                                                                                                                            (Prims.op_Modulus
                                                                                                                             (Prims.op_Addition
                                                                                                                              @x0
                                                                                                                              (Prims.op_Multiply
                                                                                                                               @x1
                                                                                                                               @x2))
                                                                                                                             @x2))
                                                                                                                           (Prims.op_Subtraction
                                                                                                                            @x0
                                                                                                                            (Prims.op_Modulus
                                                                                                                             @x0
                                                                                                                             @x2)))
                                                                                                                          @x36))
                                                                                                                        ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                        (and
                                                                                                                         (implies
                                                                                                                          ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(240,18-240,19)
                                                                                                                          (>
                                                                                                                           (BoxInt_proj_0
                                                                                                                            @x2)
                                                                                                                           (BoxInt_proj_0
                                                                                                                            (BoxInt
                                                                                                                             0)))
                                                                                                                          ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(240,18-240,19)
                                                                                                                          (or
                                                                                                                           label_13
                                                                                                                           ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(240,18-240,19)
                                                                                                                           (not
                                                                                                                            (=
                                                                                                                             @x2
                                                                                                                             (BoxInt
                                                                                                                              0)))))
                                                                                                                         ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                         (forall
                                                                                                                           ((@x37
                                                                                                                             Term))
                                                                                                                          (! (implies
                                                                                                                            (and
                                                                                                                             (HasType
                                                                                                                              @x37
                                                                                                                              Prims.pos)
                                                                                                                             ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                             (=
                                                                                                                              @x2
                                                                                                                              @x37))
                                                                                                                            ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                            (forall
                                                                                                                              ((@x38
                                                                                                                                Term))
                                                                                                                             (! (implies
                                                                                                                               (and
                                                                                                                                (HasType
                                                                                                                                 @x38
                                                                                                                                 Prims.int)
                                                                                                                                ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                (=
                                                                                                                                 (Prims.op_Modulus
                                                                                                                                  (Prims.op_Addition
                                                                                                                                   @x0
                                                                                                                                   (Prims.op_Multiply
                                                                                                                                    @x1
                                                                                                                                    @x2))
                                                                                                                                  @x2)
                                                                                                                                 @x38))
                                                                                                                               ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                               (forall
                                                                                                                                 ((@x39
                                                                                                                                   Term))
                                                                                                                                (! (implies
                                                                                                                                  (and
                                                                                                                                   (HasType
                                                                                                                                    @x39
                                                                                                                                    Prims.int)
                                                                                                                                   ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                   (=
                                                                                                                                    (Prims.op_Subtraction
                                                                                                                                     (Prims.op_Multiply
                                                                                                                                      @x1
                                                                                                                                      @x2)
                                                                                                                                     (Prims.op_Modulus
                                                                                                                                      (Prims.op_Addition
                                                                                                                                       @x0
                                                                                                                                       (Prims.op_Multiply
                                                                                                                                        @x1
                                                                                                                                        @x2))
                                                                                                                                      @x2))
                                                                                                                                    @x39))
                                                                                                                                  ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                  (and
                                                                                                                                   (implies
                                                                                                                                    ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(240,24-240,25)
                                                                                                                                    (>
                                                                                                                                     (BoxInt_proj_0
                                                                                                                                      @x2)
                                                                                                                                     (BoxInt_proj_0
                                                                                                                                      (BoxInt
                                                                                                                                       0)))
                                                                                                                                    ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(240,24-240,25)
                                                                                                                                    (or
                                                                                                                                     label_14
                                                                                                                                     ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(240,24-240,25)
                                                                                                                                     (not
                                                                                                                                      (=
                                                                                                                                       @x2
                                                                                                                                       (BoxInt
                                                                                                                                        0)))))
                                                                                                                                   ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                   (forall
                                                                                                                                     ((@x40
                                                                                                                                       Term))
                                                                                                                                    (! (implies
                                                                                                                                      (and
                                                                                                                                       (HasType
                                                                                                                                        @x40
                                                                                                                                        Prims.pos)
                                                                                                                                       ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                       (=
                                                                                                                                        @x2
                                                                                                                                        @x40))
                                                                                                                                      ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                      (forall
                                                                                                                                        ((@x41
                                                                                                                                          Term))
                                                                                                                                       (! (implies
                                                                                                                                         (and
                                                                                                                                          (HasType
                                                                                                                                           @x41
                                                                                                                                           Prims.int)
                                                                                                                                          ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                          (=
                                                                                                                                           (Prims.op_Modulus
                                                                                                                                            @x0
                                                                                                                                            @x2)
                                                                                                                                           @x41))
                                                                                                                                         ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                         (forall
                                                                                                                                           ((@x42
                                                                                                                                             Term))
                                                                                                                                          (! (implies
                                                                                                                                            (and
                                                                                                                                             (HasType
                                                                                                                                              @x42
                                                                                                                                              Prims.int)
                                                                                                                                             ;; def=FStar.Calc.fsti(67,3-67,4); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                             (=
                                                                                                                                              (Prims.op_Addition
                                                                                                                                               (Prims.op_Subtraction
                                                                                                                                                (Prims.op_Multiply
                                                                                                                                                 @x1
                                                                                                                                                 @x2)
                                                                                                                                                (Prims.op_Modulus
                                                                                                                                                 (Prims.op_Addition
                                                                                                                                                  @x0
                                                                                                                                                  (Prims.op_Multiply
                                                                                                                                                   @x1
                                                                                                                                                   @x2))
                                                                                                                                                 @x2))
                                                                                                                                               (Prims.op_Modulus
                                                                                                                                                @x0
                                                                                                                                                @x2))
                                                                                                                                              @x42))
                                                                                                                                            ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                            (and
                                                                                                                                             ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                             (forall
                                                                                                                                               ((@x43
                                                                                                                                                 Term))
                                                                                                                                              (! (implies
                                                                                                                                                (HasType
                                                                                                                                                 @x43
                                                                                                                                                 Prims.unit)
                                                                                                                                                ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                (and
                                                                                                                                                 (implies
                                                                                                                                                  ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(234,17-234,18)
                                                                                                                                                  (>
                                                                                                                                                   (BoxInt_proj_0
                                                                                                                                                    @x2)
                                                                                                                                                   (BoxInt_proj_0
                                                                                                                                                    (BoxInt
                                                                                                                                                     0)))
                                                                                                                                                  ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(234,17-234,18)
                                                                                                                                                  (or
                                                                                                                                                   label_15
                                                                                                                                                   ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(234,17-234,18)
                                                                                                                                                   (not
                                                                                                                                                    (=
                                                                                                                                                     @x2
                                                                                                                                                     (BoxInt
                                                                                                                                                      0)))))
                                                                                                                                                 ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                 (forall
                                                                                                                                                   ((@x44
                                                                                                                                                     Term))
                                                                                                                                                  (! (implies
                                                                                                                                                    (and
                                                                                                                                                     (HasType
                                                                                                                                                      @x44
                                                                                                                                                      Prims.pos)
                                                                                                                                                     ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                     (=
                                                                                                                                                      @x2
                                                                                                                                                      @x44))
                                                                                                                                                    ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                    (forall
                                                                                                                                                      ((@x45
                                                                                                                                                        Term))
                                                                                                                                                     (! (implies
                                                                                                                                                       (and
                                                                                                                                                        (HasType
                                                                                                                                                         @x45
                                                                                                                                                         Prims.int)
                                                                                                                                                        ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                        (=
                                                                                                                                                         (Prims.op_Division
                                                                                                                                                          (Prims.op_Addition
                                                                                                                                                           @x0
                                                                                                                                                           (Prims.op_Multiply
                                                                                                                                                            @x1
                                                                                                                                                            @x2))
                                                                                                                                                          @x2)
                                                                                                                                                         @x45))
                                                                                                                                                       ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                       (and
                                                                                                                                                        (implies
                                                                                                                                                         ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(234,23-234,24)
                                                                                                                                                         (>
                                                                                                                                                          (BoxInt_proj_0
                                                                                                                                                           @x2)
                                                                                                                                                          (BoxInt_proj_0
                                                                                                                                                           (BoxInt
                                                                                                                                                            0)))
                                                                                                                                                         ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(234,23-234,24)
                                                                                                                                                         (or
                                                                                                                                                          label_16
                                                                                                                                                          ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(234,23-234,24)
                                                                                                                                                          (not
                                                                                                                                                           (=
                                                                                                                                                            @x2
                                                                                                                                                            (BoxInt
                                                                                                                                                             0)))))
                                                                                                                                                        ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                        (forall
                                                                                                                                                          ((@x46
                                                                                                                                                            Term))
                                                                                                                                                         (! (implies
                                                                                                                                                           (and
                                                                                                                                                            (HasType
                                                                                                                                                             @x46
                                                                                                                                                             Prims.pos)
                                                                                                                                                            ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                            (=
                                                                                                                                                             @x2
                                                                                                                                                             @x46))
                                                                                                                                                           ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                           (forall
                                                                                                                                                             ((@x47
                                                                                                                                                               Term))
                                                                                                                                                            (! (implies
                                                                                                                                                              (and
                                                                                                                                                               (HasType
                                                                                                                                                                @x47
                                                                                                                                                                Prims.int)
                                                                                                                                                               ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                               (=
                                                                                                                                                                (Prims.op_Division
                                                                                                                                                                 @x0
                                                                                                                                                                 @x2)
                                                                                                                                                                @x47))
                                                                                                                                                              ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                              (forall
                                                                                                                                                                ((@x48
                                                                                                                                                                  Term))
                                                                                                                                                               (! (implies
                                                                                                                                                                 (and
                                                                                                                                                                  (HasType
                                                                                                                                                                   @x48
                                                                                                                                                                   Prims.int)
                                                                                                                                                                  ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                  (=
                                                                                                                                                                   (Prims.op_Subtraction
                                                                                                                                                                    (Prims.op_Division
                                                                                                                                                                     (Prims.op_Addition
                                                                                                                                                                      @x0
                                                                                                                                                                      (Prims.op_Multiply
                                                                                                                                                                       @x1
                                                                                                                                                                       @x2))
                                                                                                                                                                     @x2)
                                                                                                                                                                    (Prims.op_Division
                                                                                                                                                                     @x0
                                                                                                                                                                     @x2))
                                                                                                                                                                   @x48))
                                                                                                                                                                 ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                 (forall
                                                                                                                                                                   ((@x49
                                                                                                                                                                     Term))
                                                                                                                                                                  (! (implies
                                                                                                                                                                    (and
                                                                                                                                                                     (HasType
                                                                                                                                                                      @x49
                                                                                                                                                                      Prims.int)
                                                                                                                                                                     ;; def=FStar.Calc.fsti(65,4-65,5); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                     (=
                                                                                                                                                                      (Prims.op_Multiply
                                                                                                                                                                       @x2
                                                                                                                                                                       (Prims.op_Subtraction
                                                                                                                                                                        (Prims.op_Division
                                                                                                                                                                         (Prims.op_Addition
                                                                                                                                                                          @x0
                                                                                                                                                                          (Prims.op_Multiply
                                                                                                                                                                           @x1
                                                                                                                                                                           @x2))
                                                                                                                                                                         @x2)
                                                                                                                                                                        (Prims.op_Division
                                                                                                                                                                         @x0
                                                                                                                                                                         @x2)))
                                                                                                                                                                      @x49))
                                                                                                                                                                    ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                    (and
                                                                                                                                                                     (implies
                                                                                                                                                                      ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(236,17-236,18)
                                                                                                                                                                      (>
                                                                                                                                                                       (BoxInt_proj_0
                                                                                                                                                                        @x2)
                                                                                                                                                                       (BoxInt_proj_0
                                                                                                                                                                        (BoxInt
                                                                                                                                                                         0)))
                                                                                                                                                                      ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(236,17-236,18)
                                                                                                                                                                      (or
                                                                                                                                                                       label_17
                                                                                                                                                                       ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(236,17-236,18)
                                                                                                                                                                       (not
                                                                                                                                                                        (=
                                                                                                                                                                         @x2
                                                                                                                                                                         (BoxInt
                                                                                                                                                                          0)))))
                                                                                                                                                                     ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                     (forall
                                                                                                                                                                       ((@x50
                                                                                                                                                                         Term))
                                                                                                                                                                      (! (implies
                                                                                                                                                                        (and
                                                                                                                                                                         (HasType
                                                                                                                                                                          @x50
                                                                                                                                                                          Prims.pos)
                                                                                                                                                                         ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                         (=
                                                                                                                                                                          @x2
                                                                                                                                                                          @x50))
                                                                                                                                                                        ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                        (forall
                                                                                                                                                                          ((@x51
                                                                                                                                                                            Term))
                                                                                                                                                                         (! (implies
                                                                                                                                                                           (and
                                                                                                                                                                            (HasType
                                                                                                                                                                             @x51
                                                                                                                                                                             Prims.int)
                                                                                                                                                                            ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                            (=
                                                                                                                                                                             (Prims.op_Division
                                                                                                                                                                              (Prims.op_Addition
                                                                                                                                                                               @x0
                                                                                                                                                                               (Prims.op_Multiply
                                                                                                                                                                                @x1
                                                                                                                                                                                @x2))
                                                                                                                                                                              @x2)
                                                                                                                                                                             @x51))
                                                                                                                                                                           ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                           (forall
                                                                                                                                                                             ((@x52
                                                                                                                                                                               Term))
                                                                                                                                                                            (! (implies
                                                                                                                                                                              (and
                                                                                                                                                                               (HasType
                                                                                                                                                                                @x52
                                                                                                                                                                                Prims.int)
                                                                                                                                                                               ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                               (=
                                                                                                                                                                                (Prims.op_Multiply
                                                                                                                                                                                 @x2
                                                                                                                                                                                 (Prims.op_Division
                                                                                                                                                                                  (Prims.op_Addition
                                                                                                                                                                                   @x0
                                                                                                                                                                                   (Prims.op_Multiply
                                                                                                                                                                                    @x1
                                                                                                                                                                                    @x2))
                                                                                                                                                                                  @x2))
                                                                                                                                                                                @x52))
                                                                                                                                                                              ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                              (and
                                                                                                                                                                               (implies
                                                                                                                                                                                ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(236,27-236,28)
                                                                                                                                                                                (>
                                                                                                                                                                                 (BoxInt_proj_0
                                                                                                                                                                                  @x2)
                                                                                                                                                                                 (BoxInt_proj_0
                                                                                                                                                                                  (BoxInt
                                                                                                                                                                                   0)))
                                                                                                                                                                                ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(236,27-236,28)
                                                                                                                                                                                (or
                                                                                                                                                                                 label_18
                                                                                                                                                                                 ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(236,27-236,28)
                                                                                                                                                                                 (not
                                                                                                                                                                                  (=
                                                                                                                                                                                   @x2
                                                                                                                                                                                   (BoxInt
                                                                                                                                                                                    0)))))
                                                                                                                                                                               ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                               (forall
                                                                                                                                                                                 ((@x53
                                                                                                                                                                                   Term))
                                                                                                                                                                                (! (implies
                                                                                                                                                                                  (and
                                                                                                                                                                                   (HasType
                                                                                                                                                                                    @x53
                                                                                                                                                                                    Prims.pos)
                                                                                                                                                                                   ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                   (=
                                                                                                                                                                                    @x2
                                                                                                                                                                                    @x53))
                                                                                                                                                                                  ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                  (forall
                                                                                                                                                                                    ((@x54
                                                                                                                                                                                      Term))
                                                                                                                                                                                   (! (implies
                                                                                                                                                                                     (and
                                                                                                                                                                                      (HasType
                                                                                                                                                                                       @x54
                                                                                                                                                                                       Prims.int)
                                                                                                                                                                                      ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                      (=
                                                                                                                                                                                       (Prims.op_Division
                                                                                                                                                                                        @x0
                                                                                                                                                                                        @x2)
                                                                                                                                                                                       @x54))
                                                                                                                                                                                     ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                     (forall
                                                                                                                                                                                       ((@x55
                                                                                                                                                                                         Term))
                                                                                                                                                                                      (! (implies
                                                                                                                                                                                        (and
                                                                                                                                                                                         (HasType
                                                                                                                                                                                          @x55
                                                                                                                                                                                          Prims.int)
                                                                                                                                                                                         ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                         (=
                                                                                                                                                                                          (Prims.op_Multiply
                                                                                                                                                                                           @x2
                                                                                                                                                                                           (Prims.op_Division
                                                                                                                                                                                            @x0
                                                                                                                                                                                            @x2))
                                                                                                                                                                                          @x55))
                                                                                                                                                                                        ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                        (forall
                                                                                                                                                                                          ((@x56
                                                                                                                                                                                            Term))
                                                                                                                                                                                         (! (implies
                                                                                                                                                                                           (and
                                                                                                                                                                                            (HasType
                                                                                                                                                                                             @x56
                                                                                                                                                                                             Prims.int)
                                                                                                                                                                                            ;; def=FStar.Calc.fsti(65,7-65,8); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                            (=
                                                                                                                                                                                             (Prims.op_Subtraction
                                                                                                                                                                                              (Prims.op_Multiply
                                                                                                                                                                                               @x2
                                                                                                                                                                                               (Prims.op_Division
                                                                                                                                                                                                (Prims.op_Addition
                                                                                                                                                                                                 @x0
                                                                                                                                                                                                 (Prims.op_Multiply
                                                                                                                                                                                                  @x1
                                                                                                                                                                                                  @x2))
                                                                                                                                                                                                @x2))
                                                                                                                                                                                              (Prims.op_Multiply
                                                                                                                                                                                               @x2
                                                                                                                                                                                               (Prims.op_Division
                                                                                                                                                                                                @x0
                                                                                                                                                                                                @x2)))
                                                                                                                                                                                             @x56))
                                                                                                                                                                                           ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                           (and
                                                                                                                                                                                            (implies
                                                                                                                                                                                             ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(238,23-238,24)
                                                                                                                                                                                             (>
                                                                                                                                                                                              (BoxInt_proj_0
                                                                                                                                                                                               @x2)
                                                                                                                                                                                              (BoxInt_proj_0
                                                                                                                                                                                               (BoxInt
                                                                                                                                                                                                0)))
                                                                                                                                                                                             ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(238,23-238,24)
                                                                                                                                                                                             (or
                                                                                                                                                                                              label_19
                                                                                                                                                                                              ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(238,23-238,24)
                                                                                                                                                                                              (not
                                                                                                                                                                                               (=
                                                                                                                                                                                                @x2
                                                                                                                                                                                                (BoxInt
                                                                                                                                                                                                 0)))))
                                                                                                                                                                                            ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                            (forall
                                                                                                                                                                                              ((@x57
                                                                                                                                                                                                Term))
                                                                                                                                                                                             (! (implies
                                                                                                                                                                                               (and
                                                                                                                                                                                                (HasType
                                                                                                                                                                                                 @x57
                                                                                                                                                                                                 Prims.pos)
                                                                                                                                                                                                ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                (=
                                                                                                                                                                                                 @x2
                                                                                                                                                                                                 @x57))
                                                                                                                                                                                               ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                               (forall
                                                                                                                                                                                                 ((@x58
                                                                                                                                                                                                   Term))
                                                                                                                                                                                                (! (implies
                                                                                                                                                                                                  (and
                                                                                                                                                                                                   (HasType
                                                                                                                                                                                                    @x58
                                                                                                                                                                                                    Prims.int)
                                                                                                                                                                                                   ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                   (=
                                                                                                                                                                                                    (Prims.op_Modulus
                                                                                                                                                                                                     (Prims.op_Addition
                                                                                                                                                                                                      @x0
                                                                                                                                                                                                      (Prims.op_Multiply
                                                                                                                                                                                                       @x1
                                                                                                                                                                                                       @x2))
                                                                                                                                                                                                     @x2)
                                                                                                                                                                                                    @x58))
                                                                                                                                                                                                  ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                  (forall
                                                                                                                                                                                                    ((@x59
                                                                                                                                                                                                      Term))
                                                                                                                                                                                                   (! (implies
                                                                                                                                                                                                     (and
                                                                                                                                                                                                      (HasType
                                                                                                                                                                                                       @x59
                                                                                                                                                                                                       Prims.int)
                                                                                                                                                                                                      ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                      (=
                                                                                                                                                                                                       (Prims.op_Subtraction
                                                                                                                                                                                                        (Prims.op_Addition
                                                                                                                                                                                                         @x0
                                                                                                                                                                                                         (Prims.op_Multiply
                                                                                                                                                                                                          @x1
                                                                                                                                                                                                          @x2))
                                                                                                                                                                                                        (Prims.op_Modulus
                                                                                                                                                                                                         (Prims.op_Addition
                                                                                                                                                                                                          @x0
                                                                                                                                                                                                          (Prims.op_Multiply
                                                                                                                                                                                                           @x1
                                                                                                                                                                                                           @x2))
                                                                                                                                                                                                         @x2))
                                                                                                                                                                                                       @x59))
                                                                                                                                                                                                     ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                     (and
                                                                                                                                                                                                      (implies
                                                                                                                                                                                                       ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(238,35-238,36)
                                                                                                                                                                                                       (>
                                                                                                                                                                                                        (BoxInt_proj_0
                                                                                                                                                                                                         @x2)
                                                                                                                                                                                                        (BoxInt_proj_0
                                                                                                                                                                                                         (BoxInt
                                                                                                                                                                                                          0)))
                                                                                                                                                                                                       ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(238,35-238,36)
                                                                                                                                                                                                       (or
                                                                                                                                                                                                        label_20
                                                                                                                                                                                                        ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(238,35-238,36)
                                                                                                                                                                                                        (not
                                                                                                                                                                                                         (=
                                                                                                                                                                                                          @x2
                                                                                                                                                                                                          (BoxInt
                                                                                                                                                                                                           0)))))
                                                                                                                                                                                                      ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                      (forall
                                                                                                                                                                                                        ((@x60
                                                                                                                                                                                                          Term))
                                                                                                                                                                                                       (! (implies
                                                                                                                                                                                                         (and
                                                                                                                                                                                                          (HasType
                                                                                                                                                                                                           @x60
                                                                                                                                                                                                           Prims.pos)
                                                                                                                                                                                                          ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                          (=
                                                                                                                                                                                                           @x2
                                                                                                                                                                                                           @x60))
                                                                                                                                                                                                         ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                         (forall
                                                                                                                                                                                                           ((@x61
                                                                                                                                                                                                             Term))
                                                                                                                                                                                                          (! (implies
                                                                                                                                                                                                            (and
                                                                                                                                                                                                             (HasType
                                                                                                                                                                                                              @x61
                                                                                                                                                                                                              Prims.int)
                                                                                                                                                                                                             ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                             (=
                                                                                                                                                                                                              (Prims.op_Modulus
                                                                                                                                                                                                               @x0
                                                                                                                                                                                                               @x2)
                                                                                                                                                                                                              @x61))
                                                                                                                                                                                                            ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                            (forall
                                                                                                                                                                                                              ((@x62
                                                                                                                                                                                                                Term))
                                                                                                                                                                                                             (! (implies
                                                                                                                                                                                                               (and
                                                                                                                                                                                                                (HasType
                                                                                                                                                                                                                 @x62
                                                                                                                                                                                                                 Prims.int)
                                                                                                                                                                                                                ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                (=
                                                                                                                                                                                                                 (Prims.op_Subtraction
                                                                                                                                                                                                                  @x0
                                                                                                                                                                                                                  (Prims.op_Modulus
                                                                                                                                                                                                                   @x0
                                                                                                                                                                                                                   @x2))
                                                                                                                                                                                                                 @x62))
                                                                                                                                                                                                               ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                               (forall
                                                                                                                                                                                                                 ((@x63
                                                                                                                                                                                                                   Term))
                                                                                                                                                                                                                (! (implies
                                                                                                                                                                                                                  (and
                                                                                                                                                                                                                   (HasType
                                                                                                                                                                                                                    @x63
                                                                                                                                                                                                                    Prims.int)
                                                                                                                                                                                                                   ;; def=FStar.Calc.fsti(67,3-67,4); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                   (=
                                                                                                                                                                                                                    (Prims.op_Subtraction
                                                                                                                                                                                                                     (Prims.op_Subtraction
                                                                                                                                                                                                                      (Prims.op_Addition
                                                                                                                                                                                                                       @x0
                                                                                                                                                                                                                       (Prims.op_Multiply
                                                                                                                                                                                                                        @x1
                                                                                                                                                                                                                        @x2))
                                                                                                                                                                                                                      (Prims.op_Modulus
                                                                                                                                                                                                                       (Prims.op_Addition
                                                                                                                                                                                                                        @x0
                                                                                                                                                                                                                        (Prims.op_Multiply
                                                                                                                                                                                                                         @x1
                                                                                                                                                                                                                         @x2))
                                                                                                                                                                                                                       @x2))
                                                                                                                                                                                                                     (Prims.op_Subtraction
                                                                                                                                                                                                                      @x0
                                                                                                                                                                                                                      (Prims.op_Modulus
                                                                                                                                                                                                                       @x0
                                                                                                                                                                                                                       @x2)))
                                                                                                                                                                                                                    @x63))
                                                                                                                                                                                                                  ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                  (and
                                                                                                                                                                                                                   ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                   (forall
                                                                                                                                                                                                                     ((@x64
                                                                                                                                                                                                                       Term))
                                                                                                                                                                                                                    (! (implies
                                                                                                                                                                                                                      (HasType
                                                                                                                                                                                                                       @x64
                                                                                                                                                                                                                       Prims.unit)
                                                                                                                                                                                                                      ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                      (and
                                                                                                                                                                                                                       (implies
                                                                                                                                                                                                                        ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(234,17-234,18)
                                                                                                                                                                                                                        (>
                                                                                                                                                                                                                         (BoxInt_proj_0
                                                                                                                                                                                                                          @x2)
                                                                                                                                                                                                                         (BoxInt_proj_0
                                                                                                                                                                                                                          (BoxInt
                                                                                                                                                                                                                           0)))
                                                                                                                                                                                                                        ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(234,17-234,18)
                                                                                                                                                                                                                        (or
                                                                                                                                                                                                                         label_21
                                                                                                                                                                                                                         ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(234,17-234,18)
                                                                                                                                                                                                                         (not
                                                                                                                                                                                                                          (=
                                                                                                                                                                                                                           @x2
                                                                                                                                                                                                                           (BoxInt
                                                                                                                                                                                                                            0)))))
                                                                                                                                                                                                                       ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                       (forall
                                                                                                                                                                                                                         ((@x65
                                                                                                                                                                                                                           Term))
                                                                                                                                                                                                                        (! (implies
                                                                                                                                                                                                                          (and
                                                                                                                                                                                                                           (HasType
                                                                                                                                                                                                                            @x65
                                                                                                                                                                                                                            Prims.pos)
                                                                                                                                                                                                                           ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                           (=
                                                                                                                                                                                                                            @x2
                                                                                                                                                                                                                            @x65))
                                                                                                                                                                                                                          ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                          (forall
                                                                                                                                                                                                                            ((@x66
                                                                                                                                                                                                                              Term))
                                                                                                                                                                                                                           (! (implies
                                                                                                                                                                                                                             (and
                                                                                                                                                                                                                              (HasType
                                                                                                                                                                                                                               @x66
                                                                                                                                                                                                                               Prims.int)
                                                                                                                                                                                                                              ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                              (=
                                                                                                                                                                                                                               (Prims.op_Division
                                                                                                                                                                                                                                (Prims.op_Addition
                                                                                                                                                                                                                                 @x0
                                                                                                                                                                                                                                 (Prims.op_Multiply
                                                                                                                                                                                                                                  @x1
                                                                                                                                                                                                                                  @x2))
                                                                                                                                                                                                                                @x2)
                                                                                                                                                                                                                               @x66))
                                                                                                                                                                                                                             ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                             (and
                                                                                                                                                                                                                              (implies
                                                                                                                                                                                                                               ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(234,23-234,24)
                                                                                                                                                                                                                               (>
                                                                                                                                                                                                                                (BoxInt_proj_0
                                                                                                                                                                                                                                 @x2)
                                                                                                                                                                                                                                (BoxInt_proj_0
                                                                                                                                                                                                                                 (BoxInt
                                                                                                                                                                                                                                  0)))
                                                                                                                                                                                                                               ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(234,23-234,24)
                                                                                                                                                                                                                               (or
                                                                                                                                                                                                                                label_22
                                                                                                                                                                                                                                ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(234,23-234,24)
                                                                                                                                                                                                                                (not
                                                                                                                                                                                                                                 (=
                                                                                                                                                                                                                                  @x2
                                                                                                                                                                                                                                  (BoxInt
                                                                                                                                                                                                                                   0)))))
                                                                                                                                                                                                                              ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                              (forall
                                                                                                                                                                                                                                ((@x67
                                                                                                                                                                                                                                  Term))
                                                                                                                                                                                                                               (! (implies
                                                                                                                                                                                                                                 (and
                                                                                                                                                                                                                                  (HasType
                                                                                                                                                                                                                                   @x67
                                                                                                                                                                                                                                   Prims.pos)
                                                                                                                                                                                                                                  ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                                  (=
                                                                                                                                                                                                                                   @x2
                                                                                                                                                                                                                                   @x67))
                                                                                                                                                                                                                                 ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                                 (forall
                                                                                                                                                                                                                                   ((@x68
                                                                                                                                                                                                                                     Term))
                                                                                                                                                                                                                                  (! (implies
                                                                                                                                                                                                                                    (and
                                                                                                                                                                                                                                     (HasType
                                                                                                                                                                                                                                      @x68
                                                                                                                                                                                                                                      Prims.int)
                                                                                                                                                                                                                                     ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                                     (=
                                                                                                                                                                                                                                      (Prims.op_Division
                                                                                                                                                                                                                                       @x0
                                                                                                                                                                                                                                       @x2)
                                                                                                                                                                                                                                      @x68))
                                                                                                                                                                                                                                    ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                                    (forall
                                                                                                                                                                                                                                      ((@x69
                                                                                                                                                                                                                                        Term))
                                                                                                                                                                                                                                     (! (implies
                                                                                                                                                                                                                                       (and
                                                                                                                                                                                                                                        (HasType
                                                                                                                                                                                                                                         @x69
                                                                                                                                                                                                                                         Prims.int)
                                                                                                                                                                                                                                        ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                                        (=
                                                                                                                                                                                                                                         (Prims.op_Subtraction
                                                                                                                                                                                                                                          (Prims.op_Division
                                                                                                                                                                                                                                           (Prims.op_Addition
                                                                                                                                                                                                                                            @x0
                                                                                                                                                                                                                                            (Prims.op_Multiply
                                                                                                                                                                                                                                             @x1
                                                                                                                                                                                                                                             @x2))
                                                                                                                                                                                                                                           @x2)
                                                                                                                                                                                                                                          (Prims.op_Division
                                                                                                                                                                                                                                           @x0
                                                                                                                                                                                                                                           @x2))
                                                                                                                                                                                                                                         @x69))
                                                                                                                                                                                                                                       ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                                       (forall
                                                                                                                                                                                                                                         ((@x70
                                                                                                                                                                                                                                           Term))
                                                                                                                                                                                                                                        (! (implies
                                                                                                                                                                                                                                          (and
                                                                                                                                                                                                                                           (HasType
                                                                                                                                                                                                                                            @x70
                                                                                                                                                                                                                                            Prims.int)
                                                                                                                                                                                                                                           ;; def=FStar.Calc.fsti(65,4-65,5); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                                           (=
                                                                                                                                                                                                                                            (Prims.op_Multiply
                                                                                                                                                                                                                                             @x2
                                                                                                                                                                                                                                             (Prims.op_Subtraction
                                                                                                                                                                                                                                              (Prims.op_Division
                                                                                                                                                                                                                                               (Prims.op_Addition
                                                                                                                                                                                                                                                @x0
                                                                                                                                                                                                                                                (Prims.op_Multiply
                                                                                                                                                                                                                                                 @x1
                                                                                                                                                                                                                                                 @x2))
                                                                                                                                                                                                                                               @x2)
                                                                                                                                                                                                                                              (Prims.op_Division
                                                                                                                                                                                                                                               @x0
                                                                                                                                                                                                                                               @x2)))
                                                                                                                                                                                                                                            @x70))
                                                                                                                                                                                                                                          ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                                          (and
                                                                                                                                                                                                                                           (implies
                                                                                                                                                                                                                                            ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(234,17-234,18)
                                                                                                                                                                                                                                            (>
                                                                                                                                                                                                                                             (BoxInt_proj_0
                                                                                                                                                                                                                                              @x2)
                                                                                                                                                                                                                                             (BoxInt_proj_0
                                                                                                                                                                                                                                              (BoxInt
                                                                                                                                                                                                                                               0)))
                                                                                                                                                                                                                                            ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(234,17-234,18)
                                                                                                                                                                                                                                            (or
                                                                                                                                                                                                                                             label_23
                                                                                                                                                                                                                                             ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(234,17-234,18)
                                                                                                                                                                                                                                             (not
                                                                                                                                                                                                                                              (=
                                                                                                                                                                                                                                               @x2
                                                                                                                                                                                                                                               (BoxInt
                                                                                                                                                                                                                                                0)))))
                                                                                                                                                                                                                                           ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                                           (forall
                                                                                                                                                                                                                                             ((@x71
                                                                                                                                                                                                                                               Term))
                                                                                                                                                                                                                                            (! (implies
                                                                                                                                                                                                                                              (and
                                                                                                                                                                                                                                               (HasType
                                                                                                                                                                                                                                                @x71
                                                                                                                                                                                                                                                Prims.pos)
                                                                                                                                                                                                                                               ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                                               (=
                                                                                                                                                                                                                                                @x2
                                                                                                                                                                                                                                                @x71))
                                                                                                                                                                                                                                              ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                                              (forall
                                                                                                                                                                                                                                                ((@x72
                                                                                                                                                                                                                                                  Term))
                                                                                                                                                                                                                                               (! (implies
                                                                                                                                                                                                                                                 (and
                                                                                                                                                                                                                                                  (HasType
                                                                                                                                                                                                                                                   @x72
                                                                                                                                                                                                                                                   Prims.int)
                                                                                                                                                                                                                                                  ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                                                  (=
                                                                                                                                                                                                                                                   (Prims.op_Division
                                                                                                                                                                                                                                                    (Prims.op_Addition
                                                                                                                                                                                                                                                     @x0
                                                                                                                                                                                                                                                     (Prims.op_Multiply
                                                                                                                                                                                                                                                      @x1
                                                                                                                                                                                                                                                      @x2))
                                                                                                                                                                                                                                                    @x2)
                                                                                                                                                                                                                                                   @x72))
                                                                                                                                                                                                                                                 ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                                                 (and
                                                                                                                                                                                                                                                  (implies
                                                                                                                                                                                                                                                   ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(234,23-234,24)
                                                                                                                                                                                                                                                   (>
                                                                                                                                                                                                                                                    (BoxInt_proj_0
                                                                                                                                                                                                                                                     @x2)
                                                                                                                                                                                                                                                    (BoxInt_proj_0
                                                                                                                                                                                                                                                     (BoxInt
                                                                                                                                                                                                                                                      0)))
                                                                                                                                                                                                                                                   ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(234,23-234,24)
                                                                                                                                                                                                                                                   (or
                                                                                                                                                                                                                                                    label_24
                                                                                                                                                                                                                                                    ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(234,23-234,24)
                                                                                                                                                                                                                                                    (not
                                                                                                                                                                                                                                                     (=
                                                                                                                                                                                                                                                      @x2
                                                                                                                                                                                                                                                      (BoxInt
                                                                                                                                                                                                                                                       0)))))
                                                                                                                                                                                                                                                  ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                                                  (forall
                                                                                                                                                                                                                                                    ((@x73
                                                                                                                                                                                                                                                      Term))
                                                                                                                                                                                                                                                   (! (implies
                                                                                                                                                                                                                                                     (and
                                                                                                                                                                                                                                                      (HasType
                                                                                                                                                                                                                                                       @x73
                                                                                                                                                                                                                                                       Prims.pos)
                                                                                                                                                                                                                                                      ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                                                      (=
                                                                                                                                                                                                                                                       @x2
                                                                                                                                                                                                                                                       @x73))
                                                                                                                                                                                                                                                     ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                                                     (forall
                                                                                                                                                                                                                                                       ((@x74
                                                                                                                                                                                                                                                         Term))
                                                                                                                                                                                                                                                      (! (implies
                                                                                                                                                                                                                                                        (and
                                                                                                                                                                                                                                                         (HasType
                                                                                                                                                                                                                                                          @x74
                                                                                                                                                                                                                                                          Prims.int)
                                                                                                                                                                                                                                                         ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                                                         (=
                                                                                                                                                                                                                                                          (Prims.op_Division
                                                                                                                                                                                                                                                           @x0
                                                                                                                                                                                                                                                           @x2)
                                                                                                                                                                                                                                                          @x74))
                                                                                                                                                                                                                                                        ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                                                        (forall
                                                                                                                                                                                                                                                          ((@x75
                                                                                                                                                                                                                                                            Term))
                                                                                                                                                                                                                                                         (! (implies
                                                                                                                                                                                                                                                           (and
                                                                                                                                                                                                                                                            (HasType
                                                                                                                                                                                                                                                             @x75
                                                                                                                                                                                                                                                             Prims.int)
                                                                                                                                                                                                                                                            ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                                                            (=
                                                                                                                                                                                                                                                             (Prims.op_Subtraction
                                                                                                                                                                                                                                                              (Prims.op_Division
                                                                                                                                                                                                                                                               (Prims.op_Addition
                                                                                                                                                                                                                                                                @x0
                                                                                                                                                                                                                                                                (Prims.op_Multiply
                                                                                                                                                                                                                                                                 @x1
                                                                                                                                                                                                                                                                 @x2))
                                                                                                                                                                                                                                                               @x2)
                                                                                                                                                                                                                                                              (Prims.op_Division
                                                                                                                                                                                                                                                               @x0
                                                                                                                                                                                                                                                               @x2))
                                                                                                                                                                                                                                                             @x75))
                                                                                                                                                                                                                                                           ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                                                           (forall
                                                                                                                                                                                                                                                             ((@x76
                                                                                                                                                                                                                                                               Term))
                                                                                                                                                                                                                                                            (! (implies
                                                                                                                                                                                                                                                              (and
                                                                                                                                                                                                                                                               (HasType
                                                                                                                                                                                                                                                                @x76
                                                                                                                                                                                                                                                                Prims.int)
                                                                                                                                                                                                                                                               ;; def=FStar.Calc.fsti(65,7-65,8); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                                                               (=
                                                                                                                                                                                                                                                                (Prims.op_Multiply
                                                                                                                                                                                                                                                                 @x2
                                                                                                                                                                                                                                                                 (Prims.op_Subtraction
                                                                                                                                                                                                                                                                  (Prims.op_Division
                                                                                                                                                                                                                                                                   (Prims.op_Addition
                                                                                                                                                                                                                                                                    @x0
                                                                                                                                                                                                                                                                    (Prims.op_Multiply
                                                                                                                                                                                                                                                                     @x1
                                                                                                                                                                                                                                                                     @x2))
                                                                                                                                                                                                                                                                   @x2)
                                                                                                                                                                                                                                                                  (Prims.op_Division
                                                                                                                                                                                                                                                                   @x0
                                                                                                                                                                                                                                                                   @x2)))
                                                                                                                                                                                                                                                                @x76))
                                                                                                                                                                                                                                                              ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                                                              (and
                                                                                                                                                                                                                                                               (implies
                                                                                                                                                                                                                                                                ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(236,17-236,18)
                                                                                                                                                                                                                                                                (>
                                                                                                                                                                                                                                                                 (BoxInt_proj_0
                                                                                                                                                                                                                                                                  @x2)
                                                                                                                                                                                                                                                                 (BoxInt_proj_0
                                                                                                                                                                                                                                                                  (BoxInt
                                                                                                                                                                                                                                                                   0)))
                                                                                                                                                                                                                                                                ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(236,17-236,18)
                                                                                                                                                                                                                                                                (or
                                                                                                                                                                                                                                                                 label_25
                                                                                                                                                                                                                                                                 ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(236,17-236,18)
                                                                                                                                                                                                                                                                 (not
                                                                                                                                                                                                                                                                  (=
                                                                                                                                                                                                                                                                   @x2
                                                                                                                                                                                                                                                                   (BoxInt
                                                                                                                                                                                                                                                                    0)))))
                                                                                                                                                                                                                                                               ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                                                               (forall
                                                                                                                                                                                                                                                                 ((@x77
                                                                                                                                                                                                                                                                   Term))
                                                                                                                                                                                                                                                                (! (implies
                                                                                                                                                                                                                                                                  (and
                                                                                                                                                                                                                                                                   (HasType
                                                                                                                                                                                                                                                                    @x77
                                                                                                                                                                                                                                                                    Prims.pos)
                                                                                                                                                                                                                                                                   ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                                                                   (=
                                                                                                                                                                                                                                                                    @x2
                                                                                                                                                                                                                                                                    @x77))
                                                                                                                                                                                                                                                                  ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                                                                  (forall
                                                                                                                                                                                                                                                                    ((@x78
                                                                                                                                                                                                                                                                      Term))
                                                                                                                                                                                                                                                                   (! (implies
                                                                                                                                                                                                                                                                     (and
                                                                                                                                                                                                                                                                      (HasType
                                                                                                                                                                                                                                                                       @x78
                                                                                                                                                                                                                                                                       Prims.int)
                                                                                                                                                                                                                                                                      ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                                                                      (=
                                                                                                                                                                                                                                                                       (Prims.op_Division
                                                                                                                                                                                                                                                                        (Prims.op_Addition
                                                                                                                                                                                                                                                                         @x0
                                                                                                                                                                                                                                                                         (Prims.op_Multiply
                                                                                                                                                                                                                                                                          @x1
                                                                                                                                                                                                                                                                          @x2))
                                                                                                                                                                                                                                                                        @x2)
                                                                                                                                                                                                                                                                       @x78))
                                                                                                                                                                                                                                                                     ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                                                                     (forall
                                                                                                                                                                                                                                                                       ((@x79
                                                                                                                                                                                                                                                                         Term))
                                                                                                                                                                                                                                                                      (! (implies
                                                                                                                                                                                                                                                                        (and
                                                                                                                                                                                                                                                                         (HasType
                                                                                                                                                                                                                                                                          @x79
                                                                                                                                                                                                                                                                          Prims.int)
                                                                                                                                                                                                                                                                         ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                                                                         (=
                                                                                                                                                                                                                                                                          (Prims.op_Multiply
                                                                                                                                                                                                                                                                           @x2
                                                                                                                                                                                                                                                                           (Prims.op_Division
                                                                                                                                                                                                                                                                            (Prims.op_Addition
                                                                                                                                                                                                                                                                             @x0
                                                                                                                                                                                                                                                                             (Prims.op_Multiply
                                                                                                                                                                                                                                                                              @x1
                                                                                                                                                                                                                                                                              @x2))
                                                                                                                                                                                                                                                                            @x2))
                                                                                                                                                                                                                                                                          @x79))
                                                                                                                                                                                                                                                                        ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                                                                        (and
                                                                                                                                                                                                                                                                         (implies
                                                                                                                                                                                                                                                                          ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(236,27-236,28)
                                                                                                                                                                                                                                                                          (>
                                                                                                                                                                                                                                                                           (BoxInt_proj_0
                                                                                                                                                                                                                                                                            @x2)
                                                                                                                                                                                                                                                                           (BoxInt_proj_0
                                                                                                                                                                                                                                                                            (BoxInt
                                                                                                                                                                                                                                                                             0)))
                                                                                                                                                                                                                                                                          ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(236,27-236,28)
                                                                                                                                                                                                                                                                          (or
                                                                                                                                                                                                                                                                           label_26
                                                                                                                                                                                                                                                                           ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(236,27-236,28)
                                                                                                                                                                                                                                                                           (not
                                                                                                                                                                                                                                                                            (=
                                                                                                                                                                                                                                                                             @x2
                                                                                                                                                                                                                                                                             (BoxInt
                                                                                                                                                                                                                                                                              0)))))
                                                                                                                                                                                                                                                                         ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                                                                         (forall
                                                                                                                                                                                                                                                                           ((@x80
                                                                                                                                                                                                                                                                             Term))
                                                                                                                                                                                                                                                                          (! (implies
                                                                                                                                                                                                                                                                            (and
                                                                                                                                                                                                                                                                             (HasType
                                                                                                                                                                                                                                                                              @x80
                                                                                                                                                                                                                                                                              Prims.pos)
                                                                                                                                                                                                                                                                             ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                                                                             (=
                                                                                                                                                                                                                                                                              @x2
                                                                                                                                                                                                                                                                              @x80))
                                                                                                                                                                                                                                                                            ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                                                                            (forall
                                                                                                                                                                                                                                                                              ((@x81
                                                                                                                                                                                                                                                                                Term))
                                                                                                                                                                                                                                                                             (! (implies
                                                                                                                                                                                                                                                                               (and
                                                                                                                                                                                                                                                                                (HasType
                                                                                                                                                                                                                                                                                 @x81
                                                                                                                                                                                                                                                                                 Prims.int)
                                                                                                                                                                                                                                                                                ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                                                                                (=
                                                                                                                                                                                                                                                                                 (Prims.op_Division
                                                                                                                                                                                                                                                                                  @x0
                                                                                                                                                                                                                                                                                  @x2)
                                                                                                                                                                                                                                                                                 @x81))
                                                                                                                                                                                                                                                                               ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                                                                               (forall
                                                                                                                                                                                                                                                                                 ((@x82
                                                                                                                                                                                                                                                                                   Term))
                                                                                                                                                                                                                                                                                (! (implies
                                                                                                                                                                                                                                                                                  (and
                                                                                                                                                                                                                                                                                   (HasType
                                                                                                                                                                                                                                                                                    @x82
                                                                                                                                                                                                                                                                                    Prims.int)
                                                                                                                                                                                                                                                                                   ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                                                                                   (=
                                                                                                                                                                                                                                                                                    (Prims.op_Multiply
                                                                                                                                                                                                                                                                                     @x2
                                                                                                                                                                                                                                                                                     (Prims.op_Division
                                                                                                                                                                                                                                                                                      @x0
                                                                                                                                                                                                                                                                                      @x2))
                                                                                                                                                                                                                                                                                    @x82))
                                                                                                                                                                                                                                                                                  ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                                                                                  (forall
                                                                                                                                                                                                                                                                                    ((@x83
                                                                                                                                                                                                                                                                                      Term))
                                                                                                                                                                                                                                                                                   (! (implies
                                                                                                                                                                                                                                                                                     (and
                                                                                                                                                                                                                                                                                      (HasType
                                                                                                                                                                                                                                                                                       @x83
                                                                                                                                                                                                                                                                                       Prims.int)
                                                                                                                                                                                                                                                                                      ;; def=FStar.Calc.fsti(67,3-67,4); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                                                                                      (=
                                                                                                                                                                                                                                                                                       (Prims.op_Subtraction
                                                                                                                                                                                                                                                                                        (Prims.op_Multiply
                                                                                                                                                                                                                                                                                         @x2
                                                                                                                                                                                                                                                                                         (Prims.op_Division
                                                                                                                                                                                                                                                                                          (Prims.op_Addition
                                                                                                                                                                                                                                                                                           @x0
                                                                                                                                                                                                                                                                                           (Prims.op_Multiply
                                                                                                                                                                                                                                                                                            @x1
                                                                                                                                                                                                                                                                                            @x2))
                                                                                                                                                                                                                                                                                          @x2))
                                                                                                                                                                                                                                                                                        (Prims.op_Multiply
                                                                                                                                                                                                                                                                                         @x2
                                                                                                                                                                                                                                                                                         (Prims.op_Division
                                                                                                                                                                                                                                                                                          @x0
                                                                                                                                                                                                                                                                                          @x2)))
                                                                                                                                                                                                                                                                                       @x83))
                                                                                                                                                                                                                                                                                     ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                                                                                     (and
                                                                                                                                                                                                                                                                                      ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                                                                                      (forall
                                                                                                                                                                                                                                                                                        ((@x84
                                                                                                                                                                                                                                                                                          Term))
                                                                                                                                                                                                                                                                                       (! (implies
                                                                                                                                                                                                                                                                                         (HasType
                                                                                                                                                                                                                                                                                          @x84
                                                                                                                                                                                                                                                                                          Prims.unit)
                                                                                                                                                                                                                                                                                         ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(234,4-234,25)
                                                                                                                                                                                                                                                                                         (and
                                                                                                                                                                                                                                                                                          (implies
                                                                                                                                                                                                                                                                                           ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(234,17-234,18)
                                                                                                                                                                                                                                                                                           (>
                                                                                                                                                                                                                                                                                            (BoxInt_proj_0
                                                                                                                                                                                                                                                                                             @x2)
                                                                                                                                                                                                                                                                                            (BoxInt_proj_0
                                                                                                                                                                                                                                                                                             (BoxInt
                                                                                                                                                                                                                                                                                              0)))
                                                                                                                                                                                                                                                                                           ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(234,17-234,18)
                                                                                                                                                                                                                                                                                           (or
                                                                                                                                                                                                                                                                                            label_27
                                                                                                                                                                                                                                                                                            ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(234,17-234,18)
                                                                                                                                                                                                                                                                                            (not
                                                                                                                                                                                                                                                                                             (=
                                                                                                                                                                                                                                                                                              @x2
                                                                                                                                                                                                                                                                                              (BoxInt
                                                                                                                                                                                                                                                                                               0)))))
                                                                                                                                                                                                                                                                                          ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(234,4-234,25)
                                                                                                                                                                                                                                                                                          (forall
                                                                                                                                                                                                                                                                                            ((@x85
                                                                                                                                                                                                                                                                                              Term))
                                                                                                                                                                                                                                                                                           (! (implies
                                                                                                                                                                                                                                                                                             (and
                                                                                                                                                                                                                                                                                              (HasType
                                                                                                                                                                                                                                                                                               @x85
                                                                                                                                                                                                                                                                                               Prims.pos)
                                                                                                                                                                                                                                                                                              ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(234,4-234,25)
                                                                                                                                                                                                                                                                                              (=
                                                                                                                                                                                                                                                                                               @x2
                                                                                                                                                                                                                                                                                               @x85))
                                                                                                                                                                                                                                                                                             ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(234,4-234,25)
                                                                                                                                                                                                                                                                                             (forall
                                                                                                                                                                                                                                                                                               ((@x86
                                                                                                                                                                                                                                                                                                 Term))
                                                                                                                                                                                                                                                                                              (! (implies
                                                                                                                                                                                                                                                                                                (and
                                                                                                                                                                                                                                                                                                 (HasType
                                                                                                                                                                                                                                                                                                  @x86
                                                                                                                                                                                                                                                                                                  Prims.int)
                                                                                                                                                                                                                                                                                                 ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(234,4-234,25)
                                                                                                                                                                                                                                                                                                 (=
                                                                                                                                                                                                                                                                                                  (Prims.op_Division
                                                                                                                                                                                                                                                                                                   (Prims.op_Addition
                                                                                                                                                                                                                                                                                                    @x0
                                                                                                                                                                                                                                                                                                    (Prims.op_Multiply
                                                                                                                                                                                                                                                                                                     @x1
                                                                                                                                                                                                                                                                                                     @x2))
                                                                                                                                                                                                                                                                                                   @x2)
                                                                                                                                                                                                                                                                                                  @x86)
                                                                                                                                                                                                                                                                                                 ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(234,23-234,24)
                                                                                                                                                                                                                                                                                                 (>
                                                                                                                                                                                                                                                                                                  (BoxInt_proj_0
                                                                                                                                                                                                                                                                                                   @x2)
                                                                                                                                                                                                                                                                                                  (BoxInt_proj_0
                                                                                                                                                                                                                                                                                                   (BoxInt
                                                                                                                                                                                                                                                                                                    0))))
                                                                                                                                                                                                                                                                                                ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(234,23-234,24)
                                                                                                                                                                                                                                                                                                (or
                                                                                                                                                                                                                                                                                                 label_28
                                                                                                                                                                                                                                                                                                 ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(234,23-234,24)
                                                                                                                                                                                                                                                                                                 (not
                                                                                                                                                                                                                                                                                                  (=
                                                                                                                                                                                                                                                                                                   @x2
                                                                                                                                                                                                                                                                                                   (BoxInt
                                                                                                                                                                                                                                                                                                    0)))))
                                                                                                                                                                                                                                                                                               :qid
                                                                                                                                                                                                                                                                                                @query.85)))
                                                                                                                                                                                                                                                                                            :qid
                                                                                                                                                                                                                                                                                             @query.84))))
                                                                                                                                                                                                                                                                                        :qid
                                                                                                                                                                                                                                                                                         @query.83))
                                                                                                                                                                                                                                                                                      ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                                                                                      (forall
                                                                                                                                                                                                                                                                                        ((@x84
                                                                                                                                                                                                                                                                                          Term))
                                                                                                                                                                                                                                                                                       (! (implies
                                                                                                                                                                                                                                                                                         (HasType
                                                                                                                                                                                                                                                                                          @x84
                                                                                                                                                                                                                                                                                          (Tm_arrow_7da6e99647c74ea5e118aa85d2042f39
                                                                                                                                                                                                                                                                                           @x1
                                                                                                                                                                                                                                                                                           @x0
                                                                                                                                                                                                                                                                                           @x2))
                                                                                                                                                                                                                                                                                         ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                                                                                         (forall
                                                                                                                                                                                                                                                                                           ((@x85
                                                                                                                                                                                                                                                                                             Term))
                                                                                                                                                                                                                                                                                          (! (implies
                                                                                                                                                                                                                                                                                            (HasType
                                                                                                                                                                                                                                                                                             @x85
                                                                                                                                                                                                                                                                                             Prims.unit)
                                                                                                                                                                                                                                                                                            ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(235,9-235,53)
                                                                                                                                                                                                                                                                                            (and
                                                                                                                                                                                                                                                                                             (implies
                                                                                                                                                                                                                                                                                              ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(235,45-235,46)
                                                                                                                                                                                                                                                                                              (>
                                                                                                                                                                                                                                                                                               (BoxInt_proj_0
                                                                                                                                                                                                                                                                                                @x2)
                                                                                                                                                                                                                                                                                               (BoxInt_proj_0
                                                                                                                                                                                                                                                                                                (BoxInt
                                                                                                                                                                                                                                                                                                 0)))
                                                                                                                                                                                                                                                                                              ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(235,45-235,46)
                                                                                                                                                                                                                                                                                              (or
                                                                                                                                                                                                                                                                                               label_29
                                                                                                                                                                                                                                                                                               ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(235,45-235,46)
                                                                                                                                                                                                                                                                                               (not
                                                                                                                                                                                                                                                                                                (=
                                                                                                                                                                                                                                                                                                 @x2
                                                                                                                                                                                                                                                                                                 (BoxInt
                                                                                                                                                                                                                                                                                                  0)))))
                                                                                                                                                                                                                                                                                             ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(235,9-235,53)
                                                                                                                                                                                                                                                                                             (forall
                                                                                                                                                                                                                                                                                               ((@x86
                                                                                                                                                                                                                                                                                                 Term))
                                                                                                                                                                                                                                                                                              (! (implies
                                                                                                                                                                                                                                                                                                (and
                                                                                                                                                                                                                                                                                                 (HasType
                                                                                                                                                                                                                                                                                                  @x86
                                                                                                                                                                                                                                                                                                  Prims.pos)
                                                                                                                                                                                                                                                                                                 ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(235,9-235,53)
                                                                                                                                                                                                                                                                                                 (=
                                                                                                                                                                                                                                                                                                  @x2
                                                                                                                                                                                                                                                                                                  @x86))
                                                                                                                                                                                                                                                                                                ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(235,9-235,53)
                                                                                                                                                                                                                                                                                                (forall
                                                                                                                                                                                                                                                                                                  ((@x87
                                                                                                                                                                                                                                                                                                    Term))
                                                                                                                                                                                                                                                                                                 (! (implies
                                                                                                                                                                                                                                                                                                   (and
                                                                                                                                                                                                                                                                                                    (HasType
                                                                                                                                                                                                                                                                                                     @x87
                                                                                                                                                                                                                                                                                                     Prims.int)
                                                                                                                                                                                                                                                                                                    ;; def=FStar.Math.Lemmas.fsti(103,39-103,40); use=FStar.Math.Lemmas.fst(235,9-235,53)
                                                                                                                                                                                                                                                                                                    (=
                                                                                                                                                                                                                                                                                                     (Prims.op_Division
                                                                                                                                                                                                                                                                                                      (Prims.op_Addition
                                                                                                                                                                                                                                                                                                       @x0
                                                                                                                                                                                                                                                                                                       (Prims.op_Multiply
                                                                                                                                                                                                                                                                                                        @x1
                                                                                                                                                                                                                                                                                                        @x2))
                                                                                                                                                                                                                                                                                                      @x2)
                                                                                                                                                                                                                                                                                                     @x87))
                                                                                                                                                                                                                                                                                                   ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(235,9-235,53)
                                                                                                                                                                                                                                                                                                   (and
                                                                                                                                                                                                                                                                                                    (implies
                                                                                                                                                                                                                                                                                                     ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(235,51-235,52)
                                                                                                                                                                                                                                                                                                     (>
                                                                                                                                                                                                                                                                                                      (BoxInt_proj_0
                                                                                                                                                                                                                                                                                                       @x2)
                                                                                                                                                                                                                                                                                                      (BoxInt_proj_0
                                                                                                                                                                                                                                                                                                       (BoxInt
                                                                                                                                                                                                                                                                                                        0)))
                                                                                                                                                                                                                                                                                                     ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(235,51-235,52)
                                                                                                                                                                                                                                                                                                     (or
                                                                                                                                                                                                                                                                                                      label_30
                                                                                                                                                                                                                                                                                                      ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(235,51-235,52)
                                                                                                                                                                                                                                                                                                      (not
                                                                                                                                                                                                                                                                                                       (=
                                                                                                                                                                                                                                                                                                        @x2
                                                                                                                                                                                                                                                                                                        (BoxInt
                                                                                                                                                                                                                                                                                                         0)))))
                                                                                                                                                                                                                                                                                                    ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(235,9-235,53)
                                                                                                                                                                                                                                                                                                    (forall
                                                                                                                                                                                                                                                                                                      ((@x88
                                                                                                                                                                                                                                                                                                        Term))
                                                                                                                                                                                                                                                                                                     (! (implies
                                                                                                                                                                                                                                                                                                       (and
                                                                                                                                                                                                                                                                                                        (HasType
                                                                                                                                                                                                                                                                                                         @x88
                                                                                                                                                                                                                                                                                                         Prims.pos)
                                                                                                                                                                                                                                                                                                        ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(235,9-235,53)
                                                                                                                                                                                                                                                                                                        (=
                                                                                                                                                                                                                                                                                                         @x2
                                                                                                                                                                                                                                                                                                         @x88))
                                                                                                                                                                                                                                                                                                       ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(235,9-235,53)
                                                                                                                                                                                                                                                                                                       (forall
                                                                                                                                                                                                                                                                                                         ((@x89
                                                                                                                                                                                                                                                                                                           Term))
                                                                                                                                                                                                                                                                                                        (! (implies
                                                                                                                                                                                                                                                                                                          (and
                                                                                                                                                                                                                                                                                                           (HasType
                                                                                                                                                                                                                                                                                                            @x89
                                                                                                                                                                                                                                                                                                            Prims.int)
                                                                                                                                                                                                                                                                                                           ;; def=FStar.Math.Lemmas.fsti(103,48-103,49); use=FStar.Math.Lemmas.fst(235,9-235,53)
                                                                                                                                                                                                                                                                                                           (=
                                                                                                                                                                                                                                                                                                            (Prims.op_Division
                                                                                                                                                                                                                                                                                                             @x0
                                                                                                                                                                                                                                                                                                             @x2)
                                                                                                                                                                                                                                                                                                            @x89))
                                                                                                                                                                                                                                                                                                          ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(235,9-235,33)
                                                                                                                                                                                                                                                                                                          (forall
                                                                                                                                                                                                                                                                                                            ((@x90
                                                                                                                                                                                                                                                                                                              Term))
                                                                                                                                                                                                                                                                                                           (! (implies
                                                                                                                                                                                                                                                                                                             (and
                                                                                                                                                                                                                                                                                                              (HasType
                                                                                                                                                                                                                                                                                                               @x90
                                                                                                                                                                                                                                                                                                               Prims.unit)
                                                                                                                                                                                                                                                                                                              ;; def=FStar.Math.Lemmas.fsti(104,8-104,39); use=FStar.Math.Lemmas.fst(235,9-235,33)
                                                                                                                                                                                                                                                                                                              (=
                                                                                                                                                                                                                                                                                                               (Prims.op_Multiply
                                                                                                                                                                                                                                                                                                                @x2
                                                                                                                                                                                                                                                                                                                (Prims.op_Subtraction
                                                                                                                                                                                                                                                                                                                 (Prims.op_Division
                                                                                                                                                                                                                                                                                                                  (Prims.op_Addition
                                                                                                                                                                                                                                                                                                                   @x0
                                                                                                                                                                                                                                                                                                                   (Prims.op_Multiply
                                                                                                                                                                                                                                                                                                                    @x1
                                                                                                                                                                                                                                                                                                                    @x2))
                                                                                                                                                                                                                                                                                                                  @x2)
                                                                                                                                                                                                                                                                                                                 (Prims.op_Division
                                                                                                                                                                                                                                                                                                                  @x0
                                                                                                                                                                                                                                                                                                                  @x2)))
                                                                                                                                                                                                                                                                                                               (Prims.op_Subtraction
                                                                                                                                                                                                                                                                                                                (Prims.op_Multiply
                                                                                                                                                                                                                                                                                                                 @x2
                                                                                                                                                                                                                                                                                                                 (Prims.op_Division
                                                                                                                                                                                                                                                                                                                  (Prims.op_Addition
                                                                                                                                                                                                                                                                                                                   @x0
                                                                                                                                                                                                                                                                                                                   (Prims.op_Multiply
                                                                                                                                                                                                                                                                                                                    @x1
                                                                                                                                                                                                                                                                                                                    @x2))
                                                                                                                                                                                                                                                                                                                  @x2))
                                                                                                                                                                                                                                                                                                                (Prims.op_Multiply
                                                                                                                                                                                                                                                                                                                 @x2
                                                                                                                                                                                                                                                                                                                 (Prims.op_Division
                                                                                                                                                                                                                                                                                                                  @x0
                                                                                                                                                                                                                                                                                                                  @x2)))))
                                                                                                                                                                                                                                                                                                             ;; def=FStar.Math.Lemmas.fst(235,4-235,6); use=FStar.Math.Lemmas.fst(235,9-235,53)
                                                                                                                                                                                                                                                                                                             (or
                                                                                                                                                                                                                                                                                                              label_31
                                                                                                                                                                                                                                                                                                              ;; def=FStar.Math.Lemmas.fst(235,4-235,6); use=FStar.Math.Lemmas.fst(235,9-235,53)
                                                                                                                                                                                                                                                                                                              (=
                                                                                                                                                                                                                                                                                                               (Prims.op_Multiply
                                                                                                                                                                                                                                                                                                                @x2
                                                                                                                                                                                                                                                                                                                (Prims.op_Subtraction
                                                                                                                                                                                                                                                                                                                 (Prims.op_Division
                                                                                                                                                                                                                                                                                                                  (Prims.op_Addition
                                                                                                                                                                                                                                                                                                                   @x0
                                                                                                                                                                                                                                                                                                                   (Prims.op_Multiply
                                                                                                                                                                                                                                                                                                                    @x1
                                                                                                                                                                                                                                                                                                                    @x2))
                                                                                                                                                                                                                                                                                                                  @x2)
                                                                                                                                                                                                                                                                                                                 (Prims.op_Division
                                                                                                                                                                                                                                                                                                                  @x0
                                                                                                                                                                                                                                                                                                                  @x2)))
                                                                                                                                                                                                                                                                                                               (Prims.op_Subtraction
                                                                                                                                                                                                                                                                                                                (Prims.op_Multiply
                                                                                                                                                                                                                                                                                                                 @x2
                                                                                                                                                                                                                                                                                                                 (Prims.op_Division
                                                                                                                                                                                                                                                                                                                  (Prims.op_Addition
                                                                                                                                                                                                                                                                                                                   @x0
                                                                                                                                                                                                                                                                                                                   (Prims.op_Multiply
                                                                                                                                                                                                                                                                                                                    @x1
                                                                                                                                                                                                                                                                                                                    @x2))
                                                                                                                                                                                                                                                                                                                  @x2))
                                                                                                                                                                                                                                                                                                                (Prims.op_Multiply
                                                                                                                                                                                                                                                                                                                 @x2
                                                                                                                                                                                                                                                                                                                 (Prims.op_Division
                                                                                                                                                                                                                                                                                                                  @x0
                                                                                                                                                                                                                                                                                                                  @x2))))))
                                                                                                                                                                                                                                                                                                            :qid
                                                                                                                                                                                                                                                                                                             @query.92)))
                                                                                                                                                                                                                                                                                                         :qid
                                                                                                                                                                                                                                                                                                          @query.91)))
                                                                                                                                                                                                                                                                                                      :qid
                                                                                                                                                                                                                                                                                                       @query.90))))
                                                                                                                                                                                                                                                                                                  :qid
                                                                                                                                                                                                                                                                                                   @query.89)))
                                                                                                                                                                                                                                                                                               :qid
                                                                                                                                                                                                                                                                                                @query.88))))
                                                                                                                                                                                                                                                                                           :qid
                                                                                                                                                                                                                                                                                            @query.87)))
                                                                                                                                                                                                                                                                                        :qid
                                                                                                                                                                                                                                                                                         @query.86))))
                                                                                                                                                                                                                                                                                    :qid
                                                                                                                                                                                                                                                                                     @query.82)))
                                                                                                                                                                                                                                                                                 :qid
                                                                                                                                                                                                                                                                                  @query.81)))
                                                                                                                                                                                                                                                                              :qid
                                                                                                                                                                                                                                                                               @query.80)))
                                                                                                                                                                                                                                                                           :qid
                                                                                                                                                                                                                                                                            @query.79))))
                                                                                                                                                                                                                                                                       :qid
                                                                                                                                                                                                                                                                        @query.78)))
                                                                                                                                                                                                                                                                    :qid
                                                                                                                                                                                                                                                                     @query.77)))
                                                                                                                                                                                                                                                                 :qid
                                                                                                                                                                                                                                                                  @query.76))))
                                                                                                                                                                                                                                                             :qid
                                                                                                                                                                                                                                                              @query.75)))
                                                                                                                                                                                                                                                          :qid
                                                                                                                                                                                                                                                           @query.74)))
                                                                                                                                                                                                                                                       :qid
                                                                                                                                                                                                                                                        @query.73)))
                                                                                                                                                                                                                                                    :qid
                                                                                                                                                                                                                                                     @query.72))))
                                                                                                                                                                                                                                                :qid
                                                                                                                                                                                                                                                 @query.71)))
                                                                                                                                                                                                                                             :qid
                                                                                                                                                                                                                                              @query.70))))
                                                                                                                                                                                                                                         :qid
                                                                                                                                                                                                                                          @query.69)))
                                                                                                                                                                                                                                      :qid
                                                                                                                                                                                                                                       @query.68)))
                                                                                                                                                                                                                                   :qid
                                                                                                                                                                                                                                    @query.67)))
                                                                                                                                                                                                                                :qid
                                                                                                                                                                                                                                 @query.66))))
                                                                                                                                                                                                                            :qid
                                                                                                                                                                                                                             @query.65)))
                                                                                                                                                                                                                         :qid
                                                                                                                                                                                                                          @query.64))))
                                                                                                                                                                                                                     :qid
                                                                                                                                                                                                                      @query.63))
                                                                                                                                                                                                                   ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                   (forall
                                                                                                                                                                                                                     ((@x64
                                                                                                                                                                                                                       Term))
                                                                                                                                                                                                                    (! (implies
                                                                                                                                                                                                                      (HasType
                                                                                                                                                                                                                       @x64
                                                                                                                                                                                                                       (Tm_arrow_0cb77c3283d06b401322bff47481f095
                                                                                                                                                                                                                        @x1
                                                                                                                                                                                                                        @x0
                                                                                                                                                                                                                        @x2))
                                                                                                                                                                                                                      ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                                                                                      (forall
                                                                                                                                                                                                                        ((@x65
                                                                                                                                                                                                                          Term))
                                                                                                                                                                                                                       (! (implies
                                                                                                                                                                                                                         (HasType
                                                                                                                                                                                                                          @x65
                                                                                                                                                                                                                          Prims.unit)
                                                                                                                                                                                                                         ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(237,9-237,51)
                                                                                                                                                                                                                         (and
                                                                                                                                                                                                                          (implies
                                                                                                                                                                                                                           ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(237,31-237,32)
                                                                                                                                                                                                                           (>
                                                                                                                                                                                                                            (BoxInt_proj_0
                                                                                                                                                                                                                             @x2)
                                                                                                                                                                                                                            (BoxInt_proj_0
                                                                                                                                                                                                                             (BoxInt
                                                                                                                                                                                                                              0)))
                                                                                                                                                                                                                           ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(237,31-237,32)
                                                                                                                                                                                                                           (or
                                                                                                                                                                                                                            label_32
                                                                                                                                                                                                                            ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(237,31-237,32)
                                                                                                                                                                                                                            (not
                                                                                                                                                                                                                             (=
                                                                                                                                                                                                                              @x2
                                                                                                                                                                                                                              (BoxInt
                                                                                                                                                                                                                               0)))))
                                                                                                                                                                                                                          ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(237,9-237,51)
                                                                                                                                                                                                                          (forall
                                                                                                                                                                                                                            ((@x66
                                                                                                                                                                                                                              Term))
                                                                                                                                                                                                                           (! (implies
                                                                                                                                                                                                                             (and
                                                                                                                                                                                                                              (HasType
                                                                                                                                                                                                                               @x66
                                                                                                                                                                                                                               Prims.pos)
                                                                                                                                                                                                                              ;; def=FStar.Math.Lemmas.fsti(170,28-170,29); use=FStar.Math.Lemmas.fst(237,9-237,51)
                                                                                                                                                                                                                              (=
                                                                                                                                                                                                                               @x2
                                                                                                                                                                                                                               @x66))
                                                                                                                                                                                                                             ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(237,9-237,22)
                                                                                                                                                                                                                             (forall
                                                                                                                                                                                                                               ((@x67
                                                                                                                                                                                                                                 Term))
                                                                                                                                                                                                                              (! (implies
                                                                                                                                                                                                                                (and
                                                                                                                                                                                                                                 (HasType
                                                                                                                                                                                                                                  @x67
                                                                                                                                                                                                                                  Prims.unit)
                                                                                                                                                                                                                                 ;; def=FStar.Math.Lemmas.fsti(170,47-170,72); use=FStar.Math.Lemmas.fst(237,9-237,22)
                                                                                                                                                                                                                                 (=
                                                                                                                                                                                                                                  (Prims.op_Addition
                                                                                                                                                                                                                                   @x0
                                                                                                                                                                                                                                   (Prims.op_Multiply
                                                                                                                                                                                                                                    @x1
                                                                                                                                                                                                                                    @x2))
                                                                                                                                                                                                                                  (Prims.op_Addition
                                                                                                                                                                                                                                   (Prims.op_Multiply
                                                                                                                                                                                                                                    @x2
                                                                                                                                                                                                                                    (Prims.op_Division
                                                                                                                                                                                                                                     (Prims.op_Addition
                                                                                                                                                                                                                                      @x0
                                                                                                                                                                                                                                      (Prims.op_Multiply
                                                                                                                                                                                                                                       @x1
                                                                                                                                                                                                                                       @x2))
                                                                                                                                                                                                                                     @x2))
                                                                                                                                                                                                                                   (Prims.op_Modulus
                                                                                                                                                                                                                                    (Prims.op_Addition
                                                                                                                                                                                                                                     @x0
                                                                                                                                                                                                                                     (Prims.op_Multiply
                                                                                                                                                                                                                                      @x1
                                                                                                                                                                                                                                      @x2))
                                                                                                                                                                                                                                    @x2))))
                                                                                                                                                                                                                                ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(237,9-237,51)
                                                                                                                                                                                                                                (and
                                                                                                                                                                                                                                 (implies
                                                                                                                                                                                                                                  ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(237,50-237,51)
                                                                                                                                                                                                                                  (>
                                                                                                                                                                                                                                   (BoxInt_proj_0
                                                                                                                                                                                                                                    @x2)
                                                                                                                                                                                                                                   (BoxInt_proj_0
                                                                                                                                                                                                                                    (BoxInt
                                                                                                                                                                                                                                     0)))
                                                                                                                                                                                                                                  ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(237,50-237,51)
                                                                                                                                                                                                                                  (or
                                                                                                                                                                                                                                   label_33
                                                                                                                                                                                                                                   ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(237,50-237,51)
                                                                                                                                                                                                                                   (not
                                                                                                                                                                                                                                    (=
                                                                                                                                                                                                                                     @x2
                                                                                                                                                                                                                                     (BoxInt
                                                                                                                                                                                                                                      0)))))
                                                                                                                                                                                                                                 ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(237,9-237,51)
                                                                                                                                                                                                                                 (forall
                                                                                                                                                                                                                                   ((@x68
                                                                                                                                                                                                                                     Term))
                                                                                                                                                                                                                                  (! (implies
                                                                                                                                                                                                                                    (and
                                                                                                                                                                                                                                     (HasType
                                                                                                                                                                                                                                      @x68
                                                                                                                                                                                                                                      Prims.pos)
                                                                                                                                                                                                                                     ;; def=FStar.Math.Lemmas.fsti(170,28-170,29); use=FStar.Math.Lemmas.fst(237,9-237,51)
                                                                                                                                                                                                                                     (=
                                                                                                                                                                                                                                      @x2
                                                                                                                                                                                                                                      @x68))
                                                                                                                                                                                                                                    ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(237,34-237,47)
                                                                                                                                                                                                                                    (forall
                                                                                                                                                                                                                                      ((@x69
                                                                                                                                                                                                                                        Term))
                                                                                                                                                                                                                                     (! (implies
                                                                                                                                                                                                                                       (and
                                                                                                                                                                                                                                        (HasType
                                                                                                                                                                                                                                         @x69
                                                                                                                                                                                                                                         Prims.unit)
                                                                                                                                                                                                                                        ;; def=FStar.Math.Lemmas.fsti(170,47-170,72); use=FStar.Math.Lemmas.fst(237,34-237,47)
                                                                                                                                                                                                                                        (=
                                                                                                                                                                                                                                         @x0
                                                                                                                                                                                                                                         (Prims.op_Addition
                                                                                                                                                                                                                                          (Prims.op_Multiply
                                                                                                                                                                                                                                           @x2
                                                                                                                                                                                                                                           (Prims.op_Division
                                                                                                                                                                                                                                            @x0
                                                                                                                                                                                                                                            @x2))
                                                                                                                                                                                                                                          (Prims.op_Modulus
                                                                                                                                                                                                                                           @x0
                                                                                                                                                                                                                                           @x2))))
                                                                                                                                                                                                                                       ;; def=FStar.Math.Lemmas.fst(237,4-237,6); use=FStar.Math.Lemmas.fst(237,34-237,51)
                                                                                                                                                                                                                                       (or
                                                                                                                                                                                                                                        label_34
                                                                                                                                                                                                                                        ;; def=FStar.Math.Lemmas.fst(237,4-237,6); use=FStar.Math.Lemmas.fst(237,34-237,51)
                                                                                                                                                                                                                                        (=
                                                                                                                                                                                                                                         (Prims.op_Subtraction
                                                                                                                                                                                                                                          (Prims.op_Multiply
                                                                                                                                                                                                                                           @x2
                                                                                                                                                                                                                                           (Prims.op_Division
                                                                                                                                                                                                                                            (Prims.op_Addition
                                                                                                                                                                                                                                             @x0
                                                                                                                                                                                                                                             (Prims.op_Multiply
                                                                                                                                                                                                                                              @x1
                                                                                                                                                                                                                                              @x2))
                                                                                                                                                                                                                                            @x2))
                                                                                                                                                                                                                                          (Prims.op_Multiply
                                                                                                                                                                                                                                           @x2
                                                                                                                                                                                                                                           (Prims.op_Division
                                                                                                                                                                                                                                            @x0
                                                                                                                                                                                                                                            @x2)))
                                                                                                                                                                                                                                         (Prims.op_Subtraction
                                                                                                                                                                                                                                          (Prims.op_Subtraction
                                                                                                                                                                                                                                           (Prims.op_Addition
                                                                                                                                                                                                                                            @x0
                                                                                                                                                                                                                                            (Prims.op_Multiply
                                                                                                                                                                                                                                             @x1
                                                                                                                                                                                                                                             @x2))
                                                                                                                                                                                                                                           (Prims.op_Modulus
                                                                                                                                                                                                                                            (Prims.op_Addition
                                                                                                                                                                                                                                             @x0
                                                                                                                                                                                                                                             (Prims.op_Multiply
                                                                                                                                                                                                                                              @x1
                                                                                                                                                                                                                                              @x2))
                                                                                                                                                                                                                                            @x2))
                                                                                                                                                                                                                                          (Prims.op_Subtraction
                                                                                                                                                                                                                                           @x0
                                                                                                                                                                                                                                           (Prims.op_Modulus
                                                                                                                                                                                                                                            @x0
                                                                                                                                                                                                                                            @x2))))))
                                                                                                                                                                                                                                      :qid
                                                                                                                                                                                                                                       @query.98)))
                                                                                                                                                                                                                                   :qid
                                                                                                                                                                                                                                    @query.97))))
                                                                                                                                                                                                                               :qid
                                                                                                                                                                                                                                @query.96)))
                                                                                                                                                                                                                            :qid
                                                                                                                                                                                                                             @query.95))))
                                                                                                                                                                                                                        :qid
                                                                                                                                                                                                                         @query.94)))
                                                                                                                                                                                                                     :qid
                                                                                                                                                                                                                      @query.93))))
                                                                                                                                                                                                                 :qid
                                                                                                                                                                                                                  @query.62)))
                                                                                                                                                                                                              :qid
                                                                                                                                                                                                               @query.61)))
                                                                                                                                                                                                           :qid
                                                                                                                                                                                                            @query.60)))
                                                                                                                                                                                                        :qid
                                                                                                                                                                                                         @query.59))))
                                                                                                                                                                                                    :qid
                                                                                                                                                                                                     @query.58)))
                                                                                                                                                                                                 :qid
                                                                                                                                                                                                  @query.57)))
                                                                                                                                                                                              :qid
                                                                                                                                                                                               @query.56))))
                                                                                                                                                                                          :qid
                                                                                                                                                                                           @query.55)))
                                                                                                                                                                                       :qid
                                                                                                                                                                                        @query.54)))
                                                                                                                                                                                    :qid
                                                                                                                                                                                     @query.53)))
                                                                                                                                                                                 :qid
                                                                                                                                                                                  @query.52))))
                                                                                                                                                                             :qid
                                                                                                                                                                              @query.51)))
                                                                                                                                                                          :qid
                                                                                                                                                                           @query.50)))
                                                                                                                                                                       :qid
                                                                                                                                                                        @query.49))))
                                                                                                                                                                   :qid
                                                                                                                                                                    @query.48)))
                                                                                                                                                                :qid
                                                                                                                                                                 @query.47)))
                                                                                                                                                             :qid
                                                                                                                                                              @query.46)))
                                                                                                                                                          :qid
                                                                                                                                                           @query.45))))
                                                                                                                                                      :qid
                                                                                                                                                       @query.44)))
                                                                                                                                                   :qid
                                                                                                                                                    @query.43))))
                                                                                                                                               :qid
                                                                                                                                                @query.42))
                                                                                                                                             ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                             (forall
                                                                                                                                               ((@x43
                                                                                                                                                 Term))
                                                                                                                                              (! (implies
                                                                                                                                                (HasType
                                                                                                                                                 @x43
                                                                                                                                                 (Tm_arrow_5191dce4a817d3609230f518fb68cf06
                                                                                                                                                  @x1
                                                                                                                                                  @x0
                                                                                                                                                  @x2))
                                                                                                                                                ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                                                                                                (forall
                                                                                                                                                  ((@x44
                                                                                                                                                    Term))
                                                                                                                                                 (! (implies
                                                                                                                                                   (HasType
                                                                                                                                                    @x44
                                                                                                                                                    Prims.unit)
                                                                                                                                                   ;; def=FStar.Math.Lemmas.fst(239,4-239,6); use=FStar.Math.Lemmas.fst(239,7-239,9)
                                                                                                                                                   (or
                                                                                                                                                    label_35
                                                                                                                                                    ;; def=FStar.Math.Lemmas.fst(239,4-239,6); use=FStar.Math.Lemmas.fst(239,7-239,9)
                                                                                                                                                    (=
                                                                                                                                                     (Prims.op_Subtraction
                                                                                                                                                      (Prims.op_Subtraction
                                                                                                                                                       (Prims.op_Addition
                                                                                                                                                        @x0
                                                                                                                                                        (Prims.op_Multiply
                                                                                                                                                         @x1
                                                                                                                                                         @x2))
                                                                                                                                                       (Prims.op_Modulus
                                                                                                                                                        (Prims.op_Addition
                                                                                                                                                         @x0
                                                                                                                                                         (Prims.op_Multiply
                                                                                                                                                          @x1
                                                                                                                                                          @x2))
                                                                                                                                                        @x2))
                                                                                                                                                      (Prims.op_Subtraction
                                                                                                                                                       @x0
                                                                                                                                                       (Prims.op_Modulus
                                                                                                                                                        @x0
                                                                                                                                                        @x2)))
                                                                                                                                                     (Prims.op_Addition
                                                                                                                                                      (Prims.op_Subtraction
                                                                                                                                                       (Prims.op_Multiply
                                                                                                                                                        @x1
                                                                                                                                                        @x2)
                                                                                                                                                       (Prims.op_Modulus
                                                                                                                                                        (Prims.op_Addition
                                                                                                                                                         @x0
                                                                                                                                                         (Prims.op_Multiply
                                                                                                                                                          @x1
                                                                                                                                                          @x2))
                                                                                                                                                        @x2))
                                                                                                                                                      (Prims.op_Modulus
                                                                                                                                                       @x0
                                                                                                                                                       @x2)))))
                                                                                                                                                  :qid
                                                                                                                                                   @query.100)))
                                                                                                                                               :qid
                                                                                                                                                @query.99))))
                                                                                                                                           :qid
                                                                                                                                            @query.41)))
                                                                                                                                        :qid
                                                                                                                                         @query.40)))
                                                                                                                                     :qid
                                                                                                                                      @query.39))))
                                                                                                                                 :qid
                                                                                                                                  @query.38)))
                                                                                                                              :qid
                                                                                                                               @query.37)))
                                                                                                                           :qid
                                                                                                                            @query.36))))
                                                                                                                       :qid
                                                                                                                        @query.35)))
                                                                                                                    :qid
                                                                                                                     @query.34)))
                                                                                                                 :qid
                                                                                                                  @query.33)))
                                                                                                              :qid
                                                                                                               @query.32))))
                                                                                                          :qid
                                                                                                           @query.31)))
                                                                                                       :qid
                                                                                                        @query.30)))
                                                                                                    :qid
                                                                                                     @query.29))))
                                                                                                :qid
                                                                                                 @query.28)))
                                                                                             :qid
                                                                                              @query.27)))
                                                                                          :qid
                                                                                           @query.26)))
                                                                                       :qid
                                                                                        @query.25))))
                                                                                   :qid @query.24)))
                                                                                :qid @query.23))))
                                                                            :qid @query.22))
                                                                          ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                          (forall ((@x23 Term))
                                                                           (! (implies
                                                                             (HasType
                                                                              @x23
                                                                              (Tm_arrow_871f680f33cdf446c9113d272d05a31b
                                                                               @x1
                                                                               @x0
                                                                               @x2))
                                                                             ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-243,3)
                                                                             (forall ((@x24 Term))
                                                                              (! (implies
                                                                                (HasType
                                                                                 @x24
                                                                                 Prims.unit)
                                                                                ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(241,9-241,23)
                                                                                (forall
                                                                                  ((@x25 Term))
                                                                                 (! (implies
                                                                                   (and
                                                                                    (HasType
                                                                                     @x25
                                                                                     Prims.unit)
                                                                                    ;; def=FStar.Math.Lemmas.fsti(194,51-194,76); use=FStar.Math.Lemmas.fst(241,9-241,23)
                                                                                    (=
                                                                                     (Prims.op_Modulus
                                                                                      (Prims.op_Addition
                                                                                       @x0
                                                                                       (Prims.op_Multiply
                                                                                        @x1
                                                                                        @x2))
                                                                                      @x2)
                                                                                     (Prims.op_Modulus
                                                                                      @x0
                                                                                      @x2)))
                                                                                   ;; def=FStar.Math.Lemmas.fst(241,4-241,6); use=FStar.Math.Lemmas.fst(241,9-241,29)
                                                                                   (or
                                                                                    label_36
                                                                                    ;; def=FStar.Math.Lemmas.fst(241,4-241,6); use=FStar.Math.Lemmas.fst(241,9-241,29)
                                                                                    (=
                                                                                     (Prims.op_Addition
                                                                                      (Prims.op_Subtraction
                                                                                       (Prims.op_Multiply
                                                                                        @x1
                                                                                        @x2)
                                                                                       (Prims.op_Modulus
                                                                                        (Prims.op_Addition
                                                                                         @x0
                                                                                         (Prims.op_Multiply
                                                                                          @x1
                                                                                          @x2))
                                                                                        @x2))
                                                                                      (Prims.op_Modulus
                                                                                       @x0
                                                                                       @x2))
                                                                                     (Prims.op_Multiply
                                                                                      @x1
                                                                                      @x2))))
                                                                                  :qid @query.103)))
                                                                               :qid @query.102)))
                                                                            :qid @query.101))))
                                                                        :qid @query.21)))
                                                                     :qid @query.20)))
                                                                  :qid @query.19))))
                                                              :qid @query.18)))
                                                           :qid @query.17)))
                                                        :qid @query.16))))
                                                    :qid @query.15)))
                                                 :qid @query.14)))
                                              :qid @query.13)))
                                           :qid @query.12))))
                                       :qid @query.11)))
                                    :qid @query.10))))
                                :qid @query.9))
                              ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-244,40)
                              (forall ((@x10 Term))
                               (! (implies
                                 (HasType
                                  @x10
                                  (Tm_arrow_07970ed8a0a6d06d9714db7437f3dd02 @x1 @x0 @x2))
                                 ;; def=Prims.fst(449,29-449,97); use=FStar.Math.Lemmas.fst(233,2-244,40)
                                 (and
                                  ;; def=FStar.Calc.fsti(47,4-47,55); use=FStar.Calc.fsti(47,4-47,55)
                                  (forall ((@x11 Term) (@x12 Term))
                                   (! (implies
                                     (and
                                      (HasType @x11 Prims.int)
                                      (HasType @x12 Prims.int)
                                      ;; def=FStar.Calc.fsti(42,16-42,65); use=FStar.Calc.fsti(42,16-42,65)
                                      (exists ((@x13 Term))
                                       (! (and
                                         (HasType @x13 Prims.int)
                                         ;; def=FStar.Calc.fsti(42,16-42,65); use=FStar.Calc.fsti(42,16-42,65)
                                         (exists ((@x14 Term))
                                          (! (and
                                            (HasType @x14 Prims.int)
                                            ;; def=FStar.Calc.fsti(42,16-42,65); use=FStar.Calc.fsti(42,16-42,65)
                                            (exists ((@x15 Term))
                                             (! (and
                                               (HasType @x15 Prims.int)
                                               ;; def=FStar.Calc.fsti(42,16-42,65); use=FStar.Calc.fsti(42,16-42,65)
                                               (exists ((@x16 Term))
                                                (! (and
                                                  (HasType @x16 Prims.int)
                                                  ;; def=FStar.Calc.fsti(40,12-40,18); use=FStar.Calc.fsti(40,12-40,18)
                                                  (= @x11 @x16)
                                                  ;; def=FStar.Math.Lemmas.fst(235,4-235,6); use=FStar.Math.Lemmas.fst(233,2-244,40)
                                                  (= @x16 @x15))
                                                 :qid @query.109))
                                               ;; def=FStar.Math.Lemmas.fst(237,4-237,6); use=FStar.Math.Lemmas.fst(233,2-244,40)
                                               (= @x15 @x14))
                                              :qid @query.108))
                                            ;; def=FStar.Math.Lemmas.fst(239,4-239,6); use=FStar.Math.Lemmas.fst(233,2-244,40)
                                            (= @x14 @x13))
                                           :qid @query.107))
                                         ;; def=FStar.Math.Lemmas.fst(241,4-241,6); use=FStar.Math.Lemmas.fst(233,2-244,40)
                                         (= @x13 @x12))
                                        :qid @query.106)))
                                     ;; def=FStar.Math.Lemmas.fst(233,7-233,11); use=FStar.Math.Lemmas.fst(233,2-244,40)
                                     (or
                                      label_37
                                      ;; def=FStar.Math.Lemmas.fst(233,7-233,11); use=FStar.Math.Lemmas.fst(233,2-244,40)
                                      (= @x11 @x12)))
                                    :qid @query.105))
                                  ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(233,2-244,40)
                                  (forall ((@x11 Term))
                                   (! (implies
                                     (and
                                      (HasType @x11 Prims.unit)
                                      ;; def=FStar.Math.Lemmas.fst(233,7-233,11); use=FStar.Math.Lemmas.fst(233,2-244,40)
                                      (=
                                       (Prims.op_Multiply
                                        @x2
                                        (Prims.op_Subtraction
                                         (Prims.op_Division
                                          (Prims.op_Addition @x0 (Prims.op_Multiply @x1 @x2))
                                          @x2)
                                         (Prims.op_Division @x0 @x2)))
                                       (Prims.op_Multiply @x1 @x2)))
                                     ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(233,2-244,40)
                                     (and
                                      (implies
                                       ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(244,28-244,29)
                                       (> (BoxInt_proj_0 @x2) (BoxInt_proj_0 (BoxInt 0)))
                                       ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(244,28-244,29)
                                       (or
                                        label_38
                                        ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(244,28-244,29)
                                        (not (= @x2 (BoxInt 0)))))
                                      ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-244,40)
                                      (forall ((@x12 Term))
                                       (! (implies
                                         (and
                                          (HasType @x12 Prims.pos)
                                          ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-244,40)
                                          (= @x2 @x12))
                                         ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-244,40)
                                         (forall ((@x13 Term))
                                          (! (implies
                                            (and
                                             (HasType @x13 Prims.int)
                                             ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-244,40)
                                             (=
                                              (Prims.op_Division
                                               (Prims.op_Addition @x0 (Prims.op_Multiply @x1 @x2))
                                               @x2)
                                              @x13))
                                            ;; def=Prims.fst(467,77-467,89); use=FStar.Math.Lemmas.fst(233,2-244,40)
                                            (and
                                             (implies
                                              ;; def=Prims.fst(685,18-685,23); use=FStar.Math.Lemmas.fst(244,34-244,35)
                                              (> (BoxInt_proj_0 @x2) (BoxInt_proj_0 (BoxInt 0)))
                                              ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(244,34-244,35)
                                              (or
                                               label_39
                                               ;; def=Prims.fst(688,22-688,28); use=FStar.Math.Lemmas.fst(244,34-244,35)
                                               (not (= @x2 (BoxInt 0)))))
                                             ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-244,40)
                                             (forall ((@x14 Term))
                                              (! (implies
                                                (and
                                                 (HasType @x14 Prims.pos)
                                                 ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-244,40)
                                                 (= @x2 @x14))
                                                ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-244,40)
                                                (forall ((@x15 Term))
                                                 (! (implies
                                                   (and
                                                    (HasType @x15 Prims.int)
                                                    ;; def=dummy(0,0-0,0); use=FStar.Math.Lemmas.fst(233,2-244,40)
                                                    (= (Prims.op_Division @x0 @x2) @x15))
                                                   ;; def=Prims.fst(459,66-459,102); use=FStar.Math.Lemmas.fst(233,2-244,40)
                                                   (forall ((@x16 Term))
                                                    (! (implies
                                                      (and
                                                       (HasType @x16 Prims.int)
                                                       ;; def=FStar.Math.Lemmas.fsti(50,22-50,23); use=FStar.Math.Lemmas.fst(233,2-244,40)
                                                       (=
                                                        (Prims.op_Subtraction
                                                         (Prims.op_Division
                                                          (Prims.op_Addition
                                                           @x0
                                                           (Prims.op_Multiply @x1 @x2))
                                                          @x2)
                                                         (Prims.op_Division @x0 @x2))
                                                        @x16))
                                                      ;; def=Prims.fst(449,29-449,97); use=FStar.Math.Lemmas.fst(244,2-244,18)
                                                      (and
                                                       ;; def=FStar.Math.Lemmas.fsti(50,61-50,76); use=FStar.Math.Lemmas.fst(244,2-244,18)
                                                       (or
                                                        label_40
                                                        ;; def=FStar.Math.Lemmas.fsti(50,61-50,76); use=FStar.Math.Lemmas.fst(244,2-244,18)
                                                        (=
                                                         (Prims.op_Multiply
                                                          (Prims.op_Subtraction
                                                           (Prims.op_Division
                                                            (Prims.op_Addition
                                                             @x0
                                                             (Prims.op_Multiply @x1 @x2))
                                                            @x2)
                                                           (Prims.op_Division @x0 @x2))
                                                          @x2)
                                                         (Prims.op_Multiply @x1 @x2)))
                                                       ;; def=Prims.fst(449,36-449,97); use=FStar.Math.Lemmas.fst(244,2-244,18)
                                                       (forall ((@x17 Term))
                                                        (! (implies
                                                          (and
                                                           (HasType @x17 Prims.unit)
                                                           ;; def=FStar.Math.Lemmas.fsti(50,87-50,94); use=FStar.Math.Lemmas.fst(244,2-244,18)
                                                           (=
                                                            (Prims.op_Subtraction
                                                             (Prims.op_Division
                                                              (Prims.op_Addition
                                                               @x0
                                                               (Prims.op_Multiply @x1 @x2))
                                                              @x2)
                                                             (Prims.op_Division @x0 @x2))
                                                            @x1))
                                                          ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(244,2-244,18)
                                                          (Valid
                                                           ;; def=Prims.fst(449,83-449,96); use=FStar.Math.Lemmas.fst(244,2-244,18)
                                                           (ApplyTT @x3 @x17)))
                                                         :qid @query.116))))
                                                     :qid @query.115)))
                                                  :qid @query.114)))
                                               :qid @query.113))))
                                           :qid @query.112)))
                                        :qid @query.111))))
                                    :qid @query.110))))
                                :qid @query.104))))
                            :qid @query.8)))
                         :qid @query.7)))
                      :qid @query.6)))
                   :qid @query.5))))
               :qid @query.4)))
            :qid @query.3))))
        :qid @query.1)))
     :qid @query)))
  :named @query))
(set-option :rlimit 1285595)
(echo "<initial_stats>")
(echo "<statistics>") (get-info :all-statistics) (echo "</statistics>")
(echo "</initial_stats>")
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>") (get-info :reason-unknown) (echo "</reason-unknown>")
(echo "<labels>")
(echo "label_40")
(eval label_40)
(echo "label_39")
(eval label_39)
(echo "label_38")
(eval label_38)
(echo "label_37")
(eval label_37)
(echo "label_36")
(eval label_36)
(echo "label_35")
(eval label_35)
(echo "label_34")
(eval label_34)
(echo "label_33")
(eval label_33)
(echo "label_32")
(eval label_32)
(echo "label_31")
(eval label_31)
(echo "label_30")
(eval label_30)
(echo "label_29")
(eval label_29)
(echo "label_28")
(eval label_28)
(echo "label_27")
(eval label_27)
(echo "label_26")
(eval label_26)
(echo "label_25")
(eval label_25)
(echo "label_24")
(eval label_24)
(echo "label_23")
(eval label_23)
(echo "label_22")
(eval label_22)
(echo "label_21")
(eval label_21)
(echo "label_20")
(eval label_20)
(echo "label_19")
(eval label_19)
(echo "label_18")
(eval label_18)
(echo "label_17")
(eval label_17)
(echo "label_16")
(eval label_16)
(echo "label_15")
(eval label_15)
(echo "label_14")
(eval label_14)
(echo "label_13")
(eval label_13)
(echo "label_12")
(eval label_12)
(echo "label_11")
(eval label_11)
(echo "label_10")
(eval label_10)
(echo "label_9")
(eval label_9)
(echo "label_8")
(eval label_8)
(echo "label_7")
(eval label_7)
(echo "label_6")
(eval label_6)
(echo "label_5")
(eval label_5)
(echo "label_4")
(eval label_4)
(echo "label_3")
(eval label_3)
(echo "label_2")
(eval label_2)
(echo "label_1")
(eval label_1)
(echo "</labels>")
(echo "Done!")
(pop) ;; 0}pop